DrvVMNet.m@ 105818

Last change on this file since 105818 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.7 KB

Line
1	/* $Id: DrvVMNet.m 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* DrvVMNet - Network filter driver that uses MAC OS VMNET API.
4	*/
5
6	/*
7	* Copyright (C) 2021-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DRV_VMNET
33	#include <VBox/vmm/pdmdrv.h>
34	#include <VBox/vmm/pdmnetifs.h>
35	#include <VBox/vmm/pdmnetinline.h>
36	#include <VBox/intnet.h>
37
38	#include <VBox/log.h>
39	#include <iprt/assert.h>
40	#include <iprt/critsect.h>
41	#include <iprt/file.h>
42	#include <iprt/mem.h>
43	#include <iprt/process.h>
44	#include <iprt/string.h>
45	#include <iprt/time.h>
46	#include <iprt/uuid.h>
47	#include <iprt/path.h>
48	#include <VBox/param.h>
49
50	#include "Pcap.h"
51	#include "VBoxDD.h"
52
53	#include <sys/uio.h>
54	#import <vmnet/vmnet.h>
55
56	#define VMNET_MAX_HOST_INTERFACE_NAME_LENGTH 16
57	#define VMNET_MAX_IP_ADDRESS_STRING_LENGTH 48
58
59	/* Force release logging for debug builds */
60	#if 0
61	# undef Log
62	# undef LogFlow
63	# undef Log2
64	# undef Log3
65	# define Log LogRel
66	# define LogFlow LogRel
67	# define Log2 LogRel
68	# define Log3 LogRel
69	#endif
70
71
72	/*********************************************************************************************************************************
73	* Structures and Typedefs *
74	*********************************************************************************************************************************/
75	/**
76	* VMNET driver states.
77	*/
78	typedef enum VMNETSTATE
79	{
80	/** The driver is suspended. */
81	VMNETSTATE_SUSPENDED = 1,
82	/** The driver is running. */
83	VMNETSTATE_RUNNING,
84	/** The usual 32-bit type blowup. */
85	VMNETSTATE_32BIT_HACK = 0x7fffffff
86	} VMNETSTATE;
87
88	/**
89	* VMNET driver instance data.
90	*
91	* @implements PDMINETWORKUP
92	* @implements PDMINETWORKCONFIG
93	*/
94	typedef struct DRVVMNET
95	{
96	/** The network interface. */
97	PDMINETWORKUP INetworkUp;
98	/** The port we're attached to. */
99	PPDMINETWORKDOWN pIAboveNet;
100	/** The config port interface we're attached to. */
101	PPDMINETWORKCONFIG pIAboveConfig;
102	/** Pointer to the driver instance. */
103	PPDMDRVINS pDrvIns;
104	/** For when we're the leaf driver. */
105	RTCRITSECT XmitLock;
106	/** VMNET interface queue handle. */
107	dispatch_queue_t InterfaceQueue;
108	/** VMNET interface handle. */
109	interface_ref Interface;
110	/** The unique id for this network. */
111	uuid_t uuid;
112	/** The operation mode: bridged or host. */
113	uint32_t uMode;
114	/** The operational state: suspended or running. */
115	VMNETSTATE volatile enmState;
116	/** The host interface name for bridge mode. */
117	char szHostInterface[VMNET_MAX_HOST_INTERFACE_NAME_LENGTH];
118	/** The network mask for host mode. */
119	char szNetworkMask[VMNET_MAX_IP_ADDRESS_STRING_LENGTH];
120	/** The lower IP address of DHCP range for host mode. */
121	char szLowerIP[VMNET_MAX_IP_ADDRESS_STRING_LENGTH];
122	/** The upper IP address of DHCP range for host mode. */
123	char szUpperIP[VMNET_MAX_IP_ADDRESS_STRING_LENGTH];
124	} DRVVMNET, *PDRVVMNET;
125
126
127
128	/**
129	* @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
130	*/
131	static DECLCALLBACK(int) drvVMNetUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
132	{
133	RT_NOREF(fOnWorkerThread);
134	PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
135	LogFlow(("drvVMNetUp_BeginXmit:\n"));
136	int rc = RTCritSectTryEnter(&pThis->XmitLock);
137	if (RT_UNLIKELY(rc == VERR_SEM_BUSY))
138	rc = VERR_TRY_AGAIN;
139	return rc;
140	}
141
142
143	/**
144	* @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
145	*/
146	static DECLCALLBACK(int) drvVMNetUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
147	PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
148	{
149	RT_NOREF(pInterface);
150	//PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
151	LogFlow(("drvVMNetUp_AllocBuf: cb=%llu%s\n", cbMin, pGso == NULL ? "" : " GSO"));
152	/*
153	* Allocate a scatter / gather buffer descriptor that is immediately
154	* followed by the buffer space of its single segment. The GSO context
155	* comes after that again.
156	*/
157	PPDMSCATTERGATHER pSgBuf = (PPDMSCATTERGATHER)RTMemAlloc( RT_ALIGN_Z(sizeof(*pSgBuf), 16)
158	+ RT_ALIGN_Z(cbMin, 16)
159	+ (pGso ? RT_ALIGN_Z(sizeof(*pGso), 16) : 0));
160	if (!pSgBuf)
161	return VERR_NO_MEMORY;
162
163	/*
164	* Initialize the S/G buffer and return.
165	*/
166	pSgBuf->fFlags = PDMSCATTERGATHER_FLAGS_MAGIC \| PDMSCATTERGATHER_FLAGS_OWNER_1;
167	pSgBuf->cbUsed = 0;
168	pSgBuf->cbAvailable = RT_ALIGN_Z(cbMin, 16);
169	pSgBuf->pvAllocator = NULL;
170	if (!pGso)
171	pSgBuf->pvUser = NULL;
172	else
173	{
174	pSgBuf->pvUser = (uint8_t *)(pSgBuf + 1) + pSgBuf->cbAvailable;
175	(PPDMNETWORKGSO)pSgBuf->pvUser = pGso;
176	}
177	pSgBuf->cSegs = 1;
178	pSgBuf->aSegs[0].cbSeg = pSgBuf->cbAvailable;
179	pSgBuf->aSegs[0].pvSeg = pSgBuf + 1;
180
181	LogFlow(("drvVMNetUp_AllocBuf: successful %p\n", pSgBuf));
182	*ppSgBuf = pSgBuf;
183	return VINF_SUCCESS;
184	}
185
186
187	/**
188	* @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
189	*/
190	static DECLCALLBACK(int) drvVMNetUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
191	{
192	PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
193	LogFlow(("drvVMNetUp_FreeBuf: %p\n", pSgBuf));
194	Assert(RTCritSectIsOwner(&pThis->XmitLock));
195	RT_NOREF(pThis);
196	if (pSgBuf)
197	{
198	Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
199	pSgBuf->fFlags = 0;
200	RTMemFree(pSgBuf);
201	}
202	return VINF_SUCCESS;
203	}
204
205
206	static int drvVMNetReceive(PDRVVMNET pThis, const uint8_t *pbFrame, uint32_t cbFrame)
207	{
208	if (pThis->enmState != VMNETSTATE_RUNNING)
209	{
210	Log(("drvVMNetReceive: Ignoring incoming packet (%d bytes) in suspended state\n", cbFrame));
211	return VINF_SUCCESS;
212	}
213
214	Log(("drvVMNetReceive: Incoming packet: %RTmac <= %RTmac (%d bytes)\n", pbFrame, pbFrame + 6, cbFrame));
215	Log2(("%.*Rhxd\n", cbFrame, pbFrame));
216	if (pThis->pIAboveNet && pThis->pIAboveNet->pfnReceive)
217	return pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, pbFrame, cbFrame);
218	return VERR_TRY_AGAIN;
219	}
220
221
222	static int drvVMNetSend(PDRVVMNET pThis, const uint8_t *pbFrame, uint32_t cbFrame)
223	{
224	if (pThis->enmState != VMNETSTATE_RUNNING)
225	{
226	Log(("drvVMNetReceive: Ignoring outgoing packet (%d bytes) in suspended state\n", cbFrame));
227	return VINF_SUCCESS;
228	}
229
230	Log(("drvVMNetSend: Outgoing packet (%d bytes)\n", cbFrame));
231	Log2(("%.*Rhxd\n", cbFrame, pbFrame));
232
233	struct iovec io;
234	struct vmpktdesc packets;
235	int packet_count = 1;
236
237	io.iov_base = (void*)pbFrame;
238	io.iov_len = cbFrame;
239	packets.vm_pkt_size = cbFrame;
240	packets.vm_pkt_iov = &io;
241	packets.vm_pkt_iovcnt = 1;
242	packets.vm_flags = 0;
243
244	vmnet_return_t rc = vmnet_write(pThis->Interface, &packets, &packet_count);
245	if (rc != VMNET_SUCCESS)
246	Log(("drvVMNetSend: Failed to send a packet with error code %d\n", rc));
247	return (rc == VMNET_SUCCESS) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
248	}
249
250	/**
251	* @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
252	*/
253	static DECLCALLBACK(int) drvVMNetUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
254	{
255	RT_NOREF(fOnWorkerThread);
256	PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
257
258	LogFlow(("drvVMNetUp_SendBuf: %p\n", pSgBuf));
259	Assert(RTCritSectIsOwner(&pThis->XmitLock));
260
261	int rc;
262	if (!pSgBuf->pvUser)
263	{
264	rc = drvVMNetSend(pThis, pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed);
265	}
266	else
267	{
268	uint8_t abHdrScratch[256];
269	uint8_t const pbFrame = (uint8_t const )pSgBuf->aSegs[0].pvSeg;
270	PCPDMNETWORKGSO pGso = (PCPDMNETWORKGSO)pSgBuf->pvUser;
271	uint32_t const cSegs = PDMNetGsoCalcSegmentCount(pGso, pSgBuf->cbUsed); Assert(cSegs > 1);
272	rc = VINF_SUCCESS;
273	for (uint32_t iSeg = 0; iSeg < cSegs && RT_SUCCESS(rc); iSeg++)
274	{
275	uint32_t cbSegFrame;
276	void pvSegFrame = PDMNetGsoCarveSegmentQD(pGso, (uint8_t )pbFrame, pSgBuf->cbUsed, abHdrScratch,
277	iSeg, cSegs, &cbSegFrame);
278	rc = drvVMNetSend(pThis, pvSegFrame, cbSegFrame);
279	}
280	}
281
282	LogFlow(("drvVMNetUp_SendBuf: free %p\n", pSgBuf));
283	pSgBuf->fFlags = 0;
284	RTMemFree(pSgBuf);
285	return rc;
286	}
287
288
289	/**
290	* @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
291	*/
292	static DECLCALLBACK(void) drvVMNetUp_EndXmit(PPDMINETWORKUP pInterface)
293	{
294	LogFlow(("drvVMNetUp_EndXmit:\n"));
295	PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
296	RTCritSectLeave(&pThis->XmitLock);
297	}
298
299
300	/**
301	* @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
302	*/
303	static DECLCALLBACK(void) drvVMNetUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
304	{
305	RT_NOREF(pInterface, fPromiscuous);
306	LogFlow(("drvVMNetUp_SetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
307	// PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
308	}
309
310
311	/**
312	* @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
313	*/
314	static DECLCALLBACK(void) drvVMNetUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
315	{
316	RT_NOREF(pInterface, enmLinkState);
317	LogFlow(("drvVMNetUp_NotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
318	// PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
319	}
320
321
322	/**
323	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
324	*/
325	static DECLCALLBACK(void ) drvVMNetQueryInterface(PPDMIBASE pInterface, const char pszIID)
326	{
327	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
328	PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
329	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
330	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUp);
331	//PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKVMNETCONFIG, &pThis->INetworkVmnetConfig);
332	return NULL;
333	}
334
335
336	static vmnet_return_t drvVMNetAttach(PDRVVMNET pThis)
337	{
338	xpc_object_t interface_desc;
339	dispatch_semaphore_t operation_done;
340	__block vmnet_return_t vmnet_status = VMNET_FAILURE;
341	__block size_t max_packet_size = 0;
342	//__block RTMAC MacAddress;
343
344	pThis->InterfaceQueue = dispatch_queue_create("VMNET", DISPATCH_QUEUE_SERIAL);
345	operation_done = dispatch_semaphore_create(0);
346	interface_desc = xpc_dictionary_create(NULL, NULL, 0);
347	xpc_dictionary_set_uuid(interface_desc, vmnet_interface_id_key, pThis->uuid);
348	xpc_dictionary_set_bool(interface_desc, vmnet_allocate_mac_address_key, false);
349	xpc_dictionary_set_uint64(interface_desc, vmnet_operation_mode_key, pThis->uMode);
350	if (pThis->uMode == VMNET_BRIDGED_MODE)
351	{
352	LogFlow(("drvVMNetAttach: mode=briged hostInterface='%s'\n", pThis->szHostInterface));
353	xpc_dictionary_set_string(interface_desc, vmnet_shared_interface_name_key, pThis->szHostInterface);
354	}
355	else
356	{
357	#ifdef LOG_ENABLED
358	char szUUID[40];
359	uuid_unparse(pThis->uuid, szUUID);
360	LogFlow(("drvVMNetAttach: mode=host id='%s' netmask='%s' start='%s' end='%s'\n", szUUID, pThis->szNetworkMask, pThis->szLowerIP, pThis->szUpperIP));
361	#endif
362	xpc_dictionary_set_string(interface_desc, vmnet_subnet_mask_key, pThis->szNetworkMask);
363	xpc_dictionary_set_string(interface_desc, vmnet_start_address_key, pThis->szLowerIP);
364	xpc_dictionary_set_string(interface_desc, vmnet_end_address_key, pThis->szUpperIP);
365	}
366	pThis->Interface = vmnet_start_interface(interface_desc, pThis->InterfaceQueue,
367	^(vmnet_return_t status, xpc_object_t interface_param)
368	{
369	// Log(("Callback reached!\n"));
370	vmnet_status = status;
371	if (status != VMNET_SUCCESS)
372	Log(("Failed to start VMNET interface. Status = %d.\n", status));
373	else if (interface_param == NULL)
374	Log(("No interface parameters provided!\n"));
375	else
376	{
377	Log(("VMNET interface has been started. Status = %d.\n", status));
378	#if 0
379	const char *pcszMacAddress = xpc_dictionary_get_string(interface_param, vmnet_mac_address_key);
380	int rc = VERR_NOT_FOUND;
381	if (pcszMacAddress)
382	rc = RTNetStrToMacAddr(pcszMacAddress, &pThis->MacAddress);
383	if (RT_FAILURE(rc))
384	Log(("drvVMNetAttachBridged: Failed to convert '%s' to MAC address (%Rrc)\n", pcszMacAddress ? pcszMacAddress : "(null)", rc));
385	#endif
386	max_packet_size = xpc_dictionary_get_uint64(interface_param, vmnet_max_packet_size_key);
387	if (max_packet_size == 0)
388	{
389	max_packet_size = 1518;
390	LogRel(("VMNet: Failed to retrieve max packet size, assuming %d bytes.\n", max_packet_size));
391	LogRel(("VMNet: Avaliable interface parameter keys:\n"));
392	xpc_dictionary_apply(interface_param, ^bool(const char * _Nonnull key, xpc_object_t _Nonnull value) {
393	RT_NOREF(value);
394	LogRel(("VMNet: %s\n", key));
395	return true;
396	});
397	}
398	#ifdef LOG_ENABLED
399	// Log(("MAC address: %s\n", xpc_dictionary_get_string(interface_param, vmnet_mac_address_key)));
400	Log(("Max packet size: %zu\n", max_packet_size));
401	Log(("MTU size: %llu\n", xpc_dictionary_get_uint64(interface_param, vmnet_mtu_key)));
402	Log(("Avaliable keys:\n"));
403	xpc_dictionary_apply(interface_param, ^bool(const char * _Nonnull key, xpc_object_t _Nonnull value) {
404	RT_NOREF(value);
405	Log(("%s\n", key));
406	return true;
407	});
408	#endif /* LOG_ENABLED */
409	}
410	dispatch_semaphore_signal(operation_done);
411	});
412	if (dispatch_semaphore_wait(operation_done, dispatch_time(DISPATCH_TIME_NOW, RT_NS_1MIN)))
413	{
414	LogRel(("VMNet: Failed to start VMNET interface due to time out!\n"));
415	return VMNET_FAILURE;
416	}
417
418	if (vmnet_status != VMNET_SUCCESS)
419	return vmnet_status;
420
421	if (pThis->Interface == NULL)
422	{
423	Log(("Failed to start VMNET interface with unknown status!\n"));
424	return VMNET_FAILURE;
425	}
426
427	LogRel(("VMNet: Max packet size is %zu\n", max_packet_size));
428
429	vmnet_interface_set_event_callback(pThis->Interface, VMNET_INTERFACE_PACKETS_AVAILABLE, pThis->InterfaceQueue, ^(interface_event_t event_mask, xpc_object_t _Nonnull event) {
430	if (event_mask & VMNET_INTERFACE_PACKETS_AVAILABLE)
431	{
432	int rc;
433	struct vmpktdesc packets;
434	struct iovec io;
435	int packet_count = (int)xpc_dictionary_get_uint64(event, vmnet_estimated_packets_available_key);
436	if (packet_count == 1)
437	Log3(("Incoming packets available: %d\n", packet_count));
438	else
439	Log(("WARNING! %d incoming packets available, but we will fetch just one.\n", packet_count));
440	packet_count = 1;
441	io.iov_base = malloc(max_packet_size);
442	io.iov_len = max_packet_size;
443	packets.vm_pkt_iov = &io;
444	packets.vm_pkt_iovcnt = 1;
445	packets.vm_pkt_size = max_packet_size;
446	packets.vm_flags = 0;
447	rc = vmnet_read(pThis->Interface, &packets, &packet_count);
448	if (rc != VMNET_SUCCESS)
449	Log(("Failed to read packets with error code %d\n", rc));
450	else
451	{
452	Log3(("Successfully read %d packets:\n", packet_count));
453	for (int i = 0; i < packet_count; ++i)
454	{
455	rc = drvVMNetReceive(pThis, io.iov_base, packets.vm_pkt_size);
456	}
457	}
458	free(io.iov_base);
459	}
460	});
461
462	return vmnet_status;
463	}
464
465	static int drvVMNetDetach(PDRVVMNET pThis)
466	{
467	if (pThis->Interface)
468	{
469	vmnet_stop_interface(pThis->Interface, pThis->InterfaceQueue, ^(vmnet_return_t status){
470	RT_NOREF(status);
471	Log(("VMNET interface has been stopped. Status = %d.\n", status));
472	});
473	pThis->Interface = 0;
474	}
475	if (pThis->InterfaceQueue)
476	{
477	dispatch_release(pThis->InterfaceQueue);
478	pThis->InterfaceQueue = 0;
479	}
480
481	return 0;
482	}
483
484
485	/**
486	* @interface_method_impl{PDMDRVREG,pfnDestruct}
487	*/
488	static DECLCALLBACK(void) drvVMNetDestruct(PPDMDRVINS pDrvIns)
489	{
490	PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
491	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
492
493	LogFlow(("drvVMNetDestruct: %p\n", pDrvIns));
494	drvVMNetDetach(pThis);
495	if (RTCritSectIsInitialized(&pThis->XmitLock))
496	RTCritSectDelete(&pThis->XmitLock);
497	}
498
499
500	/**
501	* @interface_method_impl{Construct a NAT network transport driver instance,
502	* PDMDRVREG,pfnDestruct}
503	*/
504	static DECLCALLBACK(int) drvVMNetConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
505	{
506	RT_NOREF(fFlags);
507	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
508	PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
509	PCPDMDRVHLPR3 pHlp = pDrvIns->pHlpR3;
510
511	LogFlow(("drvVMNetConstruct: %p\n", pDrvIns));
512
513	/*
514	* Init the static parts.
515	*/
516	pThis->pDrvIns = pDrvIns;
517	/* IBase */
518	pDrvIns->IBase.pfnQueryInterface = drvVMNetQueryInterface;
519	/* INetworkUp */
520	pThis->INetworkUp.pfnBeginXmit = drvVMNetUp_BeginXmit;
521	pThis->INetworkUp.pfnAllocBuf = drvVMNetUp_AllocBuf;
522	pThis->INetworkUp.pfnFreeBuf = drvVMNetUp_FreeBuf;
523	pThis->INetworkUp.pfnSendBuf = drvVMNetUp_SendBuf;
524	pThis->INetworkUp.pfnEndXmit = drvVMNetUp_EndXmit;
525	pThis->INetworkUp.pfnSetPromiscuousMode = drvVMNetUp_SetPromiscuousMode;
526	pThis->INetworkUp.pfnNotifyLinkChanged = drvVMNetUp_NotifyLinkChanged;
527
528	/* Initialize the state. */
529	pThis->enmState = VMNETSTATE_SUSPENDED;
530
531	/*
532	* Create the locks.
533	*/
534	int rc = RTCritSectInit(&pThis->XmitLock);
535	AssertRCReturn(rc, rc);
536
537	/*
538	* Validate the config.
539	*/
540	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns,
541	"Network"
542	"\|Id"
543	"\|Trunk"
544	"\|TrunkType"
545	"\|NetworkMask"
546	"\|LowerIP"
547	"\|UpperIP",
548	"");
549
550	/** @cfgm{GUID, string}
551	* The unique id of the VMNET interface.
552	*/
553	char szUUID[40];
554	rc = pHlp->pfnCFGMQueryString(pCfg, "Id", szUUID, sizeof(szUUID));
555	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
556	uuid_generate_random(pThis->uuid);
557	else if (RT_FAILURE(rc))
558	return PDMDRV_SET_ERROR(pDrvIns, rc,
559	N_("Configuration error: Failed to get the \"Id\" value"));
560	else if (uuid_parse(szUUID, pThis->uuid))
561	return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
562	N_("Configuration error: Invalid \"Id\" value: %s"), szUUID);
563
564	/** @cfgm{TrunkType, uint32_t}
565	* The trunk connection type see INTNETTRUNKTYPE.
566	*/
567	uint32_t u32TrunkType;
568	rc = pHlp->pfnCFGMQueryU32(pCfg, "TrunkType", &u32TrunkType);
569	if (RT_FAILURE(rc))
570	return PDMDRV_SET_ERROR(pDrvIns, rc,
571	N_("Configuration error: Failed to get the \"TrunkType\" value"));
572
573	switch ((INTNETTRUNKTYPE)u32TrunkType)
574	{
575	case kIntNetTrunkType_NetAdp:
576	/*
577	* Get the network mask.
578	*/
579	rc = pHlp->pfnCFGMQueryString(pCfg, "NetworkMask", pThis->szNetworkMask, sizeof(pThis->szNetworkMask));
580	if (RT_FAILURE(rc))
581	return PDMDRV_SET_ERROR(pDrvIns, rc,
582	N_("Configuration error: Failed to get the \"NetworkMask\" value"));
583
584	/*
585	* Get the network mask.
586	*/
587	rc = pHlp->pfnCFGMQueryString(pCfg, "LowerIP", pThis->szLowerIP, sizeof(pThis->szLowerIP));
588	if (RT_FAILURE(rc))
589	return PDMDRV_SET_ERROR(pDrvIns, rc,
590	N_("Configuration error: Failed to get the \"LowerIP\" value"));
591
592	/*
593	* Get the network mask.
594	*/
595	rc = pHlp->pfnCFGMQueryString(pCfg, "UpperIP", pThis->szUpperIP, sizeof(pThis->szUpperIP));
596	if (RT_FAILURE(rc))
597	return PDMDRV_SET_ERROR(pDrvIns, rc,
598	N_("Configuration error: Failed to get the \"UpperIP\" value"));
599
600	pThis->uMode = VMNET_HOST_MODE;
601	LogRel(("VMNet: Host network with mask %s (%s to %s)\n", pThis->szNetworkMask, pThis->szLowerIP, pThis->szUpperIP));
602	break;
603
604	case kIntNetTrunkType_NetFlt:
605	/** @cfgm{Trunk, string}
606	* The name of the host interface to use for bridging.
607	*/
608	rc = pHlp->pfnCFGMQueryString(pCfg, "Trunk", pThis->szHostInterface, sizeof(pThis->szHostInterface));
609	if (RT_FAILURE(rc))
610	return PDMDRV_SET_ERROR(pDrvIns, rc,
611	N_("Configuration error: Failed to get the \"Trunk\" value"));
612	pThis->uMode = VMNET_BRIDGED_MODE;
613	LogRel(("VMNet: Bridge to %s\n", pThis->szHostInterface));
614	break;
615
616	default:
617	return PDMDRV_SET_ERROR(pDrvIns, rc,
618	N_("Configuration error: Unsupported \"TrunkType\" value"));
619	}
620
621	/*
622	* Check that no-one is attached to us.
623	*/
624	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
625	("Configuration error: Not possible to attach anything to this driver!\n"),
626	VERR_PDM_DRVINS_NO_ATTACH);
627
628	/*
629	* Query the network port interface.
630	*/
631	pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
632	if (!pThis->pIAboveNet)
633	{
634	AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
635	return VERR_PDM_MISSING_INTERFACE_ABOVE;
636	}
637
638	/*
639	* Query the network config interface.
640	*/
641	pThis->pIAboveConfig = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
642	if (!pThis->pIAboveConfig)
643	{
644	AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
645	return VERR_PDM_MISSING_INTERFACE_ABOVE;
646	}
647
648	vmnet_return_t status = drvVMNetAttach(pThis);
649	if (status != VMNET_SUCCESS)
650	return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
651	N_("Error: vmnet_start_interface returned %d"), status);
652
653	return VINF_SUCCESS;
654	}
655
656
657	/**
658	* Power On notification.
659	*
660	* @param pDrvIns The driver instance.
661	*/
662	static DECLCALLBACK(void) drvVMNetPowerOn(PPDMDRVINS pDrvIns)
663	{
664	LogFlow(("drvVMNetPowerOn\n"));
665	PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
666	ASMAtomicXchgSize(&pThis->enmState, VMNETSTATE_RUNNING);
667	}
668
669
670	/**
671	* Suspend notification.
672	*
673	* @param pDrvIns The driver instance.
674	*/
675	static DECLCALLBACK(void) drvVMNetSuspend(PPDMDRVINS pDrvIns)
676	{
677	LogFlow(("drvVMNetSuspend\n"));
678	PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
679	ASMAtomicXchgSize(&pThis->enmState, VMNETSTATE_SUSPENDED);
680	}
681
682
683	/**
684	* Resume notification.
685	*
686	* @param pDrvIns The driver instance.
687	*/
688	static DECLCALLBACK(void) drvVMNetResume(PPDMDRVINS pDrvIns)
689	{
690	LogFlow(("drvVMNetResume\n"));
691	PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
692	ASMAtomicXchgSize(&pThis->enmState, VMNETSTATE_RUNNING);
693	}
694
695
696
697	/**
698	* Network sniffer filter driver registration record.
699	*/
700	const PDMDRVREG g_DrvVMNet =
701	{
702	/* u32Version */
703	PDM_DRVREG_VERSION,
704	/* szName */
705	"VMNet",
706	/* szRCMod */
707	"",
708	/* szR0Mod */
709	"",
710	/* pszDescription */
711	"VMNET Filter Driver",
712	/* fFlags */
713	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
714	/* fClass. */
715	PDM_DRVREG_CLASS_NETWORK,
716	/* cMaxInstances */
717	UINT32_MAX,
718	/* cbInstance */
719	sizeof(DRVVMNET),
720	/* pfnConstruct */
721	drvVMNetConstruct,
722	/* pfnDestruct */
723	drvVMNetDestruct,
724	/* pfnRelocate */
725	NULL,
726	/* pfnIOCtl */
727	NULL,
728	/* pfnPowerOn */
729	drvVMNetPowerOn,
730	/* pfnReset */
731	NULL,
732	/* pfnSuspend */
733	drvVMNetSuspend,
734	/* pfnResume */
735	drvVMNetResume,
736	/* pfnAttach */
737	NULL,
738	/* pfnDetach */
739	NULL,
740	/* pfnPowerOff */
741	NULL,
742	/* pfnSoftReset */
743	NULL,
744	/* u32EndVersion */
745	PDM_DRVREG_VERSION
746	};
747

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

source: vbox/trunk/src/VBox/Devices/Network/DrvVMNet.m@ 105818

Download in other formats: