VBoxInternalManage.cpp@ 13325

Last change on this file since 13325 was 12776, checked in by vboxsync, 16 years ago
fixed Linux builds
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 55.6 KB

Line
1	/** @file
2	*
3	* VBox frontends: VBoxManage (command-line interface):
4	* VBoxInternalManage
5	*
6	* VBoxInternalManage used to be a second CLI for doing special tricks,
7	* not intended for general usage, only for assisting VBox developers.
8	* It is now integrated into VBoxManage.
9	*/
10
11	/*
12	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
13	*
14	* This file is part of VirtualBox Open Source Edition (OSE), as
15	* available from http://www.virtualbox.org. This file is free software;
16	* you can redistribute it and/or modify it under the terms of the GNU
17	* General Public License (GPL) as published by the Free Software
18	* Foundation, in version 2 as it comes in the "COPYING" file of the
19	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
20	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
21	*
22	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
23	* Clara, CA 95054 USA or visit http://www.sun.com if you need
24	* additional information or have any questions.
25	*/
26
27
28
29	/*******************************************************************************
30	* Header Files *
31	*******************************************************************************/
32	#include <VBox/com/com.h>
33	#include <VBox/com/string.h>
34	#include <VBox/com/Guid.h>
35	#include <VBox/com/ErrorInfo.h>
36
37	#include <VBox/com/VirtualBox.h>
38
39	#include <iprt/runtime.h>
40	#include <iprt/stream.h>
41	#include <iprt/string.h>
42	#include <iprt/uuid.h>
43	#include <VBox/err.h>
44
45	#include <VBox/VBoxHDD.h>
46	#include <VBox/VBoxHDD-new.h>
47	#include <VBox/sup.h>
48
49	#include "VBoxManage.h"
50
51	/* Includes for the raw disk stuff. */
52	#ifdef RT_OS_WINDOWS
53	#include <windows.h>
54	#include <winioctl.h>
55	#elif defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS)
56	#include <errno.h>
57	#include <sys/ioctl.h>
58	#include <sys/types.h>
59	#include <sys/stat.h>
60	#include <fcntl.h>
61	#include <unistd.h>
62	#endif
63	#ifdef RT_OS_LINUX
64	#include <sys/utsname.h>
65	#include <linux/hdreg.h>
66	#include <linux/fs.h>
67	#endif /* RT_OS_LINUX */
68	#ifdef RT_OS_DARWIN
69	#include <sys/disk.h>
70	#endif /* RT_OS_DARWIN */
71	#ifdef RT_OS_SOLARIS
72	#include <stropts.h>
73	#include <sys/dkio.h>
74	#include <sys/vtoc.h>
75	#endif /* RT_OS_SOLARIS */
76
77	using namespace com;
78
79
80	/** Macro for checking whether a partition is of extended type or not. */
81	#define PARTTYPE_IS_EXTENDED(x) ((x) == 0x05 \|\| (x) == 0x0f \|\| (x) == 0x85)
82
83	/* Maximum number of partitions we can deal with. Ridiculously large number,
84	* but the memory consumption is rather low so who cares about never using
85	* most entries. */
86	#define HOSTPARTITION_MAX 100
87
88
89	typedef struct HOSTPARTITION
90	{
91	unsigned uIndex;
92	unsigned uType;
93	unsigned uStartCylinder;
94	unsigned uStartHead;
95	unsigned uStartSector;
96	unsigned uEndCylinder;
97	unsigned uEndHead;
98	unsigned uEndSector;
99	uint64_t uStart;
100	uint64_t uSize;
101	uint64_t uPartDataStart;
102	uint64_t cPartDataSectors;
103	} HOSTPARTITION, *PHOSTPARTITION;
104
105	typedef struct HOSTPARTITIONS
106	{
107	unsigned cPartitions;
108	HOSTPARTITION aPartitions[HOSTPARTITION_MAX];
109	} HOSTPARTITIONS, *PHOSTPARTITIONS;
110
111	/** flag whether we're in internal mode */
112	bool g_fInternalMode;
113
114	/**
115	* Print the usage info.
116	*/
117	void printUsageInternal(USAGECATEGORY u64Cmd)
118	{
119	RTPrintf("Usage: VBoxManage internalcommands <command> [command arguments]\n"
120	"\n"
121	"Commands:\n"
122	"\n"
123	"%s%s%s%s%s%s%s%s"
124	"WARNING: This is a development tool and shall only be used to analyse\n"
125	" problems. It is completely unsupported and will change in\n"
126	" incompatible ways without warning.\n",
127	(u64Cmd & USAGE_LOADSYMS) ?
128	" loadsyms <vmname>\|<uuid> <symfile> [delta] [module] [module address]\n"
129	" This will instruct DBGF to load the given symbolfile\n"
130	" during initialization.\n"
131	"\n"
132	: "",
133	(u64Cmd & USAGE_UNLOADSYMS) ?
134	" unloadsyms <vmname>\|<uuid> <symfile>\n"
135	" Removes <symfile> from the list of symbol files that\n"
136	" should be loaded during DBF initialization.\n"
137	"\n"
138	: "",
139	(u64Cmd & USAGE_SETVDIUUID) ?
140	" setvdiuuid <filepath>\n"
141	" Assigns a new UUID to the given VDI file. This way, multiple copies\n"
142	" of VDI containers can be registered.\n"
143	"\n"
144	: "",
145	(u64Cmd & USAGE_LISTPARTITIONS) ?
146	" listpartitions -rawdisk <diskname>\n"
147	" Lists all partitions on <diskname>.\n"
148	"\n"
149	: "",
150	(u64Cmd & USAGE_CREATERAWVMDK) ?
151	" createrawvmdk -filename <filename> -rawdisk <diskname>\n"
152	" [-partitions <list of partition numbers> [-mbr <filename>] ]\n"
153	" [-register] [-relative]\n"
154	" Creates a new VMDK image which gives access to an entite host disk (if\n"
155	" the parameter -partitions is not specified) or some partitions of a\n"
156	" host disk. If access to individual partitions is granted, then the\n"
157	" parameter -mbr can be used to specify an alternative MBR to be used\n"
158	" (the partitioning information in the MBR file is ignored).\n"
159	" The diskname is on Linux e.g. /dev/sda, and on Windows e.g.\n"
160	" \\\\.\\PhysicalDrive0).\n"
161	" On Linux host the parameter -relative causes a VMDK file to be created\n"
162	" which refers to individual partitions instead to the entire disk.\n"
163	" Optionally the created image can be immediately registered.\n"
164	" The necessary partition numbers can be queried with\n"
165	" VBoxManage internalcommands listpartitions\n"
166	"\n"
167	: "",
168	(u64Cmd & USAGE_RENAMEVMDK) ?
169	" renamevmdk -from <filename> -to <filename>\n"
170	" Renames an existing VMDK image, including the base file and all its extents.\n"
171	"\n"
172	: "",
173	(u64Cmd & USAGE_CONVERTTORAW) ?
174	" converttoraw [-format <fileformat>] <filename> <outputfile>"
175	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
176	"\|stdout"
177	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
178	"\n"
179	" Convert image to raw, writing to file"
180	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
181	" or stdout"
182	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
183	".\n"
184	"\n"
185	: "",
186	(u64Cmd & USAGE_CONVERTDISK) ?
187	" convertdisk [-srcformat <fmt>] [-dstformat <fmt>] <inputfile> <outputfile>"
188	"\n"
189	" Convert image to another image format.\n"
190	"\n"
191	: "",
192	#ifdef RT_OS_WINDOWS
193	(u64Cmd & USAGE_MODINSTALL) ?
194	" modinstall\n"
195	" Installs the neccessary driver for the host OS\n"
196	"\n"
197	: "",
198	(u64Cmd & USAGE_MODUNINSTALL) ?
199	" moduninstall\n"
200	" Deinstalls the driver\n"
201	"\n"
202	: ""
203	#else
204	"",
205	""
206	#endif
207	);
208	}
209
210	/** @todo this is no longer necessary, we can enumerate extra data */
211	/**
212	* Finds a new unique key name.
213	*
214	* I don't think this is 100% race condition proof, but we assumes
215	* the user is not trying to push this point.
216	*
217	* @returns Result from the insert.
218	* @param pMachine The Machine object.
219	* @param pszKeyBase The base key.
220	* @param rKey Reference to the string object in which we will return the key.
221	*/
222	static HRESULT NewUniqueKey(ComPtr<IMachine> pMachine, const char *pszKeyBase, Utf8Str &rKey)
223	{
224	Bstr Keys;
225	HRESULT hrc = pMachine->GetExtraData(Bstr(pszKeyBase), Keys.asOutParam());
226	if (FAILED(hrc))
227	return hrc;
228
229	/* if there are no keys, it's simple. */
230	if (Keys.isEmpty())
231	{
232	rKey = "1";
233	return pMachine->SetExtraData(Bstr(pszKeyBase), Bstr("1"));
234	}
235
236	/* find a unique number - brute force rulez. */
237	Utf8Str KeysUtf8(Keys);
238	const char *pszKeys = RTStrStripL(KeysUtf8.raw());
239	for (unsigned i = 1; i < 1000000; i++)
240	{
241	char szKey[32];
242	size_t cchKey = RTStrPrintf(szKey, sizeof(szKey), "%#x", i);
243	const char *psz = strstr(pszKeys, szKey);
244	while (psz)
245	{
246	if ( ( psz == pszKeys
247	\|\| psz[-1] == ' ')
248	&& ( psz[cchKey] == ' '
249	\|\| !psz[cchKey])
250	)
251	break;
252	psz = strstr(psz + cchKey, szKey);
253	}
254	if (!psz)
255	{
256	rKey = szKey;
257	Utf8StrFmt NewKeysUtf8("%s %s", pszKeys, szKey);
258	return pMachine->SetExtraData(Bstr(pszKeyBase), Bstr(NewKeysUtf8));
259	}
260	}
261	RTPrintf("Error: Cannot find unique key for '%s'!\n", pszKeyBase);
262	return E_FAIL;
263	}
264
265
266	#if 0
267	/**
268	* Remove a key.
269	*
270	* I don't think this isn't 100% race condition proof, but we assumes
271	* the user is not trying to push this point.
272	*
273	* @returns Result from the insert.
274	* @param pMachine The machine object.
275	* @param pszKeyBase The base key.
276	* @param pszKey The key to remove.
277	*/
278	static HRESULT RemoveKey(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey)
279	{
280	Bstr Keys;
281	HRESULT hrc = pMachine->GetExtraData(Bstr(pszKeyBase), Keys.asOutParam());
282	if (FAILED(hrc))
283	return hrc;
284
285	/* if there are no keys, it's simple. */
286	if (Keys.isEmpty())
287	return S_OK;
288
289	char *pszKeys;
290	int rc = RTUtf16ToUtf8(Keys.raw(), &pszKeys);
291	if (RT_SUCCESS(rc))
292	{
293	/* locate it */
294	size_t cchKey = strlen(pszKey);
295	char *psz = strstr(pszKeys, pszKey);
296	while (psz)
297	{
298	if ( ( psz == pszKeys
299	\|\| psz[-1] == ' ')
300	&& ( psz[cchKey] == ' '
301	\|\| !psz[cchKey])
302	)
303	break;
304	psz = strstr(psz + cchKey, pszKey);
305	}
306	if (psz)
307	{
308	/* remove it */
309	char *pszNext = RTStrStripL(psz + cchKey);
310	if (*pszNext)
311	memmove(psz, pszNext, strlen(pszNext) + 1);
312	else
313	*psz = '\0';
314	psz = RTStrStrip(pszKeys);
315
316	/* update */
317	hrc = pMachine->SetExtraData(Bstr(pszKeyBase), Bstr(psz));
318	}
319
320	RTStrFree(pszKeys);
321	return hrc;
322	}
323	else
324	RTPrintf("error: failed to delete key '%s' from '%s', string conversion error %Vrc!\n",
325	pszKey, pszKeyBase, rc);
326
327	return E_FAIL;
328	}
329	#endif
330
331
332	/**
333	* Sets a key value, does necessary error bitching.
334	*
335	* @returns COM status code.
336	* @param pMachine The Machine object.
337	* @param pszKeyBase The key base.
338	* @param pszKey The key.
339	* @param pszAttribute The attribute name.
340	* @param pszValue The string value.
341	*/
342	static HRESULT SetString(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char pszAttribute, const char pszValue)
343	{
344	HRESULT hrc = pMachine->SetExtraData(Bstr(Utf8StrFmt("%s/%s/%s", pszKeyBase, pszKey, pszAttribute)), Bstr(pszValue));
345	if (FAILED(hrc))
346	RTPrintf("error: Failed to set '%s/%s/%s' to '%s'! hrc=%#x\n",
347	pszKeyBase, pszKey, pszAttribute, pszValue, hrc);
348	return hrc;
349	}
350
351
352	/**
353	* Sets a key value, does necessary error bitching.
354	*
355	* @returns COM status code.
356	* @param pMachine The Machine object.
357	* @param pszKeyBase The key base.
358	* @param pszKey The key.
359	* @param pszAttribute The attribute name.
360	* @param u64Value The value.
361	*/
362	static HRESULT SetUInt64(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char *pszAttribute, uint64_t u64Value)
363	{
364	char szValue[64];
365	RTStrPrintf(szValue, sizeof(szValue), "%#RX64", u64Value);
366	return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue);
367	}
368
369
370	/**
371	* Sets a key value, does necessary error bitching.
372	*
373	* @returns COM status code.
374	* @param pMachine The Machine object.
375	* @param pszKeyBase The key base.
376	* @param pszKey The key.
377	* @param pszAttribute The attribute name.
378	* @param i64Value The value.
379	*/
380	static HRESULT SetInt64(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char *pszAttribute, int64_t i64Value)
381	{
382	char szValue[64];
383	RTStrPrintf(szValue, sizeof(szValue), "%RI64", i64Value);
384	return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue);
385	}
386
387
388	/**
389	* Identical to the 'loadsyms' command.
390	*/
391	static int CmdLoadSyms(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
392	{
393	HRESULT rc;
394
395	/*
396	* Get the VM
397	*/
398	ComPtr<IMachine> machine;
399	/* assume it's a UUID */
400	rc = aVirtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
401	if (FAILED(rc) \|\| !machine)
402	{
403	/* must be a name */
404	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()), 1);
405	}
406
407	/*
408	* Parse the command.
409	*/
410	const char *pszFilename;
411	int64_t offDelta = 0;
412	const char *pszModule = NULL;
413	uint64_t ModuleAddress = ~0;
414	uint64_t ModuleSize = 0;
415
416	/* filename */
417	if (argc < 2)
418	return errorArgument("Missing the filename argument!\n");
419	pszFilename = argv[1];
420
421	/* offDelta */
422	if (argc >= 3)
423	{
424	int rc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta);
425	if (VBOX_FAILURE(rc))
426	return errorArgument(argv[0], "Failed to read delta '%s', rc=%Vrc\n", argv[2], rc);
427	}
428
429	/* pszModule */
430	if (argc >= 4)
431	pszModule = argv[3];
432
433	/* ModuleAddress */
434	if (argc >= 5)
435	{
436	int rc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress);
437	if (VBOX_FAILURE(rc))
438	return errorArgument(argv[0], "Failed to read module address '%s', rc=%Vrc\n", argv[4], rc);
439	}
440
441	/* ModuleSize */
442	if (argc >= 6)
443	{
444	int rc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize);
445	if (VBOX_FAILURE(rc))
446	return errorArgument(argv[0], "Failed to read module size '%s', rc=%Vrc\n", argv[5], rc);
447	}
448
449	/*
450	* Add extra data.
451	*/
452	Utf8Str KeyStr;
453	HRESULT hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadsyms", KeyStr);
454	if (SUCCEEDED(hrc))
455	hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "Filename", pszFilename);
456	if (SUCCEEDED(hrc) && argc >= 3)
457	hrc = SetInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "Delta", offDelta);
458	if (SUCCEEDED(hrc) && argc >= 4)
459	hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "Module", pszModule);
460	if (SUCCEEDED(hrc) && argc >= 5)
461	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "ModuleAddress", ModuleAddress);
462	if (SUCCEEDED(hrc) && argc >= 6)
463	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "ModuleSize", ModuleSize);
464
465	return FAILED(hrc);
466	}
467
468	static int handleSetVDIUUID(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
469	{
470	/* we need exactly one parameter: the vdi file */
471	if (argc != 1)
472	{
473	return errorSyntax(USAGE_SETVDIUUID, "Not enough parameters");
474	}
475
476	/* generate a new UUID */
477	Guid uuid;
478	uuid.create();
479
480	/* just try it */
481	int rc = VDISetImageUUIDs(argv[0], uuid.raw(), NULL, NULL, NULL);
482	if (VBOX_FAILURE(rc))
483	{
484	RTPrintf("Error while setting a new UUID: %Vrc (%d)\n", rc, rc);
485	}
486	else
487	{
488	RTPrintf("UUID changed to: %s\n", uuid.toString().raw());
489	}
490
491	return 0;
492	}
493
494
495	static DECLCALLBACK(void) handleVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
496	{
497	RTPrintf("ERROR: ");
498	RTPrintfV(pszFormat, va);
499	RTPrintf("\n");
500	RTPrintf("Error code %Vrc at %s(%u) in function %s\n", rc, RT_SRC_POS_ARGS);
501	}
502
503	static int partRead(RTFILE File, PHOSTPARTITIONS pPart)
504	{
505	uint8_t aBuffer[512];
506	int rc;
507
508	pPart->cPartitions = 0;
509	memset(pPart->aPartitions, '\0', sizeof(pPart->aPartitions));
510	rc = RTFileReadAt(File, 0, &aBuffer, sizeof(aBuffer), NULL);
511	if (VBOX_FAILURE(rc))
512	return rc;
513	if (aBuffer[510] != 0x55 \|\| aBuffer[511] != 0xaa)
514	return VERR_INVALID_PARAMETER;
515
516	unsigned uExtended = (unsigned)-1;
517
518	for (unsigned i = 0; i < 4; i++)
519	{
520	uint8_t p = &aBuffer[0x1be + i 16];
521	if (p[4] == 0)
522	continue;
523	PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
524	pCP->uIndex = i + 1;
525	pCP->uType = p[4];
526	pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2);
527	pCP->uStartHead = p[1];
528	pCP->uStartSector = p[2] & 0x3f;
529	pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2);
530	pCP->uEndHead = p[5];
531	pCP->uEndSector = p[6] & 0x3f;
532	pCP->uStart = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
533	pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]);
534	pCP->uPartDataStart = 0; /* will be filled out later properly. */
535	pCP->cPartDataSectors = 0;
536
537	if (PARTTYPE_IS_EXTENDED(p[4]))
538	{
539	if (uExtended == (unsigned)-1)
540	uExtended = pCP - pPart->aPartitions;
541	else
542	{
543	RTPrintf("More than one extended partition. Aborting\n");
544	return VERR_INVALID_PARAMETER;
545	}
546	}
547	}
548
549	if (uExtended != (unsigned)-1)
550	{
551	unsigned uIndex = 5;
552	uint64_t uStart = pPart->aPartitions[uExtended].uStart;
553	uint64_t uOffset = 0;
554	if (!uStart)
555	{
556	RTPrintf("Inconsistency for logical partition start. Aborting\n");
557	return VERR_INVALID_PARAMETER;
558	}
559
560	do
561	{
562	rc = RTFileReadAt(File, (uStart + uOffset) * 512, &aBuffer, sizeof(aBuffer), NULL);
563	if (VBOX_FAILURE(rc))
564	return rc;
565
566	if (aBuffer[510] != 0x55 \|\| aBuffer[511] != 0xaa)
567	{
568	RTPrintf("Logical partition without magic. Aborting\n");
569	return VERR_INVALID_PARAMETER;
570	}
571	uint8_t *p = &aBuffer[0x1be];
572
573	if (p[4] == 0)
574	{
575	RTPrintf("Logical partition with type 0 encountered. Aborting\n");
576	return VERR_INVALID_PARAMETER;
577	}
578
579	PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
580	pCP->uIndex = uIndex;
581	pCP->uType = p[4];
582	pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2);
583	pCP->uStartHead = p[1];
584	pCP->uStartSector = p[2] & 0x3f;
585	pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2);
586	pCP->uEndHead = p[5];
587	pCP->uEndSector = p[6] & 0x3f;
588	uint32_t uStartOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
589	if (!uStartOffset)
590	{
591	RTPrintf("Invalid partition start offset. Aborting\n");
592	return VERR_INVALID_PARAMETER;
593	}
594	pCP->uStart = uStart + uOffset + uStartOffset;
595	pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]);
596	/* Fill out partitioning location info for EBR. */
597	pCP->uPartDataStart = uStart + uOffset;
598	pCP->cPartDataSectors = uStartOffset;
599	p += 16;
600	if (p[4] == 0)
601	uExtended = (unsigned)-1;
602	else if (PARTTYPE_IS_EXTENDED(p[4]))
603	{
604	uExtended = uIndex++;
605	uOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
606	}
607	else
608	{
609	RTPrintf("Logical partition chain broken. Aborting\n");
610	return VERR_INVALID_PARAMETER;
611	}
612	} while (uExtended != (unsigned)-1);
613	}
614
615	/* Sort partitions in ascending order of start sector, plus a trivial
616	* bit of consistency checking. */
617	for (unsigned i = 0; i < pPart->cPartitions-1; i++)
618	{
619	unsigned uMinIdx = i;
620	uint64_t uMinVal = pPart->aPartitions[i].uStart;
621	for (unsigned j = i + 1; j < pPart->cPartitions; j++)
622	{
623	if (pPart->aPartitions[j].uStart < uMinVal)
624	{
625	uMinIdx = j;
626	uMinVal = pPart->aPartitions[j].uStart;
627	}
628	else if (pPart->aPartitions[j].uStart == uMinVal)
629	{
630	RTPrintf("Two partitions start at the same place. Aborting\n");
631	return VERR_INVALID_PARAMETER;
632	} else if (pPart->aPartitions[j].uStart == 0)
633	{
634	RTPrintf("Partition starts at sector 0. Aborting\n");
635	return VERR_INVALID_PARAMETER;
636	}
637	}
638	if (uMinIdx != i)
639	{
640	/* Swap entries at index i and uMinIdx. */
641	memcpy(&pPart->aPartitions[pPart->cPartitions],
642	&pPart->aPartitions[i], sizeof(HOSTPARTITION));
643	memcpy(&pPart->aPartitions[i],
644	&pPart->aPartitions[uMinIdx], sizeof(HOSTPARTITION));
645	memcpy(&pPart->aPartitions[uMinIdx],
646	&pPart->aPartitions[pPart->cPartitions], sizeof(HOSTPARTITION));
647	}
648	}
649
650	/* Now do a lot of consistency checking. */
651	uint64_t uPrevEnd = 0;
652	for (unsigned i = 0; i < pPart->cPartitions-1; i++)
653	{
654	if (pPart->aPartitions[i].cPartDataSectors)
655	{
656	if (pPart->aPartitions[i].uPartDataStart < uPrevEnd)
657	{
658	RTPrintf("Overlapping partition description areas. Aborting\n");
659	return VERR_INVALID_PARAMETER;
660	}
661	uPrevEnd = pPart->aPartitions[i].uPartDataStart + pPart->aPartitions[i].cPartDataSectors;
662	}
663	if (pPart->aPartitions[i].uStart < uPrevEnd)
664	{
665	RTPrintf("Overlapping partitions. Aborting\n");
666	return VERR_INVALID_PARAMETER;
667	}
668	if (!PARTTYPE_IS_EXTENDED(pPart->aPartitions[i].uType))
669	uPrevEnd = pPart->aPartitions[i].uStart + pPart->aPartitions[i].uSize;
670	}
671
672	/* Fill out partitioning location info for MBR. */
673	pPart->aPartitions[0].uPartDataStart = 0;
674	pPart->aPartitions[0].cPartDataSectors = pPart->aPartitions[0].uStart;
675
676	return VINF_SUCCESS;
677	}
678
679	static int CmdListPartitions(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
680	{
681	Utf8Str rawdisk;
682
683	/* let's have a closer look at the arguments */
684	for (int i = 0; i < argc; i++)
685	{
686	if (strcmp(argv[i], "-rawdisk") == 0)
687	{
688	if (argc <= i + 1)
689	{
690	return errorArgument("Missing argument to '%s'", argv[i]);
691	}
692	i++;
693	rawdisk = argv[i];
694	}
695	else
696	{
697	return errorSyntax(USAGE_LISTPARTITIONS, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
698	}
699	}
700
701	if (rawdisk.isEmpty())
702	return errorSyntax(USAGE_LISTPARTITIONS, "Mandatory parameter -rawdisk missing");
703
704	RTFILE RawFile;
705	int vrc = RTFileOpen(&RawFile, rawdisk.raw(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE);
706	if (VBOX_FAILURE(vrc))
707	{
708	RTPrintf("Error opening the raw disk: %Vrc\n", vrc);
709	return vrc;
710	}
711
712	HOSTPARTITIONS partitions;
713	vrc = partRead(RawFile, &partitions);
714	if (VBOX_FAILURE(vrc))
715	return vrc;
716
717	RTPrintf("Number Type StartCHS EndCHS Size (MiB) Start (Sect)\n");
718	for (unsigned i = 0; i < partitions.cPartitions; i++)
719	{
720	/* Suppress printing the extended partition. Otherwise people
721	* might add it to the list of partitions for raw partition
722	* access (which is not good). */
723	if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
724	continue;
725
726	RTPrintf("%-7u %#04x %-4u/%-3u/%-2u %-4u/%-3u/%-2u %10llu %10llu\n",
727	partitions.aPartitions[i].uIndex,
728	partitions.aPartitions[i].uType,
729	partitions.aPartitions[i].uStartCylinder,
730	partitions.aPartitions[i].uStartHead,
731	partitions.aPartitions[i].uStartSector,
732	partitions.aPartitions[i].uEndCylinder,
733	partitions.aPartitions[i].uEndHead,
734	partitions.aPartitions[i].uEndSector,
735	partitions.aPartitions[i].uSize / 2048,
736	partitions.aPartitions[i].uStart);
737	}
738
739	return 0;
740	}
741
742	static int CmdCreateRawVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
743	{
744	HRESULT rc = S_OK;
745	Bstr filename;
746	const char *pszMBRFilename = NULL;
747	Utf8Str rawdisk;
748	const char *pszPartitions = NULL;
749	bool fRegister = false;
750	bool fRelative = false;
751
752	uint64_t cbSize = 0;
753	PVBOXHDD pDisk = NULL;
754	VBOXHDDRAW RawDescriptor;
755	HOSTPARTITIONS partitions;
756	uint32_t uPartitions = 0;
757	PVDINTERFACE pVDIfs = NULL;
758
759	/* let's have a closer look at the arguments */
760	for (int i = 0; i < argc; i++)
761	{
762	if (strcmp(argv[i], "-filename") == 0)
763	{
764	if (argc <= i + 1)
765	{
766	return errorArgument("Missing argument to '%s'", argv[i]);
767	}
768	i++;
769	filename = argv[i];
770	}
771	else if (strcmp(argv[i], "-mbr") == 0)
772	{
773	if (argc <= i + 1)
774	{
775	return errorArgument("Missing argument to '%s'", argv[i]);
776	}
777	i++;
778	pszMBRFilename = argv[i];
779	}
780	else if (strcmp(argv[i], "-rawdisk") == 0)
781	{
782	if (argc <= i + 1)
783	{
784	return errorArgument("Missing argument to '%s'", argv[i]);
785	}
786	i++;
787	rawdisk = argv[i];
788	}
789	else if (strcmp(argv[i], "-partitions") == 0)
790	{
791	if (argc <= i + 1)
792	{
793	return errorArgument("Missing argument to '%s'", argv[i]);
794	}
795	i++;
796	pszPartitions = argv[i];
797	}
798	else if (strcmp(argv[i], "-register") == 0)
799	{
800	fRegister = true;
801	}
802	#ifdef RT_OS_LINUX
803	else if (strcmp(argv[i], "-relative") == 0)
804	{
805	fRelative = true;
806	}
807	#endif /* RT_OS_LINUX */
808	else
809	{
810	return errorSyntax(USAGE_CREATERAWVMDK, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
811	}
812	}
813
814	if (filename.isEmpty())
815	return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -filename missing");
816	if (rawdisk.isEmpty())
817	return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -rawdisk missing");
818	if (!pszPartitions && pszMBRFilename)
819	return errorSyntax(USAGE_CREATERAWVMDK, "The parameter -mbr is only valid when the parameter -partitions is also present");
820
821	RTFILE RawFile;
822	int vrc = RTFileOpen(&RawFile, rawdisk.raw(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE);
823	if (VBOX_FAILURE(vrc))
824	{
825	RTPrintf("Error opening the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
826	goto out;
827	}
828
829	#ifdef RT_OS_WINDOWS
830	/* Windows NT has no IOCTL_DISK_GET_LENGTH_INFORMATION ioctl. This was
831	* added to Windows XP, so we have to use the available info from DriveGeo.
832	* Note that we cannot simply use IOCTL_DISK_GET_DRIVE_GEOMETRY as it
833	* yields a slightly different result than IOCTL_DISK_GET_LENGTH_INFO.
834	* We call IOCTL_DISK_GET_DRIVE_GEOMETRY first as we need to check the media
835	* type anyway, and if IOCTL_DISK_GET_LENGTH_INFORMATION is supported
836	* we will later override cbSize.
837	*/
838	DISK_GEOMETRY DriveGeo;
839	DWORD cbDriveGeo;
840	if (DeviceIoControl((HANDLE)RawFile,
841	IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
842	&DriveGeo, sizeof(DriveGeo), &cbDriveGeo, NULL))
843	{
844	if ( DriveGeo.MediaType == FixedMedia
845	\|\| DriveGeo.MediaType == RemovableMedia)
846	{
847	cbSize = DriveGeo.Cylinders.QuadPart
848	* DriveGeo.TracksPerCylinder
849	* DriveGeo.SectorsPerTrack
850	* DriveGeo.BytesPerSector;
851	}
852	else
853	{
854	RTPrintf("File '%s' is no fixed/removable medium device\n", rawdisk.raw());
855	vrc = VERR_INVALID_PARAMETER;
856	goto out;
857	}
858
859	GET_LENGTH_INFORMATION DiskLenInfo;
860	DWORD junk;
861	if (DeviceIoControl((HANDLE)RawFile,
862	IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
863	&DiskLenInfo, sizeof(DiskLenInfo), &junk, (LPOVERLAPPED)NULL))
864	{
865	/* IOCTL_DISK_GET_LENGTH_INFO is supported -- override cbSize. */
866	cbSize = DiskLenInfo.Length.QuadPart;
867	}
868	}
869	else
870	{
871	vrc = RTErrConvertFromWin32(GetLastError());
872	RTPrintf("Error getting the geometry of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
873	goto out;
874	}
875	#elif defined(RT_OS_LINUX)
876	struct stat DevStat;
877	if (!fstat(RawFile, &DevStat) && S_ISBLK(DevStat.st_mode))
878	{
879	#ifdef BLKGETSIZE64
880	/* BLKGETSIZE64 is broken up to 2.4.17 and in many 2.5.x. In 2.6.0
881	* it works without problems. */
882	struct utsname utsname;
883	if ( uname(&utsname) == 0
884	&& ( (strncmp(utsname.release, "2.5.", 4) == 0 && atoi(&utsname.release[4]) >= 18)
885	\|\| (strncmp(utsname.release, "2.", 2) == 0 && atoi(&utsname.release[2]) >= 6)))
886	{
887	uint64_t cbBlk;
888	if (!ioctl(RawFile, BLKGETSIZE64, &cbBlk))
889	cbSize = cbBlk;
890	}
891	#endif /* BLKGETSIZE64 */
892	if (!cbSize)
893	{
894	long cBlocks;
895	if (!ioctl(RawFile, BLKGETSIZE, &cBlocks))
896	cbSize = (uint64_t)cBlocks << 9;
897	else
898	{
899	vrc = RTErrConvertFromErrno(errno);
900	RTPrintf("Error getting the size of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
901	goto out;
902	}
903	}
904	}
905	else
906	{
907	RTPrintf("File '%s' is no block device\n", rawdisk.raw());
908	vrc = VERR_INVALID_PARAMETER;
909	goto out;
910	}
911	#elif defined(RT_OS_DARWIN)
912	struct stat DevStat;
913	if (!fstat(RawFile, &DevStat) && S_ISBLK(DevStat.st_mode))
914	{
915	uint64_t cBlocks;
916	uint32_t cbBlock;
917	if (!ioctl(RawFile, DKIOCGETBLOCKCOUNT, &cBlocks))
918	{
919	if (!ioctl(RawFile, DKIOCGETBLOCKSIZE, &cbBlock))
920	cbSize = cBlocks * cbBlock;
921	else
922	{
923	RTPrintf("Cannot get the block size for file '%s': %Vrc", rawdisk.raw(), vrc);
924	vrc = RTErrConvertFromErrno(errno);
925	goto out;
926	}
927	}
928	else
929	{
930	vrc = RTErrConvertFromErrno(errno);
931	RTPrintf("Cannot get the block count for file '%s': %Vrc", rawdisk.raw(), vrc);
932	goto out;
933	}
934	}
935	else
936	{
937	RTPrintf("File '%s' is no block device\n", rawdisk.raw());
938	vrc = VERR_INVALID_PARAMETER;
939	goto out;
940	}
941	#elif defined(RT_OS_SOLARIS)
942	struct stat DevStat;
943	if (!fstat(RawFile, &DevStat) && ( S_ISBLK(DevStat.st_mode)
944	\|\| S_ISCHR(DevStat.st_mode)))
945	{
946	struct dk_minfo mediainfo;
947	if (!ioctl(RawFile, DKIOCGMEDIAINFO, &mediainfo))
948	cbSize = mediainfo.dki_capacity * mediainfo.dki_lbsize;
949	else
950	{
951	vrc = RTErrConvertFromErrno(errno);
952	RTPrintf("Error getting the size of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
953	goto out;
954	}
955	}
956	else
957	{
958	RTPrintf("File '%s' is no block or char device\n", rawdisk.raw());
959	vrc = VERR_INVALID_PARAMETER;
960	goto out;
961	}
962	#else /* all unrecognized OSes */
963	/* Hopefully this works on all other hosts. If it doesn't, it'll just fail
964	* creating the VMDK, so no real harm done. */
965	vrc = RTFileGetSize(RawFile, &cbSize);
966	if (VBOX_FAILURE(vrc))
967	{
968	RTPrintf("Error getting the size of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
969	goto out;
970	}
971	#endif
972
973	/* Check whether cbSize is actually sensible. */
974	if (!cbSize \|\| cbSize % 512)
975	{
976	RTPrintf("Detected size of raw disk '%s' is %s, an invalid value\n", rawdisk.raw(), cbSize);
977	vrc = VERR_INVALID_PARAMETER;
978	goto out;
979	}
980
981	RawDescriptor.szSignature[0] = 'R';
982	RawDescriptor.szSignature[1] = 'A';
983	RawDescriptor.szSignature[2] = 'W';
984	RawDescriptor.szSignature[3] = '\0';
985	if (!pszPartitions)
986	{
987	RawDescriptor.fRawDisk = true;
988	RawDescriptor.pszRawDisk = rawdisk.raw();
989	}
990	else
991	{
992	RawDescriptor.fRawDisk = false;
993	RawDescriptor.pszRawDisk = NULL;
994	RawDescriptor.cPartitions = 0;
995
996	const char *p = pszPartitions;
997	char *pszNext;
998	uint32_t u32;
999	while (*p != '\0')
1000	{
1001	vrc = RTStrToUInt32Ex(p, &pszNext, 0, &u32);
1002	if (VBOX_FAILURE(vrc))
1003	{
1004	RTPrintf("Incorrect value in partitions parameter\n");
1005	goto out;
1006	}
1007	uPartitions \|= RT_BIT(u32);
1008	p = pszNext;
1009	if (*p == ',')
1010	p++;
1011	else if (*p != '\0')
1012	{
1013	RTPrintf("Incorrect separator in partitions parameter\n");
1014	vrc = VERR_INVALID_PARAMETER;
1015	goto out;
1016	}
1017	}
1018
1019	vrc = partRead(RawFile, &partitions);
1020	if (VBOX_FAILURE(vrc))
1021	{
1022	RTPrintf("Error reading the partition information from '%s'\n", rawdisk.raw());
1023	goto out;
1024	}
1025
1026	for (unsigned i = 0; i < partitions.cPartitions; i++)
1027	{
1028	if ( uPartitions & RT_BIT(partitions.aPartitions[i].uIndex)
1029	&& PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
1030	{
1031	/* Some ignorant user specified an extended partition.
1032	* Bad idea, as this would trigger an overlapping
1033	* partitions error later during VMDK creation. So warn
1034	* here and ignore what the user requested. */
1035	RTPrintf("Warning: it is not possible (and necessary) to explicitly give access to the\n"
1036	" extended partition %u. If required, enable access to all logical\n"
1037	" partitions inside this extended partition.\n", partitions.aPartitions[i].uIndex);
1038	uPartitions &= ~RT_BIT(partitions.aPartitions[i].uIndex);
1039	}
1040	}
1041
1042	RawDescriptor.cPartitions = partitions.cPartitions;
1043	RawDescriptor.pPartitions = (PVBOXHDDRAWPART)RTMemAllocZ(partitions.cPartitions * sizeof(VBOXHDDRAWPART));
1044	if (!RawDescriptor.pPartitions)
1045	{
1046	RTPrintf("Out of memory allocating the partition list for '%s'\n", rawdisk.raw());
1047	vrc = VERR_NO_MEMORY;
1048	goto out;
1049	}
1050	for (unsigned i = 0; i < partitions.cPartitions; i++)
1051	{
1052	if (uPartitions & RT_BIT(partitions.aPartitions[i].uIndex))
1053	{
1054	if (fRelative)
1055	{
1056	#ifdef RT_OS_LINUX
1057	/* Refer to the correct partition and use offset 0. */
1058	char *pszRawName;
1059	vrc = RTStrAPrintf(&pszRawName, "%s%u", rawdisk.raw(),
1060	partitions.aPartitions[i].uIndex);
1061	if (VBOX_FAILURE(vrc))
1062	{
1063	RTPrintf("Error creating reference to individual partition %u, rc=%Vrc\n",
1064	partitions.aPartitions[i].uIndex, vrc);
1065	goto out;
1066	}
1067	RawDescriptor.pPartitions[i].pszRawDevice = pszRawName;
1068	RawDescriptor.pPartitions[i].uPartitionStartOffset = 0;
1069	RawDescriptor.pPartitions[i].uPartitionStart = partitions.aPartitions[i].uStart * 512;
1070	#else
1071	/** @todo not implemented yet for Windows host. Treat just
1072	* like not specified (this code is actually never reached). */
1073	RawDescriptor.pPartitions[i].pszRawDevice = rawdisk.raw();
1074	RawDescriptor.pPartitions[i].uPartitionStartOffset = partitions.aPartitions[i].uStart * 512;
1075	RawDescriptor.pPartitions[i].uPartitionStart = partitions.aPartitions[i].uStart * 512;
1076	#endif
1077	}
1078	else
1079	{
1080	/* This is the "everything refers to the base raw device"
1081	* variant. This requires opening the base device in RW
1082	* mode even for creation. */
1083	RawDescriptor.pPartitions[i].pszRawDevice = rawdisk.raw();
1084	RawDescriptor.pPartitions[i].uPartitionStartOffset = partitions.aPartitions[i].uStart * 512;
1085	RawDescriptor.pPartitions[i].uPartitionStart = partitions.aPartitions[i].uStart * 512;
1086	}
1087	}
1088	else
1089	{
1090	/* Suppress access to this partition. */
1091	RawDescriptor.pPartitions[i].pszRawDevice = NULL;
1092	RawDescriptor.pPartitions[i].uPartitionStartOffset = 0;
1093	/* This is used in the plausibility check in the creation
1094	* code. In theory it's a dummy, but I don't want to make
1095	* the VMDK creatiion any more complicated than what it needs
1096	* to be. */
1097	RawDescriptor.pPartitions[i].uPartitionStart = partitions.aPartitions[i].uStart * 512;
1098	}
1099	if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
1100	{
1101	/* Suppress exporting the actual extended partition. Only
1102	* logical partitions should be processed. However completely
1103	* ignoring it leads to leaving out the MBR data. */
1104	RawDescriptor.pPartitions[i].cbPartition = 0;
1105	}
1106	else
1107	RawDescriptor.pPartitions[i].cbPartition = partitions.aPartitions[i].uSize * 512;
1108	RawDescriptor.pPartitions[i].uPartitionDataStart = partitions.aPartitions[i].uPartDataStart * 512;
1109	RawDescriptor.pPartitions[i].cbPartitionData = partitions.aPartitions[i].cPartDataSectors * 512;
1110	if (RawDescriptor.pPartitions[i].cbPartitionData)
1111	{
1112	Assert (RawDescriptor.pPartitions[i].cbPartitionData -
1113	(size_t)RawDescriptor.pPartitions[i].cbPartitionData == 0);
1114	void *pPartData = RTMemAlloc((size_t)RawDescriptor.pPartitions[i].cbPartitionData);
1115	if (!pPartData)
1116	{
1117	RTPrintf("Out of memory allocating the partition descriptor for '%s'\n", rawdisk.raw());
1118	vrc = VERR_NO_MEMORY;
1119	goto out;
1120	}
1121	vrc = RTFileReadAt(RawFile, partitions.aPartitions[i].uPartDataStart * 512, pPartData, (size_t)RawDescriptor.pPartitions[i].cbPartitionData, NULL);
1122	if (VBOX_FAILURE(vrc))
1123	{
1124	RTPrintf("Cannot read partition data from raw device '%s': %Vrc\n", rawdisk.raw(), vrc);
1125	goto out;
1126	}
1127	/* Splice in the replacement MBR code if specified. */
1128	if ( partitions.aPartitions[i].uPartDataStart == 0
1129	&& pszMBRFilename)
1130	{
1131	RTFILE MBRFile;
1132	vrc = RTFileOpen(&MBRFile, pszMBRFilename, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE);
1133	if (VBOX_FAILURE(vrc))
1134	{
1135	RTPrintf("Cannot open replacement MBR file '%s' specified with -mbr: %Vrc\n", pszMBRFilename, vrc);
1136	goto out;
1137	}
1138	vrc = RTFileReadAt(MBRFile, 0, pPartData, 0x1be, NULL);
1139	RTFileClose(MBRFile);
1140	if (VBOX_FAILURE(vrc))
1141	{
1142	RTPrintf("Cannot read replacement MBR file '%s': %Vrc\n", pszMBRFilename, vrc);
1143	goto out;
1144	}
1145	}
1146	RawDescriptor.pPartitions[i].pvPartitionData = pPartData;
1147	}
1148	}
1149	}
1150
1151	RTFileClose(RawFile);
1152
1153	VDINTERFACE vdInterfaceError;
1154	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1155	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1156	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1157	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1158
1159	vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1160	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1161	AssertRC(vrc);
1162
1163	vrc = VDCreate(&vdInterfaceError, &pDisk);
1164	if (VBOX_FAILURE(vrc))
1165	{
1166	RTPrintf("Error while creating the virtual disk container: %Vrc\n", vrc);
1167	goto out;
1168	}
1169
1170	Assert(RT_MIN(cbSize / 512 / 16 / 63, 16383) -
1171	(unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383) == 0);
1172	PDMMEDIAGEOMETRY PCHS, LCHS;
1173	PCHS.cCylinders = (unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383);
1174	PCHS.cHeads = 16;
1175	PCHS.cSectors = 63;
1176	LCHS.cCylinders = 0;
1177	LCHS.cHeads = 0;
1178	LCHS.cSectors = 0;
1179	vrc = VDCreateBase(pDisk, "VMDK", Utf8Str(filename).raw(),
1180	VD_IMAGE_TYPE_FIXED, cbSize,
1181	VD_VMDK_IMAGE_FLAGS_RAWDISK, (char *)&RawDescriptor,
1182	&PCHS, &LCHS, NULL, VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1183	if (VBOX_FAILURE(vrc))
1184	{
1185	RTPrintf("Error while creating the raw disk VMDK: %Vrc\n", vrc);
1186	goto out;
1187	}
1188	RTPrintf("RAW host disk access VMDK file %s created successfully.\n", Utf8Str(filename).raw());
1189
1190	VDCloseAll(pDisk);
1191
1192	/* Clean up allocated memory etc. */
1193	if (pszPartitions)
1194	{
1195	for (unsigned i = 0; i < partitions.cPartitions; i++)
1196	{
1197	if (uPartitions & RT_BIT(partitions.aPartitions[i].uIndex))
1198	{
1199	if (fRelative)
1200	{
1201	#ifdef RT_OS_LINUX
1202	/* Free memory allocated above. */
1203	RTStrFree((char )(void )RawDescriptor.pPartitions[i].pszRawDevice);
1204	#endif /* RT_OS_LINUX */
1205	}
1206	}
1207	}
1208	}
1209
1210	if (fRegister)
1211	{
1212	ComPtr<IHardDisk> hardDisk;
1213	CHECK_ERROR(aVirtualBox, OpenHardDisk(filename, hardDisk.asOutParam()));
1214
1215	if (SUCCEEDED(rc) && hardDisk)
1216	{
1217	CHECK_ERROR(aVirtualBox, RegisterHardDisk(hardDisk));
1218	}
1219	}
1220
1221	return SUCCEEDED(rc) ? 0 : 1;
1222
1223	out:
1224	RTPrintf("The raw disk vmdk file was not created\n");
1225	return VBOX_SUCCESS(vrc) ? 0 : 1;
1226	}
1227
1228	static int CmdRenameVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1229	{
1230	Bstr src;
1231	Bstr dst;
1232	/* Parse the arguments. */
1233	for (int i = 0; i < argc; i++)
1234	{
1235	if (strcmp(argv[i], "-from") == 0)
1236	{
1237	if (argc <= i + 1)
1238	{
1239	return errorArgument("Missing argument to '%s'", argv[i]);
1240	}
1241	i++;
1242	src = argv[i];
1243	}
1244	else if (strcmp(argv[i], "-to") == 0)
1245	{
1246	if (argc <= i + 1)
1247	{
1248	return errorArgument("Missing argument to '%s'", argv[i]);
1249	}
1250	i++;
1251	dst = argv[i];
1252	}
1253	else
1254	{
1255	return errorSyntax(USAGE_RENAMEVMDK, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
1256	}
1257	}
1258
1259	if (src.isEmpty())
1260	return errorSyntax(USAGE_RENAMEVMDK, "Mandatory parameter -from missing");
1261	if (dst.isEmpty())
1262	return errorSyntax(USAGE_RENAMEVMDK, "Mandatory parameter -to missing");
1263
1264	PVBOXHDD pDisk = NULL;
1265
1266	PVDINTERFACE pVDIfs = NULL;
1267	VDINTERFACE vdInterfaceError;
1268	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1269	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1270	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1271	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1272
1273	int vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1274	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1275	AssertRC(vrc);
1276
1277	vrc = VDCreate(&vdInterfaceError, &pDisk);
1278	if (VBOX_FAILURE(vrc))
1279	{
1280	RTPrintf("Error while creating the virtual disk container: %Vrc\n", vrc);
1281	return vrc;
1282	}
1283	else
1284	{
1285	vrc = VDOpen(pDisk, "VMDK", Utf8Str(src).raw(), VD_OPEN_FLAGS_NORMAL, NULL);
1286	if (VBOX_FAILURE(vrc))
1287	{
1288	RTPrintf("Error while opening the source image: %Vrc\n", vrc);
1289	}
1290	else
1291	{
1292	vrc = VDCopy(pDisk, 0, pDisk, "VMDK", Utf8Str(dst).raw(), true, 0, NULL, NULL, NULL);
1293	if (VBOX_FAILURE(vrc))
1294	{
1295	RTPrintf("Error while renaming the image: %Vrc\n", vrc);
1296	}
1297	}
1298	}
1299	VDCloseAll(pDisk);
1300	return vrc;
1301	}
1302
1303	static int CmdConvertToRaw(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1304	{
1305	Bstr srcformat;
1306	Bstr src;
1307	Bstr dst;
1308	bool fWriteToStdOut = false;
1309
1310	/* Parse the arguments. */
1311	for (int i = 0; i < argc; i++)
1312	{
1313	if (strcmp(argv[i], "-format") == 0)
1314	{
1315	if (argc <= i + 1)
1316	{
1317	return errorArgument("Missing argument to '%s'", argv[i]);
1318	}
1319	i++;
1320	srcformat = argv[i];
1321	}
1322	else if (src.isEmpty())
1323	{
1324	src = argv[i];
1325	}
1326	else if (dst.isEmpty())
1327	{
1328	dst = argv[i];
1329	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
1330	if (!strcmp(argv[i], "stdout"))
1331	fWriteToStdOut = true;
1332	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
1333	}
1334	else
1335	{
1336	return errorSyntax(USAGE_CONVERTTORAW, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
1337	}
1338	}
1339
1340	if (src.isEmpty())
1341	return errorSyntax(USAGE_CONVERTTORAW, "Mandatory filename parameter missing");
1342	if (dst.isEmpty())
1343	return errorSyntax(USAGE_CONVERTTORAW, "Mandatory outputfile parameter missing");
1344
1345	PVBOXHDD pDisk = NULL;
1346
1347	PVDINTERFACE pVDIfs = NULL;
1348	VDINTERFACE vdInterfaceError;
1349	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1350	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1351	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1352	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1353
1354	int vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1355	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1356	AssertRC(vrc);
1357
1358	vrc = VDCreate(&vdInterfaceError, &pDisk);
1359	if (VBOX_FAILURE(vrc))
1360	{
1361	RTPrintf("Error while creating the virtual disk container: %Vrc\n", vrc);
1362	return 1;
1363	}
1364
1365	/* Open raw output file. */
1366	RTFILE outFile;
1367	vrc = VINF_SUCCESS;
1368	if (fWriteToStdOut)
1369	outFile = 1;
1370	else
1371	vrc = RTFileOpen(&outFile, Utf8Str(dst).raw(), RTFILE_O_OPEN \| RTFILE_O_CREATE \| RTFILE_O_WRITE \| RTFILE_O_DENY_ALL);
1372	if (VBOX_FAILURE(vrc))
1373	{
1374	VDCloseAll(pDisk);
1375	RTPrintf("Error while creating destination file \"%s\": %Vrc\n", Utf8Str(dst).raw(), vrc);
1376	return 1;
1377	}
1378
1379	if (srcformat.isEmpty())
1380	{
1381	char *pszFormat = NULL;
1382	vrc = VDGetFormat(Utf8Str(src).raw(), &pszFormat);
1383	if (VBOX_FAILURE(vrc))
1384	{
1385	VDCloseAll(pDisk);
1386	if (!fWriteToStdOut)
1387	{
1388	RTFileClose(outFile);
1389	RTFileDelete(Utf8Str(dst).raw());
1390	}
1391	RTPrintf("No file format specified and autodetect failed - please specify format: %Vrc\n", vrc);
1392	return 1;
1393	}
1394	srcformat = pszFormat;
1395	RTStrFree(pszFormat);
1396	}
1397	vrc = VDOpen(pDisk, Utf8Str(srcformat).raw(), Utf8Str(src).raw(), VD_OPEN_FLAGS_READONLY, NULL);
1398	if (VBOX_FAILURE(vrc))
1399	{
1400	VDCloseAll(pDisk);
1401	if (!fWriteToStdOut)
1402	{
1403	RTFileClose(outFile);
1404	RTFileDelete(Utf8Str(dst).raw());
1405	}
1406	RTPrintf("Error while opening the source image: %Vrc\n", vrc);
1407	return 1;
1408	}
1409
1410	uint64_t cbSize = VDGetSize(pDisk, VD_LAST_IMAGE);
1411	uint64_t offFile = 0;
1412	#define RAW_BUFFER_SIZE _128K
1413	uint64_t cbBuf = RAW_BUFFER_SIZE;
1414	void *pvBuf = RTMemAlloc(cbBuf);
1415	if (pvBuf)
1416	{
1417	RTPrintf("Converting image \"%s\" with size %RU64 bytes (%RU64MB) to raw...\n", Utf8Str(src).raw(), cbSize, (cbSize + _1M - 1) / _1M);
1418	while (offFile < cbSize)
1419	{
1420	size_t cb = cbSize - offFile >= (uint64_t)cbBuf ? cbBuf : (size_t)(cbSize - offFile);
1421	vrc = VDRead(pDisk, offFile, pvBuf, cb);
1422	if (VBOX_FAILURE(vrc))
1423	break;
1424	vrc = RTFileWrite(outFile, pvBuf, cb, NULL);
1425	if (VBOX_FAILURE(vrc))
1426	break;
1427	offFile += cb;
1428	}
1429	if (VBOX_FAILURE(vrc))
1430	{
1431	VDCloseAll(pDisk);
1432	if (!fWriteToStdOut)
1433	{
1434	RTFileClose(outFile);
1435	RTFileDelete(Utf8Str(dst).raw());
1436	}
1437	RTPrintf("Error copying image data: %Vrc\n", vrc);
1438	return 1;
1439	}
1440	}
1441	else
1442	{
1443	vrc = VERR_NO_MEMORY;
1444	VDCloseAll(pDisk);
1445	if (!fWriteToStdOut)
1446	{
1447	RTFileClose(outFile);
1448	RTFileDelete(Utf8Str(dst).raw());
1449	}
1450	RTPrintf("Error allocating read buffer: %Vrc\n", vrc);
1451	return 1;
1452	}
1453
1454	if (!fWriteToStdOut)
1455	RTFileClose(outFile);
1456	VDCloseAll(pDisk);
1457	return 0;
1458	}
1459
1460	static int CmdConvertDisk(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1461	{
1462	Bstr srcformat;
1463	Bstr dstformat;
1464	Bstr src;
1465	Bstr dst;
1466	int vrc;
1467	PVBOXHDD pSrcDisk = NULL;
1468	PVBOXHDD pDstDisk = NULL;
1469
1470	/* Parse the arguments. */
1471	for (int i = 0; i < argc; i++)
1472	{
1473	if (strcmp(argv[i], "-srcformat") == 0)
1474	{
1475	if (argc <= i + 1)
1476	{
1477	return errorArgument("Missing argument to '%s'", argv[i]);
1478	}
1479	i++;
1480	srcformat = argv[i];
1481	}
1482	else if (strcmp(argv[i], "-dstformat") == 0)
1483	{
1484	if (argc <= i + 1)
1485	{
1486	return errorArgument("Missing argument to '%s'", argv[i]);
1487	}
1488	i++;
1489	dstformat = argv[i];
1490	}
1491	else if (src.isEmpty())
1492	{
1493	src = argv[i];
1494	}
1495	else if (dst.isEmpty())
1496	{
1497	dst = argv[i];
1498	}
1499	else
1500	{
1501	return errorSyntax(USAGE_CONVERTDISK, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
1502	}
1503	}
1504
1505	if (src.isEmpty())
1506	return errorSyntax(USAGE_CONVERTDISK, "Mandatory input image parameter missing");
1507	if (dst.isEmpty())
1508	return errorSyntax(USAGE_CONVERTDISK, "Mandatory output image parameter missing");
1509
1510
1511	PVDINTERFACE pVDIfs = NULL;
1512	VDINTERFACE vdInterfaceError;
1513	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1514	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1515	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1516	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1517
1518	vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1519	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1520	AssertRC(vrc);
1521
1522	do
1523	{
1524	/* Try to determine input image format */
1525	if (srcformat.isEmpty())
1526	{
1527	char *pszFormat = NULL;
1528	vrc = VDGetFormat(Utf8Str(src).raw(), &pszFormat);
1529	if (VBOX_FAILURE(vrc))
1530	{
1531	RTPrintf("No file format specified and autodetect failed - please specify format: %Vrc\n", vrc);
1532	break;
1533	}
1534	srcformat = pszFormat;
1535	RTStrFree(pszFormat);
1536	}
1537
1538	vrc = VDCreate(&vdInterfaceError, &pSrcDisk);
1539	if (VBOX_FAILURE(vrc))
1540	{
1541	RTPrintf("Error while creating the source virtual disk container: %Vrc\n", vrc);
1542	break;
1543	}
1544
1545	/* Open the input image */
1546	vrc = VDOpen(pSrcDisk, Utf8Str(srcformat).raw(), Utf8Str(src).raw(), VD_OPEN_FLAGS_READONLY, NULL);
1547	if (VBOX_FAILURE(vrc))
1548	{
1549	RTPrintf("Error while opening the source image: %Vrc\n", vrc);
1550	break;
1551	}
1552
1553	/* Output format defaults to VDI */
1554	if (dstformat.isEmpty())
1555	dstformat = "VDI";
1556
1557	vrc = VDCreate(&vdInterfaceError, &pDstDisk);
1558	if (VBOX_FAILURE(vrc))
1559	{
1560	RTPrintf("Error while creating the destination virtual disk container: %Vrc\n", vrc);
1561	break;
1562	}
1563
1564	uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE);
1565	RTPrintf("Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", Utf8Str(src).raw(), cbSize, (cbSize + _1M - 1) / _1M);
1566
1567	/* Create the output image */
1568	vrc = VDCopy(pSrcDisk, VD_LAST_IMAGE, pDstDisk, Utf8Str(dstformat).raw(),
1569	Utf8Str(dst).raw(), false, 0, NULL, NULL, NULL);
1570	if (VBOX_FAILURE(vrc))
1571	{
1572	RTPrintf("Error while copying the image: %Vrc\n", vrc);
1573	break;
1574	}
1575	}
1576	while (0);
1577
1578	if (pDstDisk)
1579	VDCloseAll(pDstDisk);
1580	if (pSrcDisk)
1581	VDCloseAll(pSrcDisk);
1582
1583	return VBOX_SUCCESS(vrc) ? 0 : 1;
1584	}
1585
1586	/**
1587	* Unloads the neccessary driver.
1588	*
1589	* @returns VBox status code
1590	*/
1591	int CmdModUninstall(void)
1592	{
1593	int rc;
1594
1595	rc = SUPUninstall();
1596	if (RT_SUCCESS(rc))
1597	return 0;
1598	if (rc == VERR_NOT_IMPLEMENTED)
1599	return 0;
1600	return E_FAIL;
1601	}
1602
1603	/**
1604	* Loads the neccessary driver.
1605	*
1606	* @returns VBox status code
1607	*/
1608	int CmdModInstall(void)
1609	{
1610	int rc;
1611
1612	rc = SUPInstall();
1613	if (RT_SUCCESS(rc))
1614	return 0;
1615	if (rc == VERR_NOT_IMPLEMENTED)
1616	return 0;
1617	return E_FAIL;
1618	}
1619
1620	/**
1621	* Wrapper for handling internal commands
1622	*/
1623	int handleInternalCommands(int argc, char *argv[],
1624	ComPtr <IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1625	{
1626	g_fInternalMode = true;
1627
1628	/* at least a command is required */
1629	if (argc < 1)
1630	return errorSyntax(USAGE_ALL, "Command missing");
1631
1632	/*
1633	* The 'string switch' on command name.
1634	*/
1635	const char *pszCmd = argv[0];
1636	if (!strcmp(pszCmd, "loadsyms"))
1637	return CmdLoadSyms(argc - 1, &argv[1], aVirtualBox, aSession);
1638	//if (!strcmp(pszCmd, "unloadsyms"))
1639	// return CmdUnloadSyms(argc - 1 , &argv[1]);
1640	if (!strcmp(pszCmd, "setvdiuuid"))
1641	return handleSetVDIUUID(argc - 1, &argv[1], aVirtualBox, aSession);
1642	if (!strcmp(pszCmd, "listpartitions"))
1643	return CmdListPartitions(argc - 1, &argv[1], aVirtualBox, aSession);
1644	if (!strcmp(pszCmd, "createrawvmdk"))
1645	return CmdCreateRawVMDK(argc - 1, &argv[1], aVirtualBox, aSession);
1646	if (!strcmp(pszCmd, "renamevmdk"))
1647	return CmdRenameVMDK(argc - 1, &argv[1], aVirtualBox, aSession);
1648	if (!strcmp(pszCmd, "converttoraw"))
1649	return CmdConvertToRaw(argc - 1, &argv[1], aVirtualBox, aSession);
1650	if (!strcmp(pszCmd, "convertdisk"))
1651	return CmdConvertDisk(argc - 1, &argv[1], aVirtualBox, aSession);
1652
1653	if (!strcmp(pszCmd, "modinstall"))
1654	return CmdModInstall();
1655	if (!strcmp(pszCmd, "moduninstall"))
1656	return CmdModUninstall();
1657
1658	/* default: */
1659	return errorSyntax(USAGE_ALL, "Invalid command '%s'", Utf8Str(argv[0]).raw());
1660	}

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp@ 13325

Download in other formats: