VBoxManageStorageController.cpp@ 86663

Last change on this file since 86663 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.4 KB

Line
1	/* $Id: VBoxManageStorageController.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* VBoxManage - The storage controller related commands.
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	#ifndef VBOX_ONLY_DOCS
19
20
21	/*********************************************************************************************************************************
22	* Header Files *
23	*********************************************************************************************************************************/
24	#include <VBox/com/com.h>
25	#include <VBox/com/array.h>
26	#include <VBox/com/ErrorInfo.h>
27	#include <VBox/com/errorprint.h>
28	#include <VBox/com/VirtualBox.h>
29
30	#include <iprt/path.h>
31	#include <iprt/param.h>
32	#include <iprt/string.h>
33	#include <iprt/ctype.h>
34	#include <iprt/stream.h>
35	#include <iprt/getopt.h>
36	#include <VBox/log.h>
37
38	#include "VBoxManage.h"
39	using namespace com;
40
41
42	// funcs
43	///////////////////////////////////////////////////////////////////////////////
44
45
46	static const RTGETOPTDEF g_aStorageAttachOptions[] =
47	{
48	{ "--storagectl", 's', RTGETOPT_REQ_STRING },
49	{ "--port", 'p', RTGETOPT_REQ_UINT32 },
50	{ "--device", 'd', RTGETOPT_REQ_UINT32 },
51	{ "--type", 't', RTGETOPT_REQ_STRING },
52	{ "--medium", 'm', RTGETOPT_REQ_STRING },
53	{ "--mtype", 'M', RTGETOPT_REQ_STRING },
54	{ "--passthrough", 'h', RTGETOPT_REQ_STRING },
55	{ "--tempeject", 'e', RTGETOPT_REQ_STRING },
56	{ "--nonrotational", 'n', RTGETOPT_REQ_STRING },
57	{ "--discard", 'u', RTGETOPT_REQ_STRING },
58	{ "--hotpluggable", 'o', RTGETOPT_REQ_STRING },
59	{ "--bandwidthgroup", 'b', RTGETOPT_REQ_STRING },
60	{ "--forceunmount", 'f', RTGETOPT_REQ_NOTHING },
61	{ "--comment", 'C', RTGETOPT_REQ_STRING },
62	{ "--setuuid", 'q', RTGETOPT_REQ_STRING },
63	{ "--setparentuuid", 'Q', RTGETOPT_REQ_STRING },
64	// iSCSI options
65	{ "--server", 'S', RTGETOPT_REQ_STRING },
66	{ "--target", 'T', RTGETOPT_REQ_STRING },
67	{ "--tport", 'P', RTGETOPT_REQ_STRING },
68	{ "--lun", 'L', RTGETOPT_REQ_STRING },
69	{ "--encodedlun", 'E', RTGETOPT_REQ_STRING },
70	{ "--username", 'U', RTGETOPT_REQ_STRING },
71	{ "--password", 'W', RTGETOPT_REQ_STRING },
72	{ "--passwordfile", 'w', RTGETOPT_REQ_STRING },
73	{ "--initiator", 'N', RTGETOPT_REQ_STRING },
74	{ "--intnet", 'I', RTGETOPT_REQ_NOTHING },
75	};
76
77	RTEXITCODE handleStorageAttach(HandlerArg *a)
78	{
79	int c = VERR_INTERNAL_ERROR; /* initialized to shut up gcc */
80	HRESULT rc = S_OK;
81	ULONG port = ~0U;
82	ULONG device = ~0U;
83	bool fForceUnmount = false;
84	bool fSetMediumType = false;
85	bool fSetNewUuid = false;
86	bool fSetNewParentUuid = false;
87	MediumType_T enmMediumType = MediumType_Normal;
88	Bstr bstrComment;
89	const char *pszCtl = NULL;
90	DeviceType_T devTypeRequested = DeviceType_Null;
91	const char *pszMedium = NULL;
92	const char *pszPassThrough = NULL;
93	const char *pszTempEject = NULL;
94	const char *pszNonRotational = NULL;
95	const char *pszDiscard = NULL;
96	const char *pszHotPluggable = NULL;
97	const char *pszBandwidthGroup = NULL;
98	Bstr bstrNewUuid;
99	Bstr bstrNewParentUuid;
100	// iSCSI options
101	Bstr bstrServer;
102	Bstr bstrTarget;
103	Bstr bstrPort;
104	Bstr bstrLun;
105	Bstr bstrUsername;
106	Bstr bstrPassword;
107	Bstr bstrInitiator;
108	Bstr bstrIso;
109	Utf8Str strIso;
110	bool fIntNet = false;
111
112	RTGETOPTUNION ValueUnion;
113	RTGETOPTSTATE GetState;
114	ComPtr<IMachine> machine;
115	ComPtr<IStorageController> storageCtl;
116	ComPtr<ISystemProperties> systemProperties;
117
118	RTGetOptInit(&GetState, a->argc, a->argv, g_aStorageAttachOptions,
119	RT_ELEMENTS(g_aStorageAttachOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
120
121	while ( SUCCEEDED(rc)
122	&& (c = RTGetOpt(&GetState, &ValueUnion)))
123	{
124	switch (c)
125	{
126	case 's': // storage controller name
127	{
128	if (ValueUnion.psz)
129	pszCtl = ValueUnion.psz;
130	else
131	rc = E_FAIL;
132	break;
133	}
134
135	case 'p': // port
136	{
137	port = ValueUnion.u32;
138	break;
139	}
140
141	case 'd': // device
142	{
143	device = ValueUnion.u32;
144	break;
145	}
146
147	case 'm': // medium <none\|emptydrive\|additions\|uuid\|filename\|host:<drive>\|iSCSI>
148	{
149	if (ValueUnion.psz)
150	pszMedium = ValueUnion.psz;
151	else
152	rc = E_FAIL;
153	break;
154	}
155
156	case 't': // type <dvddrive\|hdd\|fdd>
157	{
158	if (ValueUnion.psz)
159	{
160	if (!RTStrICmp(ValueUnion.psz, "hdd"))
161	devTypeRequested = DeviceType_HardDisk;
162	else if (!RTStrICmp(ValueUnion.psz, "fdd"))
163	devTypeRequested = DeviceType_Floppy;
164	else if (!RTStrICmp(ValueUnion.psz, "dvddrive"))
165	devTypeRequested = DeviceType_DVD;
166	else
167	return errorArgument("Invalid --type argument '%s'", ValueUnion.psz);
168	}
169	else
170	rc = E_FAIL;
171	break;
172	}
173
174	case 'h': // passthrough <on\|off>
175	{
176	if (ValueUnion.psz)
177	pszPassThrough = ValueUnion.psz;
178	else
179	rc = E_FAIL;
180	break;
181	}
182
183	case 'e': // tempeject <on\|off>
184	{
185	if (ValueUnion.psz)
186	pszTempEject = ValueUnion.psz;
187	else
188	rc = E_FAIL;
189	break;
190	}
191
192	case 'n': // nonrotational <on\|off>
193	{
194	if (ValueUnion.psz)
195	pszNonRotational = ValueUnion.psz;
196	else
197	rc = E_FAIL;
198	break;
199	}
200
201	case 'u': // discard <on\|off>
202	{
203	if (ValueUnion.psz)
204	pszDiscard = ValueUnion.psz;
205	else
206	rc = E_FAIL;
207	break;
208	}
209
210	case 'o': // hotpluggable <on\|off>
211	{
212	if (ValueUnion.psz)
213	pszHotPluggable = ValueUnion.psz;
214	else
215	rc = E_FAIL;
216	break;
217	}
218
219	case 'b': // bandwidthgroup <name>
220	{
221	if (ValueUnion.psz)
222	pszBandwidthGroup = ValueUnion.psz;
223	else
224	rc = E_FAIL;
225	break;
226	}
227
228	case 'f': // force unmount medium during runtime
229	{
230	fForceUnmount = true;
231	break;
232	}
233
234	case 'C':
235	if (ValueUnion.psz)
236	bstrComment = ValueUnion.psz;
237	else
238	rc = E_FAIL;
239	break;
240
241	case 'q':
242	if (ValueUnion.psz)
243	{
244	bstrNewUuid = ValueUnion.psz;
245	fSetNewUuid = true;
246	}
247	else
248	rc = E_FAIL;
249	break;
250
251	case 'Q':
252	if (ValueUnion.psz)
253	{
254	bstrNewParentUuid = ValueUnion.psz;
255	fSetNewParentUuid = true;
256	}
257	else
258	rc = E_FAIL;
259	break;
260
261	case 'S': // --server
262	bstrServer = ValueUnion.psz;
263	break;
264
265	case 'T': // --target
266	bstrTarget = ValueUnion.psz;
267	break;
268
269	case 'P': // --tport
270	bstrPort = ValueUnion.psz;
271	break;
272
273	case 'L': // --lun
274	bstrLun = ValueUnion.psz;
275	break;
276
277	case 'E': // --encodedlun
278	bstrLun = BstrFmt("enc%s", ValueUnion.psz);
279	break;
280
281	case 'U': // --username
282	bstrUsername = ValueUnion.psz;
283	break;
284
285	case 'W': // --password
286	bstrPassword = ValueUnion.psz;
287	break;
288
289	case 'w': // --passwordFile
290	{
291	Utf8Str utf8Password;
292	RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &utf8Password);
293	if (rcExit != RTEXITCODE_SUCCESS)
294	rc = E_FAIL;
295	bstrPassword = utf8Password;
296	break;
297	}
298	case 'N': // --initiator
299	bstrInitiator = ValueUnion.psz;
300	break;
301
302	case 'M': // --type
303	{
304	int vrc = parseMediumType(ValueUnion.psz, &enmMediumType);
305	if (RT_FAILURE(vrc))
306	return errorArgument("Invalid medium type '%s'", ValueUnion.psz);
307	fSetMediumType = true;
308	break;
309	}
310
311	case 'I': // --intnet
312	fIntNet = true;
313	break;
314
315	default:
316	{
317	errorGetOpt(USAGE_STORAGEATTACH, c, &ValueUnion);
318	rc = E_FAIL;
319	break;
320	}
321	}
322	}
323
324	if (FAILED(rc))
325	return RTEXITCODE_FAILURE;
326
327	if (!pszCtl)
328	return errorSyntax(USAGE_STORAGEATTACH, "Storage controller name not specified");
329
330	/* get the virtualbox system properties */
331	CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), RTEXITCODE_FAILURE);
332
333	// find the machine, lock it, get the mutable session machine
334	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
335	machine.asOutParam()), RTEXITCODE_FAILURE);
336	CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
337	SessionType_T st;
338	CHECK_ERROR_RET(a->session, COMGETTER(Type)(&st), RTEXITCODE_FAILURE);
339	a->session->COMGETTER(Machine)(machine.asOutParam());
340
341	try
342	{
343	bool fRunTime = (st == SessionType_Shared);
344
345	if (fRunTime)
346	{
347	if (pszPassThrough)
348	throw Utf8Str("Drive passthrough state cannot be changed while the VM is running\n");
349	else if (pszBandwidthGroup)
350	throw Utf8Str("Bandwidth group cannot be changed while the VM is running\n");
351	}
352
353	/* check if the storage controller is present */
354	rc = machine->GetStorageControllerByName(Bstr(pszCtl).raw(),
355	storageCtl.asOutParam());
356	if (FAILED(rc))
357	throw Utf8StrFmt("Could not find a controller named '%s'\n", pszCtl);
358
359	StorageBus_T storageBus = StorageBus_Null;
360	CHECK_ERROR_RET(storageCtl, COMGETTER(Bus)(&storageBus), RTEXITCODE_FAILURE);
361	ULONG maxPorts = 0;
362	CHECK_ERROR_RET(systemProperties, GetMaxPortCountForStorageBus(storageBus, &maxPorts), RTEXITCODE_FAILURE);
363	ULONG maxDevices = 0;
364	CHECK_ERROR_RET(systemProperties, GetMaxDevicesPerPortForStorageBus(storageBus, &maxDevices), RTEXITCODE_FAILURE);
365
366	if (port == ~0U)
367	{
368	if (maxPorts == 1)
369	port = 0;
370	else
371	return errorSyntax(USAGE_STORAGEATTACH, "Port not specified");
372	}
373	if (device == ~0U)
374	{
375	if (maxDevices == 1)
376	device = 0;
377	else
378	return errorSyntax(USAGE_STORAGEATTACH, "Device not specified");
379	}
380
381	/* for sata controller check if the port count is big enough
382	* to accommodate the current port which is being assigned
383	* else just increase the port count
384	*/
385	{
386	ULONG ulPortCount = 0;
387	ULONG ulMaxPortCount = 0;
388
389	CHECK_ERROR(storageCtl, COMGETTER(MaxPortCount)(&ulMaxPortCount));
390	CHECK_ERROR(storageCtl, COMGETTER(PortCount)(&ulPortCount));
391
392	if ( (ulPortCount != ulMaxPortCount)
393	&& (port >= ulPortCount)
394	&& (port < ulMaxPortCount))
395	CHECK_ERROR(storageCtl, COMSETTER(PortCount)(port + 1));
396	}
397
398	StorageControllerType_T ctlType = StorageControllerType_Null;
399	CHECK_ERROR(storageCtl, COMGETTER(ControllerType)(&ctlType));
400
401	if (!RTStrICmp(pszMedium, "none"))
402	{
403	CHECK_ERROR(machine, DetachDevice(Bstr(pszCtl).raw(), port, device));
404	}
405	else if (!RTStrICmp(pszMedium, "emptydrive"))
406	{
407	if (fRunTime)
408	{
409	ComPtr<IMediumAttachment> mediumAttachment;
410	DeviceType_T deviceType = DeviceType_Null;
411	rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, device,
412	mediumAttachment.asOutParam());
413	if (SUCCEEDED(rc))
414	{
415	mediumAttachment->COMGETTER(Type)(&deviceType);
416
417	if ( (deviceType == DeviceType_DVD)
418	\|\| (deviceType == DeviceType_Floppy))
419	{
420	/* just unmount the floppy/dvd */
421	CHECK_ERROR(machine, UnmountMedium(Bstr(pszCtl).raw(),
422	port,
423	device,
424	fForceUnmount));
425	}
426	}
427	else if (devTypeRequested == DeviceType_DVD)
428	{
429	/*
430	* Try to attach an empty DVD drive as a hotplug operation.
431	* Main will complain if the controller doesn't support hotplugging.
432	*/
433	CHECK_ERROR(machine, AttachDeviceWithoutMedium(Bstr(pszCtl).raw(), port, device,
434	devTypeRequested));
435	deviceType = DeviceType_DVD; /* To avoid the error message below. */
436	}
437
438	if ( FAILED(rc)
439	\|\| !( deviceType == DeviceType_DVD
440	\|\| deviceType == DeviceType_Floppy)
441	)
442	throw Utf8StrFmt("No DVD/Floppy Drive attached to the controller '%s'"
443	"at the port: %u, device: %u", pszCtl, port, device);
444
445	}
446	else
447	{
448	DeviceType_T deviceType = DeviceType_Null;
449	com::SafeArray <DeviceType_T> saDeviceTypes;
450	ULONG driveCheck = 0;
451
452	/* check if the device type is supported by the controller */
453	CHECK_ERROR(systemProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes)));
454	for (size_t i = 0; i < saDeviceTypes.size(); ++ i)
455	{
456	if ( (saDeviceTypes[i] == DeviceType_DVD)
457	\|\| (saDeviceTypes[i] == DeviceType_Floppy))
458	driveCheck++;
459	}
460
461	if (!driveCheck)
462	throw Utf8StrFmt("The attachment is not supported by the storage controller '%s'", pszCtl);
463
464	if (storageBus == StorageBus_Floppy)
465	deviceType = DeviceType_Floppy;
466	else
467	deviceType = DeviceType_DVD;
468
469	/* attach a empty floppy/dvd drive after removing previous attachment */
470	machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
471	CHECK_ERROR(machine, AttachDeviceWithoutMedium(Bstr(pszCtl).raw(), port, device,
472	deviceType));
473	}
474	} // end if (!RTStrICmp(pszMedium, "emptydrive"))
475	else
476	{
477	ComPtr<IMedium> pMedium2Mount;
478
479	// not "none", not "emptydrive": then it must be a UUID or filename or hostdrive or iSCSI;
480	// for all these we first need to know the type of drive we're attaching to
481	{
482	/*
483	* try to determine the type of the drive from the
484	* storage controller chipset, the attachment and
485	* the medium being attached
486	*/
487	if (ctlType == StorageControllerType_I82078) // floppy controller
488	devTypeRequested = DeviceType_Floppy;
489	else
490	{
491	/*
492	* for SATA/SCSI/IDE it is hard to tell if it is a harddisk or
493	* a dvd being attached so lets check if the medium attachment
494	* and the medium, both are of same type. if yes then we are
495	* sure of its type and don't need the user to enter it manually
496	* else ask the user for the type.
497	*/
498	ComPtr<IMediumAttachment> mediumAttachment;
499	rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
500	device,
501	mediumAttachment.asOutParam());
502	if (SUCCEEDED(rc))
503	{
504	DeviceType_T deviceType;
505	mediumAttachment->COMGETTER(Type)(&deviceType);
506
507	if (pszMedium)
508	{
509	if (!RTStrICmp(pszMedium, "additions"))
510	{
511	ComPtr<ISystemProperties> pProperties;
512	CHECK_ERROR(a->virtualBox,
513	COMGETTER(SystemProperties)(pProperties.asOutParam()));
514	CHECK_ERROR(pProperties, COMGETTER(DefaultAdditionsISO)(bstrIso.asOutParam()));
515	strIso = Utf8Str(bstrIso);
516	if (strIso.isEmpty())
517	throw Utf8Str("Cannot find the Guest Additions ISO image\n");
518	pszMedium = strIso.c_str();
519	if (devTypeRequested == DeviceType_Null)
520	devTypeRequested = DeviceType_DVD;
521	}
522	ComPtr<IMedium> pExistingMedium;
523	rc = openMedium(a, pszMedium, deviceType,
524	AccessMode_ReadWrite,
525	pExistingMedium,
526	false /* fForceNewUuidOnOpen */,
527	true /* fSilent */);
528	if (SUCCEEDED(rc) && pExistingMedium)
529	{
530	if ( (deviceType == DeviceType_DVD)
531	\|\| (deviceType == DeviceType_HardDisk)
532	)
533	devTypeRequested = deviceType;
534	}
535	}
536	else
537	devTypeRequested = deviceType;
538	}
539	}
540	}
541
542	if (devTypeRequested == DeviceType_Null) // still the initializer value?
543	throw Utf8Str("Argument --type must be specified\n");
544
545	/* check if the device type is supported by the controller */
546	{
547	com::SafeArray <DeviceType_T> saDeviceTypes;
548
549	CHECK_ERROR(systemProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes)));
550	if (SUCCEEDED(rc))
551	{
552	ULONG driveCheck = 0;
553	for (size_t i = 0; i < saDeviceTypes.size(); ++ i)
554	if (saDeviceTypes[i] == devTypeRequested)
555	driveCheck++;
556	if (!driveCheck)
557	throw Utf8StrFmt("The given attachment is not supported by the storage controller '%s'", pszCtl);
558	}
559	else
560	goto leave;
561	}
562
563	// find the medium given
564	/* host drive? */
565	if (!RTStrNICmp(pszMedium, RT_STR_TUPLE("host:")))
566	{
567	ComPtr<IHost> host;
568	CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
569
570	if (devTypeRequested == DeviceType_DVD)
571	{
572	rc = host->FindHostDVDDrive(Bstr(pszMedium + 5).raw(),
573	pMedium2Mount.asOutParam());
574	if (!pMedium2Mount)
575	{
576	/* 2nd try: try with the real name, important on Linux+libhal */
577	char szPathReal[RTPATH_MAX];
578	if (RT_FAILURE(RTPathReal(pszMedium + 5, szPathReal, sizeof(szPathReal))))
579	throw Utf8StrFmt("Invalid host DVD drive name \"%s\"", pszMedium + 5);
580	rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
581	pMedium2Mount.asOutParam());
582	if (!pMedium2Mount)
583	throw Utf8StrFmt("Invalid host DVD drive name \"%s\"", pszMedium + 5);
584	}
585	}
586	else
587	{
588	// floppy
589	rc = host->FindHostFloppyDrive(Bstr(pszMedium + 5).raw(),
590	pMedium2Mount.asOutParam());
591	if (!pMedium2Mount)
592	throw Utf8StrFmt("Invalid host floppy drive name \"%s\"", pszMedium + 5);
593	}
594	}
595	else if (!RTStrICmp(pszMedium, "iSCSI"))
596	{
597	/* check for required options */
598	if (bstrServer.isEmpty() \|\| bstrTarget.isEmpty())
599	throw Utf8StrFmt("Parameters --server and --target are required for iSCSI media");
600
601	/** @todo move the location stuff to Main, which can use pfnComposeName
602	* from the disk backends to construct the location properly. Also do
603	* not use slashes to separate the parts, as otherwise only the last
604	* element containing information will be shown. */
605	Bstr bstrISCSIMedium;
606	if ( bstrLun.isEmpty()
607	\|\| (bstrLun == "0")
608	\|\| (bstrLun == "enc0")
609	)
610	bstrISCSIMedium = BstrFmt("%ls\|%ls", bstrServer.raw(), bstrTarget.raw());
611	else
612	bstrISCSIMedium = BstrFmt("%ls\|%ls\|%ls", bstrServer.raw(), bstrTarget.raw(), bstrLun.raw());
613
614	CHECK_ERROR(a->virtualBox, CreateMedium(Bstr("iSCSI").raw(),
615	bstrISCSIMedium.raw(),
616	AccessMode_ReadWrite,
617	DeviceType_HardDisk,
618	pMedium2Mount.asOutParam()));
619	if (FAILED(rc)) goto leave;
620	if (!bstrPort.isEmpty())
621	bstrServer = BstrFmt("%ls:%ls", bstrServer.raw(), bstrPort.raw());
622
623	// set the other iSCSI parameters as properties
624	com::SafeArray <BSTR> names;
625	com::SafeArray <BSTR> values;
626	Bstr("TargetAddress").detachTo(names.appendedRaw());
627	bstrServer.detachTo(values.appendedRaw());
628	Bstr("TargetName").detachTo(names.appendedRaw());
629	bstrTarget.detachTo(values.appendedRaw());
630
631	if (!bstrLun.isEmpty())
632	{
633	Bstr("LUN").detachTo(names.appendedRaw());
634	bstrLun.detachTo(values.appendedRaw());
635	}
636	if (!bstrUsername.isEmpty())
637	{
638	Bstr("InitiatorUsername").detachTo(names.appendedRaw());
639	bstrUsername.detachTo(values.appendedRaw());
640	}
641	if (!bstrPassword.isEmpty())
642	{
643	Bstr("InitiatorSecret").detachTo(names.appendedRaw());
644	bstrPassword.detachTo(values.appendedRaw());
645	}
646	if (!bstrInitiator.isEmpty())
647	{
648	Bstr("InitiatorName").detachTo(names.appendedRaw());
649	bstrInitiator.detachTo(values.appendedRaw());
650	}
651
652	/// @todo add --targetName and --targetPassword options
653
654	if (fIntNet)
655	{
656	Bstr("HostIPStack").detachTo(names.appendedRaw());
657	Bstr("0").detachTo(values.appendedRaw());
658	}
659
660	CHECK_ERROR(pMedium2Mount, SetProperties(ComSafeArrayAsInParam(names),
661	ComSafeArrayAsInParam(values)));
662	if (FAILED(rc)) goto leave;
663	Bstr guid;
664	CHECK_ERROR(pMedium2Mount, COMGETTER(Id)(guid.asOutParam()));
665	if (FAILED(rc)) goto leave;
666	RTPrintf("iSCSI disk created. UUID: %s\n", Utf8Str(guid).c_str());
667	}
668	else
669	{
670	if (!pszMedium)
671	{
672	ComPtr<IMediumAttachment> mediumAttachment;
673	rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
674	device,
675	mediumAttachment.asOutParam());
676	if (FAILED(rc))
677	throw Utf8Str("Missing --medium argument");
678	}
679	else
680	{
681	Bstr bstrMedium(pszMedium);
682	rc = openMedium(a, pszMedium, devTypeRequested,
683	AccessMode_ReadWrite, pMedium2Mount,
684	fSetNewUuid, false /* fSilent */);
685	if (FAILED(rc) \|\| !pMedium2Mount)
686	throw Utf8StrFmt("Invalid UUID or filename \"%s\"", pszMedium);
687	}
688	}
689
690	// set medium/parent medium UUID, if so desired
691	if (pMedium2Mount && (fSetNewUuid \|\| fSetNewParentUuid))
692	{
693	CHECK_ERROR(pMedium2Mount, SetIds(fSetNewUuid, bstrNewUuid.raw(),
694	fSetNewParentUuid, bstrNewParentUuid.raw()));
695	if (FAILED(rc))
696	throw Utf8Str("Failed to set the medium/parent medium UUID");
697	}
698
699	// set medium type, if so desired
700	if (pMedium2Mount && fSetMediumType)
701	{
702	MediumType_T enmMediumTypeOld;
703	CHECK_ERROR(pMedium2Mount, COMGETTER(Type)(&enmMediumTypeOld));
704	if (SUCCEEDED(rc))
705	{
706	if (enmMediumTypeOld != enmMediumType)
707	{
708	CHECK_ERROR(pMedium2Mount, COMSETTER(Type)(enmMediumType));
709	if (FAILED(rc))
710	throw Utf8Str("Failed to set the medium type");
711	}
712	}
713	}
714
715	if (pMedium2Mount && !bstrComment.isEmpty())
716	{
717	CHECK_ERROR(pMedium2Mount, COMSETTER(Description)(bstrComment.raw()));
718	}
719
720	if (pszMedium)
721	{
722	switch (devTypeRequested)
723	{
724	case DeviceType_DVD:
725	case DeviceType_Floppy:
726	{
727	if (!fRunTime)
728	{
729	ComPtr<IMediumAttachment> mediumAttachment;
730	// check if there is a dvd/floppy drive at the given location, if not attach one first
731	rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(),
732	port,
733	device,
734	mediumAttachment.asOutParam());
735	if (SUCCEEDED(rc))
736	{
737	DeviceType_T deviceType;
738	mediumAttachment->COMGETTER(Type)(&deviceType);
739	if (deviceType != devTypeRequested)
740	{
741	machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
742	rc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(),
743	port,
744	device,
745	devTypeRequested); // DeviceType_DVD or DeviceType_Floppy
746	}
747	}
748	else
749	{
750	rc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(),
751	port,
752	device,
753	devTypeRequested); // DeviceType_DVD or DeviceType_Floppy
754	}
755	}
756
757	if (pMedium2Mount)
758	{
759	CHECK_ERROR(machine, MountMedium(Bstr(pszCtl).raw(),
760	port,
761	device,
762	pMedium2Mount,
763	fForceUnmount));
764	}
765	break;
766	} // end DeviceType_DVD or DeviceType_Floppy:
767
768	case DeviceType_HardDisk:
769	{
770	// if there is anything attached at the given location, remove it
771	machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
772	CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl).raw(),
773	port,
774	device,
775	DeviceType_HardDisk,
776	pMedium2Mount));
777	break;
778	}
779
780	default: break; /* Shut up MSC */
781	}
782	}
783	}
784
785	if ( pszPassThrough
786	&& (SUCCEEDED(rc)))
787	{
788	ComPtr<IMediumAttachment> mattach;
789	CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port,
790	device, mattach.asOutParam()));
791
792	if (SUCCEEDED(rc))
793	{
794	if (!RTStrICmp(pszPassThrough, "on"))
795	{
796	CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl).raw(),
797	port, device, TRUE));
798	}
799	else if (!RTStrICmp(pszPassThrough, "off"))
800	{
801	CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl).raw(),
802	port, device, FALSE));
803	}
804	else
805	throw Utf8StrFmt("Invalid --passthrough argument '%s'", pszPassThrough);
806	}
807	else
808	throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
809	}
810
811	if ( pszTempEject
812	&& (SUCCEEDED(rc)))
813	{
814	ComPtr<IMediumAttachment> mattach;
815	CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port,
816	device, mattach.asOutParam()));
817
818	if (SUCCEEDED(rc))
819	{
820	if (!RTStrICmp(pszTempEject, "on"))
821	{
822	CHECK_ERROR(machine, TemporaryEjectDevice(Bstr(pszCtl).raw(),
823	port, device, TRUE));
824	}
825	else if (!RTStrICmp(pszTempEject, "off"))
826	{
827	CHECK_ERROR(machine, TemporaryEjectDevice(Bstr(pszCtl).raw(),
828	port, device, FALSE));
829	}
830	else
831	throw Utf8StrFmt("Invalid --tempeject argument '%s'", pszTempEject);
832	}
833	else
834	throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
835	}
836
837	if ( pszNonRotational
838	&& (SUCCEEDED(rc)))
839	{
840	ComPtr<IMediumAttachment> mattach;
841	CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port,
842	device, mattach.asOutParam()));
843
844	if (SUCCEEDED(rc))
845	{
846	if (!RTStrICmp(pszNonRotational, "on"))
847	{
848	CHECK_ERROR(machine, NonRotationalDevice(Bstr(pszCtl).raw(),
849	port, device, TRUE));
850	}
851	else if (!RTStrICmp(pszNonRotational, "off"))
852	{
853	CHECK_ERROR(machine, NonRotationalDevice(Bstr(pszCtl).raw(),
854	port, device, FALSE));
855	}
856	else
857	throw Utf8StrFmt("Invalid --nonrotational argument '%s'", pszNonRotational);
858	}
859	else
860	throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
861	}
862
863	if ( pszDiscard
864	&& (SUCCEEDED(rc)))
865	{
866	ComPtr<IMediumAttachment> mattach;
867	CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port,
868	device, mattach.asOutParam()));
869
870	if (SUCCEEDED(rc))
871	{
872	if (!RTStrICmp(pszDiscard, "on"))
873	{
874	CHECK_ERROR(machine, SetAutoDiscardForDevice(Bstr(pszCtl).raw(),
875	port, device, TRUE));
876	}
877	else if (!RTStrICmp(pszDiscard, "off"))
878	{
879	CHECK_ERROR(machine, SetAutoDiscardForDevice(Bstr(pszCtl).raw(),
880	port, device, FALSE));
881	}
882	else
883	throw Utf8StrFmt("Invalid --discard argument '%s'", pszDiscard);
884	}
885	else
886	throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
887	}
888
889	if ( pszHotPluggable
890	&& (SUCCEEDED(rc)))
891	{
892	ComPtr<IMediumAttachment> mattach;
893	CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port,
894	device, mattach.asOutParam()));
895
896	if (SUCCEEDED(rc))
897	{
898	if (!RTStrICmp(pszHotPluggable, "on"))
899	{
900	CHECK_ERROR(machine, SetHotPluggableForDevice(Bstr(pszCtl).raw(),
901	port, device, TRUE));
902	}
903	else if (!RTStrICmp(pszHotPluggable, "off"))
904	{
905	CHECK_ERROR(machine, SetHotPluggableForDevice(Bstr(pszCtl).raw(),
906	port, device, FALSE));
907	}
908	else
909	throw Utf8StrFmt("Invalid --hotpluggable argument '%s'", pszHotPluggable);
910	}
911	else
912	throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
913	}
914
915	if ( pszBandwidthGroup
916	&& !fRunTime
917	&& SUCCEEDED(rc))
918	{
919
920	if (!RTStrICmp(pszBandwidthGroup, "none"))
921	{
922	/* Just remove the bandwidth gorup. */
923	CHECK_ERROR(machine, SetNoBandwidthGroupForDevice(Bstr(pszCtl).raw(),
924	port, device));
925	}
926	else
927	{
928	ComPtr<IBandwidthControl> bwCtrl;
929	ComPtr<IBandwidthGroup> bwGroup;
930
931	CHECK_ERROR(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
932
933	if (SUCCEEDED(rc))
934	{
935	CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(pszBandwidthGroup).raw(), bwGroup.asOutParam()));
936	if (SUCCEEDED(rc))
937	{
938	CHECK_ERROR(machine, SetBandwidthGroupForDevice(Bstr(pszCtl).raw(),
939	port, device, bwGroup));
940	}
941	}
942	}
943	}
944
945	/* commit changes */
946	if (SUCCEEDED(rc))
947	CHECK_ERROR(machine, SaveSettings());
948	}
949	catch (const Utf8Str &strError)
950	{
951	errorArgument("%s", strError.c_str());
952	rc = E_FAIL;
953	}
954
955	// machine must always be unlocked, even on errors
956	leave:
957	a->session->UnlockMachine();
958
959	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
960	}
961
962
963	static const RTGETOPTDEF g_aStorageControllerOptions[] =
964	{
965	{ "--name", 'n', RTGETOPT_REQ_STRING },
966	{ "--add", 'a', RTGETOPT_REQ_STRING },
967	{ "--controller", 'c', RTGETOPT_REQ_STRING },
968	{ "--portcount", 'p', RTGETOPT_REQ_UINT32 },
969	{ "--remove", 'r', RTGETOPT_REQ_NOTHING },
970	{ "--rename", 'R', RTGETOPT_REQ_STRING },
971	{ "--hostiocache", 'i', RTGETOPT_REQ_STRING },
972	{ "--bootable", 'b', RTGETOPT_REQ_STRING },
973	};
974
975	RTEXITCODE handleStorageController(HandlerArg *a)
976	{
977	int c;
978	const char *pszCtl = NULL;
979	const char *pszBusType = NULL;
980	const char *pszCtlType = NULL;
981	const char *pszHostIOCache = NULL;
982	const char *pszBootable = NULL;
983	const char *pszCtlNewName = NULL;
984	ULONG portcount = ~0U;
985	bool fRemoveCtl = false;
986	ComPtr<IMachine> machine;
987	RTGETOPTUNION ValueUnion;
988	RTGETOPTSTATE GetState;
989
990	if (a->argc < 4)
991	return errorSyntax(USAGE_STORAGECONTROLLER, "Too few parameters");
992
993	RTGetOptInit (&GetState, a->argc, a->argv, g_aStorageControllerOptions,
994	RT_ELEMENTS(g_aStorageControllerOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
995
996	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
997	{
998	switch (c)
999	{
1000	case 'n': // controller name
1001	Assert(ValueUnion.psz);
1002	pszCtl = ValueUnion.psz;
1003	break;
1004
1005	case 'a': // controller bus type <ide/sata/scsi/floppy>
1006	Assert(ValueUnion.psz);
1007	pszBusType = ValueUnion.psz;
1008	break;
1009
1010	case 'c': // controller <lsilogic/buslogic/intelahci/piix3/piix4/ich6/i82078>
1011	Assert(ValueUnion.psz);
1012	pszCtlType = ValueUnion.psz;
1013	break;
1014
1015	case 'p': // portcount
1016	portcount = ValueUnion.u32;
1017	break;
1018
1019	case 'r': // remove controller
1020	fRemoveCtl = true;
1021	break;
1022
1023	case 'R': // rename controller
1024	Assert(ValueUnion.psz);
1025	pszCtlNewName = ValueUnion.psz;
1026	break;
1027
1028	case 'i':
1029	pszHostIOCache = ValueUnion.psz;
1030	break;
1031
1032	case 'b':
1033	pszBootable = ValueUnion.psz;
1034	break;
1035
1036	default:
1037	return errorGetOpt(USAGE_STORAGECONTROLLER, c, &ValueUnion);
1038	}
1039	}
1040
1041	HRESULT rc;
1042
1043	/* try to find the given machine */
1044	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
1045	machine.asOutParam()), RTEXITCODE_FAILURE);
1046
1047	/* open a session for the VM */
1048	CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE);
1049
1050	/* get the mutable session machine */
1051	a->session->COMGETTER(Machine)(machine.asOutParam());
1052
1053	if (!pszCtl)
1054	{
1055	/* it's important to always close sessions */
1056	a->session->UnlockMachine();
1057	return errorSyntax(USAGE_STORAGECONTROLLER, "Storage controller name not specified\n");
1058	}
1059
1060	if (fRemoveCtl)
1061	{
1062	CHECK_ERROR(machine, RemoveStorageController(Bstr(pszCtl).raw()));
1063	}
1064	else
1065	{
1066	if (pszBusType)
1067	{
1068	ComPtr<IStorageController> ctl;
1069
1070	if (!RTStrICmp(pszBusType, "ide"))
1071	{
1072	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1073	StorageBus_IDE,
1074	ctl.asOutParam()));
1075	}
1076	else if (!RTStrICmp(pszBusType, "sata"))
1077	{
1078	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1079	StorageBus_SATA,
1080	ctl.asOutParam()));
1081	}
1082	else if (!RTStrICmp(pszBusType, "scsi"))
1083	{
1084	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1085	StorageBus_SCSI,
1086	ctl.asOutParam()));
1087	}
1088	else if (!RTStrICmp(pszBusType, "floppy"))
1089	{
1090	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1091	StorageBus_Floppy,
1092	ctl.asOutParam()));
1093	}
1094	else if (!RTStrICmp(pszBusType, "sas"))
1095	{
1096	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1097	StorageBus_SAS,
1098	ctl.asOutParam()));
1099	}
1100	else if (!RTStrICmp(pszBusType, "usb"))
1101	{
1102	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1103	StorageBus_USB,
1104	ctl.asOutParam()));
1105	}
1106	else if (!RTStrICmp(pszBusType, "pcie"))
1107	{
1108	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1109	StorageBus_PCIe,
1110	ctl.asOutParam()));
1111	}
1112	else if (!RTStrICmp(pszBusType, "virtio-scsi") \|\| !RTStrICmp(pszBusType, "virtio"))
1113	{
1114	CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
1115	StorageBus_VirtioSCSI,
1116	ctl.asOutParam()));
1117	}
1118	else
1119	{
1120	errorArgument("Invalid --add argument '%s'", pszBusType);
1121	rc = E_FAIL;
1122	}
1123	}
1124
1125	if ( pszCtlType
1126	&& SUCCEEDED(rc))
1127	{
1128	ComPtr<IStorageController> ctl;
1129
1130	CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
1131	ctl.asOutParam()));
1132
1133	if (SUCCEEDED(rc))
1134	{
1135	if (!RTStrICmp(pszCtlType, "lsilogic"))
1136	{
1137	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
1138	}
1139	else if (!RTStrICmp(pszCtlType, "buslogic"))
1140	{
1141	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1142	}
1143	else if (!RTStrICmp(pszCtlType, "intelahci"))
1144	{
1145	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
1146	}
1147	else if (!RTStrICmp(pszCtlType, "piix3"))
1148	{
1149	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
1150	}
1151	else if (!RTStrICmp(pszCtlType, "piix4"))
1152	{
1153	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
1154	}
1155	else if (!RTStrICmp(pszCtlType, "ich6"))
1156	{
1157	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_ICH6));
1158	}
1159	else if (!RTStrICmp(pszCtlType, "i82078"))
1160	{
1161	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_I82078));
1162	}
1163	else if (!RTStrICmp(pszCtlType, "lsilogicsas"))
1164	{
1165	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas));
1166	}
1167	else if (!RTStrICmp(pszCtlType, "usb"))
1168	{
1169	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_USB));
1170	}
1171	else if (!RTStrICmp(pszCtlType, "nvme"))
1172	{
1173	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_NVMe));
1174	}
1175	else if (!RTStrICmp(pszCtlType, "virtio-scsi") \|\| !RTStrICmp(pszCtlType, "virtio"))
1176	{
1177	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_VirtioSCSI));
1178	}
1179	else
1180	{
1181	errorArgument("Invalid --type argument '%s'", pszCtlType);
1182	rc = E_FAIL;
1183	}
1184	}
1185	else
1186	{
1187	errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
1188	rc = E_FAIL;
1189	}
1190	}
1191
1192	if ( (portcount != ~0U)
1193	&& SUCCEEDED(rc))
1194	{
1195	ComPtr<IStorageController> ctl;
1196
1197	CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
1198	ctl.asOutParam()));
1199
1200	if (SUCCEEDED(rc))
1201	{
1202	CHECK_ERROR(ctl, COMSETTER(PortCount)(portcount));
1203	}
1204	else
1205	{
1206	errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
1207	rc = E_FAIL;
1208	}
1209	}
1210
1211	if ( pszHostIOCache
1212	&& SUCCEEDED(rc))
1213	{
1214	ComPtr<IStorageController> ctl;
1215
1216	CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
1217	ctl.asOutParam()));
1218
1219	if (SUCCEEDED(rc))
1220	{
1221	if (!RTStrICmp(pszHostIOCache, "on"))
1222	{
1223	CHECK_ERROR(ctl, COMSETTER(UseHostIOCache)(TRUE));
1224	}
1225	else if (!RTStrICmp(pszHostIOCache, "off"))
1226	{
1227	CHECK_ERROR(ctl, COMSETTER(UseHostIOCache)(FALSE));
1228	}
1229	else
1230	{
1231	errorArgument("Invalid --hostiocache argument '%s'", pszHostIOCache);
1232	rc = E_FAIL;
1233	}
1234	}
1235	else
1236	{
1237	errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
1238	rc = E_FAIL;
1239	}
1240	}
1241
1242	if ( pszBootable
1243	&& SUCCEEDED(rc))
1244	{
1245	if (SUCCEEDED(rc))
1246	{
1247	if (!RTStrICmp(pszBootable, "on"))
1248	{
1249	CHECK_ERROR(machine, SetStorageControllerBootable(Bstr(pszCtl).raw(), TRUE));
1250	}
1251	else if (!RTStrICmp(pszBootable, "off"))
1252	{
1253	CHECK_ERROR(machine, SetStorageControllerBootable(Bstr(pszCtl).raw(), FALSE));
1254	}
1255	else
1256	{
1257	errorArgument("Invalid --bootable argument '%s'", pszBootable);
1258	rc = E_FAIL;
1259	}
1260	}
1261	else
1262	{
1263	errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
1264	rc = E_FAIL;
1265	}
1266	}
1267
1268	if ( pszCtlNewName
1269	&& SUCCEEDED(rc))
1270	{
1271	ComPtr<IStorageController> ctl;
1272
1273	CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
1274	ctl.asOutParam()));
1275
1276	if (SUCCEEDED(rc))
1277	{
1278	CHECK_ERROR(ctl, COMSETTER(Name)(Bstr(pszCtlNewName).raw()));
1279	}
1280	else
1281	{
1282	errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
1283	rc = E_FAIL;
1284	}
1285	}
1286
1287	}
1288
1289	/* commit changes */
1290	if (SUCCEEDED(rc))
1291	CHECK_ERROR(machine, SaveSettings());
1292
1293	/* it's important to always close sessions */
1294	a->session->UnlockMachine();
1295
1296	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1297	}
1298
1299	#endif /* !VBOX_ONLY_DOCS */
1300

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp@ 86663

Download in other formats: