DrvIntNet.cpp@ 61541

Last change on this file since 61541 was 60076, checked in by vboxsync, 9 years ago
IntNet: Unregister all registered statistics counters.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.9 KB

Line
1	/* $Id: DrvIntNet.cpp 60076 2016-03-17 13:38:30Z vboxsync $ */
2	/** @file
3	* DrvIntNet - Internal network transport driver.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DRV_INTNET
23	#include <VBox/vmm/pdmdrv.h>
24	#include <VBox/vmm/pdmnetinline.h>
25	#include <VBox/vmm/pdmnetifs.h>
26	#include <VBox/vmm/cfgm.h>
27	#include <VBox/intnet.h>
28	#include <VBox/intnetinline.h>
29	#include <VBox/vmm/vmm.h>
30	#include <VBox/sup.h>
31	#include <VBox/err.h>
32
33	#include <VBox/param.h>
34	#include <VBox/log.h>
35	#include <iprt/asm.h>
36	#include <iprt/assert.h>
37	#include <iprt/ctype.h>
38	#include <iprt/memcache.h>
39	#include <iprt/net.h>
40	#include <iprt/semaphore.h>
41	#include <iprt/string.h>
42	#include <iprt/time.h>
43	#include <iprt/thread.h>
44	#include <iprt/uuid.h>
45	#if defined(RT_OS_DARWIN) && defined(IN_RING3)
46	# include <iprt/system.h>
47	#endif
48
49	#include "VBoxDD.h"
50
51
52	/*********************************************************************************************************************************
53	* Defined Constants And Macros *
54	*********************************************************************************************************************************/
55	/** Enables the ring-0 part. */
56	#define VBOX_WITH_DRVINTNET_IN_R0
57
58
59	/*********************************************************************************************************************************
60	* Structures and Typedefs *
61	*********************************************************************************************************************************/
62	/**
63	* The state of the asynchronous thread.
64	*/
65	typedef enum RECVSTATE
66	{
67	/** The thread is suspended. */
68	RECVSTATE_SUSPENDED = 1,
69	/** The thread is running. */
70	RECVSTATE_RUNNING,
71	/** The thread must (/has) terminate. */
72	RECVSTATE_TERMINATE,
73	/** The usual 32-bit type blowup. */
74	RECVSTATE_32BIT_HACK = 0x7fffffff
75	} RECVSTATE;
76
77	/**
78	* Internal networking driver instance data.
79	*
80	* @implements PDMINETWORKUP
81	*/
82	typedef struct DRVINTNET
83	{
84	/** The network interface. */
85	PDMINETWORKUP INetworkUpR3;
86	/** The network interface. */
87	R3PTRTYPE(PPDMINETWORKDOWN) pIAboveNet;
88	/** The network config interface.
89	* Can (in theory at least) be NULL. */
90	R3PTRTYPE(PPDMINETWORKCONFIG) pIAboveConfigR3;
91	/** Pointer to the driver instance (ring-3). */
92	PPDMDRVINSR3 pDrvInsR3;
93	/** Pointer to the communication buffer (ring-3). */
94	R3PTRTYPE(PINTNETBUF) pBufR3;
95	/** Ring-3 base interface for the ring-0 context. */
96	PDMIBASER0 IBaseR0;
97	/** Ring-3 base interface for the raw-mode context. */
98	PDMIBASERC IBaseRC;
99	RTR3PTR R3PtrAlignment;
100
101	/** The network interface for the ring-0 context. */
102	PDMINETWORKUPR0 INetworkUpR0;
103	/** Pointer to the driver instance (ring-0). */
104	PPDMDRVINSR0 pDrvInsR0;
105	/** Pointer to the communication buffer (ring-0). */
106	R0PTRTYPE(PINTNETBUF) pBufR0;
107
108	/** The network interface for the raw-mode context. */
109	PDMINETWORKUPRC INetworkUpRC;
110	/** Pointer to the driver instance. */
111	PPDMDRVINSRC pDrvInsRC;
112	RTRCPTR RCPtrAlignment;
113
114	/** The transmit lock. */
115	PDMCRITSECT XmitLock;
116	/** Interface handle. */
117	INTNETIFHANDLE hIf;
118	/** The receive thread state. */
119	RECVSTATE volatile enmRecvState;
120	/** The receive thread. */
121	RTTHREAD hRecvThread;
122	/** The event semaphore that the receive thread waits on. */
123	RTSEMEVENT hRecvEvt;
124	/** The transmit thread. */
125	PPDMTHREAD pXmitThread;
126	/** The event semaphore that the transmit thread waits on. */
127	SUPSEMEVENT hXmitEvt;
128	/** The support driver session handle. */
129	PSUPDRVSESSION pSupDrvSession;
130	/** Scatter/gather descriptor cache. */
131	RTMEMCACHE hSgCache;
132	/** Set if the link is down.
133	* When the link is down all incoming packets will be dropped. */
134	bool volatile fLinkDown;
135	/** Set when the xmit thread has been signalled. (atomic) */
136	bool volatile fXmitSignalled;
137	/** Set if the transmit thread the one busy transmitting. */
138	bool volatile fXmitOnXmitThread;
139	/** The xmit thread should process the ring ASAP. */
140	bool fXmitProcessRing;
141	/** Set if data transmission should start immediately and deactivate
142	* as late as possible. */
143	bool fActivateEarlyDeactivateLate;
144	/** Padding. */
145	bool afReserved[HC_ARCH_BITS == 64 ? 3 : 3];
146	/** Scratch space for holding the ring-0 scatter / gather descriptor.
147	* The PDMSCATTERGATHER::fFlags member is used to indicate whether it is in
148	* use or not. Always accessed while owning the XmitLock. */
149	union
150	{
151	PDMSCATTERGATHER Sg;
152	uint8_t padding[8 * sizeof(RTUINTPTR)];
153	} u;
154	/** The network name. */
155	char szNetwork[INTNET_MAX_NETWORK_NAME];
156
157	/** Number of GSO packets sent. */
158	STAMCOUNTER StatSentGso;
159	/** Number of GSO packets received. */
160	STAMCOUNTER StatReceivedGso;
161	/** Number of packets send from ring-0. */
162	STAMCOUNTER StatSentR0;
163	/** The number of times we've had to wake up the xmit thread to continue the
164	* ring-0 job. */
165	STAMCOUNTER StatXmitWakeupR0;
166	/** The number of times we've had to wake up the xmit thread to continue the
167	* ring-3 job. */
168	STAMCOUNTER StatXmitWakeupR3;
169	/** The times the xmit thread has been told to process the ring. */
170	STAMCOUNTER StatXmitProcessRing;
171	#ifdef VBOX_WITH_STATISTICS
172	/** Profiling packet transmit runs. */
173	STAMPROFILE StatTransmit;
174	/** Profiling packet receive runs. */
175	STAMPROFILEADV StatReceive;
176	#endif /* VBOX_WITH_STATISTICS */
177	#ifdef LOG_ENABLED
178	/** The nano ts of the last transfer. */
179	uint64_t u64LastTransferTS;
180	/** The nano ts of the last receive. */
181	uint64_t u64LastReceiveTS;
182	#endif
183	} DRVINTNET;
184	AssertCompileMemberAlignment(DRVINTNET, XmitLock, 8);
185	AssertCompileMemberAlignment(DRVINTNET, StatSentGso, 8);
186	/** Pointer to instance data of the internal networking driver. */
187	typedef DRVINTNET *PDRVINTNET;
188
189	/**
190	* Config value to flag translation structure.
191	*/
192	typedef struct DRVINTNETFLAG
193	{
194	/** The value. */
195	const char *pszChoice;
196	/** The corresponding flag. */
197	uint32_t fFlag;
198	} DRVINTNETFLAG;
199	/** Pointer to a const flag value translation. */
200	typedef DRVINTNETFLAG const *PCDRVINTNETFLAG;
201
202
203	#ifdef IN_RING3
204
205
206	/**
207	* Updates the MAC address on the kernel side.
208	*
209	* @returns VBox status code.
210	* @param pThis The driver instance.
211	*/
212	static int drvR3IntNetUpdateMacAddress(PDRVINTNET pThis)
213	{
214	if (!pThis->pIAboveConfigR3)
215	return VINF_SUCCESS;
216
217	INTNETIFSETMACADDRESSREQ SetMacAddressReq;
218	SetMacAddressReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
219	SetMacAddressReq.Hdr.cbReq = sizeof(SetMacAddressReq);
220	SetMacAddressReq.pSession = NIL_RTR0PTR;
221	SetMacAddressReq.hIf = pThis->hIf;
222	int rc = pThis->pIAboveConfigR3->pfnGetMac(pThis->pIAboveConfigR3, &SetMacAddressReq.Mac);
223	if (RT_SUCCESS(rc))
224	rc = PDMDrvHlpSUPCallVMMR0Ex(pThis->pDrvInsR3, VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS,
225	&SetMacAddressReq, sizeof(SetMacAddressReq));
226
227	Log(("drvR3IntNetUpdateMacAddress: %.*Rhxs rc=%Rrc\n", sizeof(SetMacAddressReq.Mac), &SetMacAddressReq.Mac, rc));
228	return rc;
229	}
230
231
232	/**
233	* Sets the kernel interface active or inactive.
234	*
235	* Worker for poweron, poweroff, suspend and resume.
236	*
237	* @returns VBox status code.
238	* @param pThis The driver instance.
239	* @param fActive The new state.
240	*/
241	static int drvR3IntNetSetActive(PDRVINTNET pThis, bool fActive)
242	{
243	if (!pThis->pIAboveConfigR3)
244	return VINF_SUCCESS;
245
246	INTNETIFSETACTIVEREQ SetActiveReq;
247	SetActiveReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
248	SetActiveReq.Hdr.cbReq = sizeof(SetActiveReq);
249	SetActiveReq.pSession = NIL_RTR0PTR;
250	SetActiveReq.hIf = pThis->hIf;
251	SetActiveReq.fActive = fActive;
252	int rc = PDMDrvHlpSUPCallVMMR0Ex(pThis->pDrvInsR3, VMMR0_DO_INTNET_IF_SET_ACTIVE,
253	&SetActiveReq, sizeof(SetActiveReq));
254
255	Log(("drvR3IntNetSetActive: fActive=%d rc=%Rrc\n", fActive, rc));
256	AssertRC(rc);
257	return rc;
258	}
259
260	#endif /* IN_RING3 */
261
262	/* -=-=-=-=- PDMINETWORKUP -=-=-=-=- */
263
264	/**
265	* Helper for signalling the xmit thread.
266	*
267	* @returns VERR_TRY_AGAIN (convenience).
268	* @param pThis The instance data..
269	*/
270	DECLINLINE(int) drvIntNetSignalXmit(PDRVINTNET pThis)
271	{
272	/// @todo if (!ASMAtomicXchgBool(&pThis->fXmitSignalled, true)) - needs careful optimizing.
273	{
274	int rc = SUPSemEventSignal(pThis->pSupDrvSession, pThis->hXmitEvt);
275	AssertRC(rc);
276	STAM_REL_COUNTER_INC(&pThis->CTX_SUFF(StatXmitWakeup));
277	}
278	return VERR_TRY_AGAIN;
279	}
280
281
282	/**
283	* Helper for processing the ring-0 consumer side of the xmit ring.
284	*
285	* The caller MUST own the xmit lock.
286	*
287	* @returns Status code from IntNetR0IfSend, except for VERR_TRY_AGAIN.
288	* @param pThis The instance data..
289	*/
290	DECLINLINE(int) drvIntNetProcessXmit(PDRVINTNET pThis)
291	{
292	Assert(PDMCritSectIsOwner(&pThis->XmitLock));
293
294	#ifdef IN_RING3
295	INTNETIFSENDREQ SendReq;
296	SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
297	SendReq.Hdr.cbReq = sizeof(SendReq);
298	SendReq.pSession = NIL_RTR0PTR;
299	SendReq.hIf = pThis->hIf;
300	int rc = PDMDrvHlpSUPCallVMMR0Ex(pThis->pDrvInsR3, VMMR0_DO_INTNET_IF_SEND, &SendReq, sizeof(SendReq));
301	#else
302	int rc = IntNetR0IfSend(pThis->hIf, pThis->pSupDrvSession);
303	if (rc == VERR_TRY_AGAIN)
304	{
305	ASMAtomicUoWriteBool(&pThis->fXmitProcessRing, true);
306	drvIntNetSignalXmit(pThis);
307	rc = VINF_SUCCESS;
308	}
309	#endif
310	return rc;
311	}
312
313
314
315	/**
316	* @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
317	*/
318	PDMBOTHCBDECL(int) drvIntNetUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
319	{
320	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, CTX_SUFF(INetworkUp));
321	#ifndef IN_RING3
322	Assert(!fOnWorkerThread);
323	#endif
324
325	int rc = PDMCritSectTryEnter(&pThis->XmitLock);
326	if (RT_SUCCESS(rc))
327	{
328	if (fOnWorkerThread)
329	{
330	ASMAtomicUoWriteBool(&pThis->fXmitOnXmitThread, true);
331	ASMAtomicWriteBool(&pThis->fXmitSignalled, false);
332	}
333	}
334	else if (rc == VERR_SEM_BUSY)
335	{
336	/** @todo Does this actually make sense if the other dude is an EMT and so
337	* forth? I seriously think this is ring-0 only...
338	* We might end up waking up the xmit thread unnecessarily here, even when in
339	* ring-0... This needs some more thought and optimizations when the ring-0 bits
340	* are working. */
341	#ifdef IN_RING3
342	if ( !fOnWorkerThread
343	/*&& !ASMAtomicUoReadBool(&pThis->fXmitOnXmitThread)
344	&& ASMAtomicCmpXchgBool(&pThis->fXmitSignalled, true, false)*/)
345	{
346	rc = SUPSemEventSignal(pThis->pSupDrvSession, pThis->hXmitEvt);
347	AssertRC(rc);
348	}
349	rc = VERR_TRY_AGAIN;
350	#else /* IN_RING0 */
351	rc = drvIntNetSignalXmit(pThis);
352	#endif /* IN_RING0 */
353	}
354	return rc;
355	}
356
357
358	/**
359	* @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
360	*/
361	PDMBOTHCBDECL(int) drvIntNetUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
362	PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
363	{
364	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, CTX_SUFF(INetworkUp));
365	int rc = VINF_SUCCESS;
366	Assert(cbMin < UINT32_MAX / 2);
367	Assert(PDMCritSectIsOwner(&pThis->XmitLock));
368
369	/*
370	* Allocate a S/G descriptor.
371	* This shouldn't normally fail as the NICs usually won't allocate more
372	* than one buffer at a time and the SG gets freed on sending.
373	*/
374	#ifdef IN_RING3
375	PPDMSCATTERGATHER pSgBuf = (PPDMSCATTERGATHER)RTMemCacheAlloc(pThis->hSgCache);
376	if (!pSgBuf)
377	return VERR_NO_MEMORY;
378	#else
379	PPDMSCATTERGATHER pSgBuf = &pThis->u.Sg;
380	if (RT_UNLIKELY(pSgBuf->fFlags != 0))
381	return drvIntNetSignalXmit(pThis);
382	#endif
383
384	/*
385	* Allocate room in the ring buffer.
386	*
387	* In ring-3 we may have to process the xmit ring before there is
388	* sufficient buffer space since we might have stacked up a few frames to the
389	* trunk while in ring-0. (There is not point of doing this in ring-0.)
390	*/
391	PINTNETHDR pHdr = NULL; /* gcc silliness */
392	if (pGso)
393	rc = IntNetRingAllocateGsoFrame(&pThis->CTX_SUFF(pBuf)->Send, (uint32_t)cbMin, pGso,
394	&pHdr, &pSgBuf->aSegs[0].pvSeg);
395	else
396	rc = IntNetRingAllocateFrame(&pThis->CTX_SUFF(pBuf)->Send, (uint32_t)cbMin,
397	&pHdr, &pSgBuf->aSegs[0].pvSeg);
398	#ifdef IN_RING3
399	if ( RT_FAILURE(rc)
400	&& pThis->CTX_SUFF(pBuf)->cbSend >= cbMin * 2 + sizeof(INTNETHDR))
401	{
402	drvIntNetProcessXmit(pThis);
403	if (pGso)
404	rc = IntNetRingAllocateGsoFrame(&pThis->CTX_SUFF(pBuf)->Send, (uint32_t)cbMin, pGso,
405	&pHdr, &pSgBuf->aSegs[0].pvSeg);
406	else
407	rc = IntNetRingAllocateFrame(&pThis->CTX_SUFF(pBuf)->Send, (uint32_t)cbMin,
408	&pHdr, &pSgBuf->aSegs[0].pvSeg);
409	}
410	#endif
411	if (RT_SUCCESS(rc))
412	{
413	/*
414	* Set up the S/G descriptor and return successfully.
415	*/
416	pSgBuf->fFlags = PDMSCATTERGATHER_FLAGS_MAGIC \| PDMSCATTERGATHER_FLAGS_OWNER_1;
417	pSgBuf->cbUsed = 0;
418	pSgBuf->cbAvailable = cbMin;
419	pSgBuf->pvAllocator = pHdr;
420	pSgBuf->pvUser = pGso ? (PPDMNETWORKGSO)pSgBuf->aSegs[0].pvSeg - 1 : NULL;
421	pSgBuf->cSegs = 1;
422	pSgBuf->aSegs[0].cbSeg = cbMin;
423
424	*ppSgBuf = pSgBuf;
425	return VINF_SUCCESS;
426	}
427
428	#ifdef IN_RING3
429	/*
430	* If the above fails, then we're really out of space. There are nobody
431	* competing with us here because of the xmit lock.
432	*/
433	rc = VERR_NO_MEMORY;
434	RTMemCacheFree(pThis->hSgCache, pSgBuf);
435
436	#else /* IN_RING0 */
437	/*
438	* If the request is reasonable, kick the xmit thread and tell it to
439	* process the xmit ring ASAP.
440	*/
441	if (pThis->CTX_SUFF(pBuf)->cbSend >= cbMin * 2 + sizeof(INTNETHDR))
442	{
443	pThis->fXmitProcessRing = true;
444	rc = drvIntNetSignalXmit(pThis);
445	}
446	else
447	rc = VERR_NO_MEMORY;
448	pSgBuf->fFlags = 0;
449	#endif /* IN_RING0 */
450	return rc;
451	}
452
453
454	/**
455	* @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
456	*/
457	PDMBOTHCBDECL(int) drvIntNetUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
458	{
459	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, CTX_SUFF(INetworkUp));
460	PINTNETHDR pHdr = (PINTNETHDR)pSgBuf->pvAllocator;
461	#ifdef IN_RING0
462	Assert(pSgBuf == &pThis->u.Sg);
463	#endif
464	Assert(pSgBuf->fFlags == (PDMSCATTERGATHER_FLAGS_MAGIC \| PDMSCATTERGATHER_FLAGS_OWNER_1));
465	Assert(pSgBuf->cbUsed <= pSgBuf->cbAvailable);
466	Assert( pHdr->u8Type == INTNETHDR_TYPE_FRAME
467	\|\| pHdr->u8Type == INTNETHDR_TYPE_GSO);
468	Assert(PDMCritSectIsOwner(&pThis->XmitLock));
469
470	/** @todo LATER: try unalloc the frame. */
471	pHdr->u8Type = INTNETHDR_TYPE_PADDING;
472	IntNetRingCommitFrame(&pThis->CTX_SUFF(pBuf)->Send, pHdr);
473
474	#ifdef IN_RING3
475	RTMemCacheFree(pThis->hSgCache, pSgBuf);
476	#else
477	pSgBuf->fFlags = 0;
478	#endif
479	return VINF_SUCCESS;
480	}
481
482
483	/**
484	* @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
485	*/
486	PDMBOTHCBDECL(int) drvIntNetUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
487	{
488	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, CTX_SUFF(INetworkUp));
489	STAM_PROFILE_START(&pThis->StatTransmit, a);
490
491	AssertPtr(pSgBuf);
492	Assert(pSgBuf->fFlags == (PDMSCATTERGATHER_FLAGS_MAGIC \| PDMSCATTERGATHER_FLAGS_OWNER_1));
493	Assert(pSgBuf->cbUsed <= pSgBuf->cbAvailable);
494	Assert(PDMCritSectIsOwner(&pThis->XmitLock));
495
496	if (pSgBuf->pvUser)
497	STAM_COUNTER_INC(&pThis->StatSentGso);
498
499	/* Set an FTM checkpoint as this operation changes the state permanently. */
500	PDMDrvHlpFTSetCheckpoint(pThis->CTX_SUFF(pDrvIns), FTMCHECKPOINTTYPE_NETWORK);
501
502	/*
503	* Commit the frame and push it thru the switch.
504	*/
505	PINTNETHDR pHdr = (PINTNETHDR)pSgBuf->pvAllocator;
506	IntNetRingCommitFrameEx(&pThis->CTX_SUFF(pBuf)->Send, pHdr, pSgBuf->cbUsed);
507	int rc = drvIntNetProcessXmit(pThis);
508	STAM_PROFILE_STOP(&pThis->StatTransmit, a);
509
510	/*
511	* Free the descriptor and return.
512	*/
513	#ifdef IN_RING3
514	RTMemCacheFree(pThis->hSgCache, pSgBuf);
515	#else
516	STAM_REL_COUNTER_INC(&pThis->StatSentR0);
517	pSgBuf->fFlags = 0;
518	#endif
519	return rc;
520	}
521
522
523	/**
524	* @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
525	*/
526	PDMBOTHCBDECL(void) drvIntNetUp_EndXmit(PPDMINETWORKUP pInterface)
527	{
528	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, CTX_SUFF(INetworkUp));
529	ASMAtomicUoWriteBool(&pThis->fXmitOnXmitThread, false);
530	PDMCritSectLeave(&pThis->XmitLock);
531	}
532
533
534	/**
535	* @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
536	*/
537	PDMBOTHCBDECL(void) drvIntNetUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
538	{
539	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, CTX_SUFF(INetworkUp));
540
541	#ifdef IN_RING3
542	INTNETIFSETPROMISCUOUSMODEREQ Req;
543	Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
544	Req.Hdr.cbReq = sizeof(Req);
545	Req.pSession = NIL_RTR0PTR;
546	Req.hIf = pThis->hIf;
547	Req.fPromiscuous = fPromiscuous;
548	int rc = PDMDrvHlpSUPCallVMMR0Ex(pThis->pDrvInsR3, VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE, &Req, sizeof(Req));
549	#else /* IN_RING0 */
550	int rc = IntNetR0IfSetPromiscuousMode(pThis->hIf, pThis->pSupDrvSession, fPromiscuous);
551	#endif /* IN_RING0 */
552
553	LogFlow(("drvIntNetUp_SetPromiscuousMode: fPromiscuous=%RTbool\n", fPromiscuous));
554	AssertRC(rc);
555	}
556
557	#ifdef IN_RING3
558
559	/**
560	* @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
561	*/
562	static DECLCALLBACK(void) drvR3IntNetUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
563	{
564	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, CTX_SUFF(INetworkUp));
565	bool fLinkDown;
566	switch (enmLinkState)
567	{
568	case PDMNETWORKLINKSTATE_DOWN:
569	case PDMNETWORKLINKSTATE_DOWN_RESUME:
570	fLinkDown = true;
571	break;
572	default:
573	AssertMsgFailed(("enmLinkState=%d\n", enmLinkState));
574	case PDMNETWORKLINKSTATE_UP:
575	fLinkDown = false;
576	break;
577	}
578	LogFlow(("drvR3IntNetUp_NotifyLinkChanged: enmLinkState=%d %d->%d\n", enmLinkState, pThis->fLinkDown, fLinkDown));
579	ASMAtomicXchgSize(&pThis->fLinkDown, fLinkDown);
580	}
581
582
583	/* -=-=-=-=- Transmit Thread -=-=-=-=- */
584
585	/**
586	* Async I/O thread for deferred packet transmission.
587	*
588	* @returns VBox status code. Returning failure will naturally terminate the thread.
589	* @param pDrvIns The internal networking driver instance.
590	* @param pThread The thread.
591	*/
592	static DECLCALLBACK(int) drvR3IntNetXmitThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
593	{
594	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
595
596	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
597	{
598	/*
599	* Transmit any pending packets.
600	*/
601	/** @todo Optimize this. We shouldn't call pfnXmitPending unless asked for.
602	* Also there is no need to call drvIntNetProcessXmit if we also
603	* called pfnXmitPending and send one or more frames. */
604	if (ASMAtomicXchgBool(&pThis->fXmitProcessRing, false))
605	{
606	STAM_REL_COUNTER_INC(&pThis->StatXmitProcessRing);
607	PDMCritSectEnter(&pThis->XmitLock, VERR_IGNORED);
608	drvIntNetProcessXmit(pThis);
609	PDMCritSectLeave(&pThis->XmitLock);
610	}
611
612	pThis->pIAboveNet->pfnXmitPending(pThis->pIAboveNet);
613
614	if (ASMAtomicXchgBool(&pThis->fXmitProcessRing, false))
615	{
616	STAM_REL_COUNTER_INC(&pThis->StatXmitProcessRing);
617	PDMCritSectEnter(&pThis->XmitLock, VERR_IGNORED);
618	drvIntNetProcessXmit(pThis);
619	PDMCritSectLeave(&pThis->XmitLock);
620	}
621
622	/*
623	* Block until we've got something to send or is supposed
624	* to leave the running state.
625	*/
626	int rc = SUPSemEventWaitNoResume(pThis->pSupDrvSession, pThis->hXmitEvt, RT_INDEFINITE_WAIT);
627	AssertLogRelMsgReturn(RT_SUCCESS(rc) \|\| rc == VERR_INTERRUPTED, ("%Rrc\n", rc), rc);
628	if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
629	break;
630
631	}
632
633	/* The thread is being initialized, suspended or terminated. */
634	return VINF_SUCCESS;
635	}
636
637
638	/**
639	* @copydoc FNPDMTHREADWAKEUPDRV
640	*/
641	static DECLCALLBACK(int) drvR3IntNetXmitWakeUp(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
642	{
643	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
644	return SUPSemEventSignal(pThis->pSupDrvSession, pThis->hXmitEvt);
645	}
646
647
648	/* -=-=-=-=- Receive Thread -=-=-=-=- */
649
650	/**
651	* Wait for space to become available up the driver/device chain.
652	*
653	* @returns VINF_SUCCESS if space is available.
654	* @returns VERR_STATE_CHANGED if the state changed.
655	* @returns VBox status code on other errors.
656	* @param pThis Pointer to the instance data.
657	*/
658	static int drvR3IntNetRecvWaitForSpace(PDRVINTNET pThis)
659	{
660	LogFlow(("drvR3IntNetRecvWaitForSpace:\n"));
661	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
662	int rc = pThis->pIAboveNet->pfnWaitReceiveAvail(pThis->pIAboveNet, RT_INDEFINITE_WAIT);
663	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
664	LogFlow(("drvR3IntNetRecvWaitForSpace: returns %Rrc\n", rc));
665	return rc;
666	}
667
668
669	/**
670	* Executes async I/O (RUNNING mode).
671	*
672	* @returns VERR_STATE_CHANGED if the state changed.
673	* @returns Appropriate VBox status code (error) on fatal error.
674	* @param pThis The driver instance data.
675	*/
676	static int drvR3IntNetRecvRun(PDRVINTNET pThis)
677	{
678	PPDMDRVINS pDrvIns = pThis->pDrvInsR3;
679	LogFlow(("drvR3IntNetRecvRun: pThis=%p\n", pThis));
680
681	/*
682	* The running loop - processing received data and waiting for more to arrive.
683	*/
684	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
685	PINTNETBUF pBuf = pThis->CTX_SUFF(pBuf);
686	PINTNETRINGBUF pRingBuf = &pBuf->Recv;
687	for (;;)
688	{
689	/*
690	* Process the receive buffer.
691	*/
692	PINTNETHDR pHdr;
693	while ((pHdr = IntNetRingGetNextFrameToRead(pRingBuf)) != NULL)
694	{
695	/*
696	* Check the state and then inspect the packet.
697	*/
698	if (pThis->enmRecvState != RECVSTATE_RUNNING)
699	{
700	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
701	LogFlow(("drvR3IntNetRecvRun: returns VERR_STATE_CHANGED (state changed - #0)\n"));
702	return VERR_STATE_CHANGED;
703	}
704
705	Log2(("pHdr=%p offRead=%#x: %.8Rhxs\n", pHdr, pRingBuf->offReadX, pHdr));
706	uint8_t u8Type = pHdr->u8Type;
707	if ( ( u8Type == INTNETHDR_TYPE_FRAME
708	\|\| u8Type == INTNETHDR_TYPE_GSO)
709	&& !pThis->fLinkDown)
710	{
711	/*
712	* Check if there is room for the frame and pass it up.
713	*/
714	size_t cbFrame = pHdr->cbFrame;
715	int rc = pThis->pIAboveNet->pfnWaitReceiveAvail(pThis->pIAboveNet, 0);
716	if (rc == VINF_SUCCESS)
717	{
718	if (u8Type == INTNETHDR_TYPE_FRAME)
719	{
720	/*
721	* Normal frame.
722	*/
723	#ifdef LOG_ENABLED
724	if (LogIsEnabled())
725	{
726	uint64_t u64Now = RTTimeProgramNanoTS();
727	LogFlow(("drvR3IntNetRecvRun: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
728	cbFrame, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
729	pThis->u64LastReceiveTS = u64Now;
730	Log2(("drvR3IntNetRecvRun: cbFrame=%#x\n"
731	"%.*Rhxd\n",
732	cbFrame, cbFrame, IntNetHdrGetFramePtr(pHdr, pBuf)));
733	}
734	#endif
735	rc = pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, IntNetHdrGetFramePtr(pHdr, pBuf), cbFrame);
736	AssertRC(rc);
737
738	/* skip to the next frame. */
739	IntNetRingSkipFrame(pRingBuf);
740	}
741	else
742	{
743	/*
744	* Generic segment offload frame (INTNETHDR_TYPE_GSO).
745	*/
746	STAM_COUNTER_INC(&pThis->StatReceivedGso);
747	PCPDMNETWORKGSO pGso = IntNetHdrGetGsoContext(pHdr, pBuf);
748	if (PDMNetGsoIsValid(pGso, cbFrame, cbFrame - sizeof(PDMNETWORKGSO)))
749	{
750	if (!pThis->pIAboveNet->pfnReceiveGso \|\|
751	RT_FAILURE(pThis->pIAboveNet->pfnReceiveGso(pThis->pIAboveNet,
752	(uint8_t *)(pGso + 1),
753	pHdr->cbFrame - sizeof(PDMNETWORKGSO),
754	pGso)))
755	{
756	/*
757	*
758	* This is where we do the offloading since this NIC
759	* does not support large receive offload (LRO).
760	*/
761	cbFrame -= sizeof(PDMNETWORKGSO);
762
763	uint8_t abHdrScratch[256];
764	uint32_t const cSegs = PDMNetGsoCalcSegmentCount(pGso, cbFrame);
765	#ifdef LOG_ENABLED
766	if (LogIsEnabled())
767	{
768	uint64_t u64Now = RTTimeProgramNanoTS();
769	LogFlow(("drvR3IntNetRecvRun: %-4d bytes at %llu ns deltas: r=%llu t=%llu; GSO - %u segs\n",
770	cbFrame, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS, cSegs));
771	pThis->u64LastReceiveTS = u64Now;
772	Log2(("drvR3IntNetRecvRun: cbFrame=%#x type=%d cbHdrsTotal=%#x cbHdrsSeg=%#x Hdr1=%#x Hdr2=%#x MMS=%#x\n"
773	"%.*Rhxd\n",
774	cbFrame, pGso->u8Type, pGso->cbHdrsTotal, pGso->cbHdrsSeg, pGso->offHdr1, pGso->offHdr2, pGso->cbMaxSeg,
775	cbFrame - sizeof(*pGso), pGso + 1));
776	}
777	#endif
778	for (size_t iSeg = 0; iSeg < cSegs; iSeg++)
779	{
780	uint32_t cbSegFrame;
781	void pvSegFrame = PDMNetGsoCarveSegmentQD(pGso, (uint8_t )(pGso + 1), cbFrame, abHdrScratch,
782	iSeg, cSegs, &cbSegFrame);
783	rc = drvR3IntNetRecvWaitForSpace(pThis);
784	if (RT_FAILURE(rc))
785	{
786	Log(("drvR3IntNetRecvRun: drvR3IntNetRecvWaitForSpace -> %Rrc; iSeg=%u cSegs=%u\n", rc, iSeg, cSegs));
787	break; /* we drop the rest. */
788	}
789	rc = pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, pvSegFrame, cbSegFrame);
790	AssertRC(rc);
791	}
792	}
793	}
794	else
795	{
796	AssertMsgFailed(("cbFrame=%#x type=%d cbHdrsTotal=%#x cbHdrsSeg=%#x Hdr1=%#x Hdr2=%#x MMS=%#x\n",
797	cbFrame, pGso->u8Type, pGso->cbHdrsTotal, pGso->cbHdrsSeg, pGso->offHdr1, pGso->offHdr2, pGso->cbMaxSeg));
798	STAM_REL_COUNTER_INC(&pBuf->cStatBadFrames);
799	}
800
801	IntNetRingSkipFrame(pRingBuf);
802	}
803	}
804	else
805	{
806	/*
807	* Wait for sufficient space to become available and then retry.
808	*/
809	rc = drvR3IntNetRecvWaitForSpace(pThis);
810	if (RT_FAILURE(rc))
811	{
812	if (rc == VERR_INTERRUPTED)
813	{
814	/*
815	* NIC is going down, likely because the VM is being reset. Skip the frame.
816	*/
817	AssertMsg(IntNetIsValidFrameType(pHdr->u8Type), ("Unknown frame type %RX16! offRead=%#x\n", pHdr->u8Type, pRingBuf->offReadX));
818	IntNetRingSkipFrame(pRingBuf);
819	}
820	else
821	{
822	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
823	LogFlow(("drvR3IntNetRecvRun: returns %Rrc (wait-for-space)\n", rc));
824	return rc;
825	}
826	}
827	}
828	}
829	else
830	{
831	/*
832	* Link down or unknown frame - skip to the next frame.
833	*/
834	AssertMsg(IntNetIsValidFrameType(pHdr->u8Type), ("Unknown frame type %RX16! offRead=%#x\n", pHdr->u8Type, pRingBuf->offReadX));
835	IntNetRingSkipFrame(pRingBuf);
836	STAM_REL_COUNTER_INC(&pBuf->cStatBadFrames);
837	}
838	} /* while more received data */
839
840	/*
841	* Wait for data, checking the state before we block.
842	*/
843	if (pThis->enmRecvState != RECVSTATE_RUNNING)
844	{
845	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
846	LogFlow(("drvR3IntNetRecvRun: returns VINF_SUCCESS (state changed - #1)\n"));
847	return VERR_STATE_CHANGED;
848	}
849	INTNETIFWAITREQ WaitReq;
850	WaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
851	WaitReq.Hdr.cbReq = sizeof(WaitReq);
852	WaitReq.pSession = NIL_RTR0PTR;
853	WaitReq.hIf = pThis->hIf;
854	WaitReq.cMillies = 30000; /* 30s - don't wait forever, timeout now and then. */
855	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
856	int rc = PDMDrvHlpSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_WAIT, &WaitReq, sizeof(WaitReq));
857	if ( RT_FAILURE(rc)
858	&& rc != VERR_TIMEOUT
859	&& rc != VERR_INTERRUPTED)
860	{
861	LogFlow(("drvR3IntNetRecvRun: returns %Rrc\n", rc));
862	return rc;
863	}
864	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
865	}
866	}
867
868
869	/**
870	* Asynchronous I/O thread for handling receive.
871	*
872	* @returns VINF_SUCCESS (ignored).
873	* @param ThreadSelf Thread handle.
874	* @param pvUser Pointer to a DRVINTNET structure.
875	*/
876	static DECLCALLBACK(int) drvR3IntNetRecvThread(RTTHREAD ThreadSelf, void *pvUser)
877	{
878	PDRVINTNET pThis = (PDRVINTNET)pvUser;
879	LogFlow(("drvR3IntNetRecvThread: pThis=%p\n", pThis));
880	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
881
882	/*
883	* The main loop - acting on state.
884	*/
885	for (;;)
886	{
887	RECVSTATE enmRecvState = pThis->enmRecvState;
888	switch (enmRecvState)
889	{
890	case RECVSTATE_SUSPENDED:
891	{
892	int rc = RTSemEventWait(pThis->hRecvEvt, 30000);
893	if ( RT_FAILURE(rc)
894	&& rc != VERR_TIMEOUT)
895	{
896	LogFlow(("drvR3IntNetRecvThread: returns %Rrc\n", rc));
897	return rc;
898	}
899	break;
900	}
901
902	case RECVSTATE_RUNNING:
903	{
904	int rc = drvR3IntNetRecvRun(pThis);
905	if ( rc != VERR_STATE_CHANGED
906	&& RT_FAILURE(rc))
907	{
908	LogFlow(("drvR3IntNetRecvThread: returns %Rrc\n", rc));
909	return rc;
910	}
911	break;
912	}
913
914	default:
915	AssertMsgFailed(("Invalid state %d\n", enmRecvState));
916	case RECVSTATE_TERMINATE:
917	LogFlow(("drvR3IntNetRecvThread: returns VINF_SUCCESS\n"));
918	return VINF_SUCCESS;
919	}
920	}
921	}
922
923
924	/* -=-=-=-=- PDMIBASERC -=-=-=-=- */
925
926	/**
927	* @interface_method_impl{PDMIBASERC,pfnQueryInterface}
928	*/
929	static DECLCALLBACK(RTRCPTR) drvR3IntNetIBaseRC_QueryInterface(PPDMIBASERC pInterface, const char *pszIID)
930	{
931	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, IBaseRC);
932
933	#if 0
934	PDMIBASERC_RETURN_INTERFACE(pThis->pDrvInsR3, pszIID, PDMINETWORKUP, &pThis->INetworkUpRC);
935	#endif
936	return NIL_RTRCPTR;
937	}
938
939
940	/* -=-=-=-=- PDMIBASER0 -=-=-=-=- */
941
942	/**
943	* @interface_method_impl{PDMIBASER0,pfnQueryInterface}
944	*/
945	static DECLCALLBACK(RTR0PTR) drvR3IntNetIBaseR0_QueryInterface(PPDMIBASER0 pInterface, const char *pszIID)
946	{
947	PDRVINTNET pThis = RT_FROM_MEMBER(pInterface, DRVINTNET, IBaseR0);
948	#ifdef VBOX_WITH_DRVINTNET_IN_R0
949	PDMIBASER0_RETURN_INTERFACE(pThis->pDrvInsR3, pszIID, PDMINETWORKUP, &pThis->INetworkUpR0);
950	#endif
951	return NIL_RTR0PTR;
952	}
953
954
955	/* -=-=-=-=- PDMIBASE -=-=-=-=- */
956
957	/**
958	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
959	*/
960	static DECLCALLBACK(void ) drvR3IntNetIBase_QueryInterface(PPDMIBASE pInterface, const char pszIID)
961	{
962	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
963	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
964
965	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
966	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASER0, &pThis->IBaseR0);
967	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASERC, &pThis->IBaseRC);
968	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUpR3);
969	return NULL;
970	}
971
972
973	/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
974
975	/**
976	* Power Off notification.
977	*
978	* @param pDrvIns The driver instance.
979	*/
980	static DECLCALLBACK(void) drvR3IntNetPowerOff(PPDMDRVINS pDrvIns)
981	{
982	LogFlow(("drvR3IntNetPowerOff\n"));
983	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
984	if (!pThis->fActivateEarlyDeactivateLate)
985	{
986	ASMAtomicXchgSize(&pThis->enmRecvState, RECVSTATE_SUSPENDED);
987	drvR3IntNetSetActive(pThis, false /* fActive */);
988	}
989	}
990
991
992	/**
993	* drvR3IntNetResume helper.
994	*/
995	static int drvR3IntNetResumeSend(PDRVINTNET pThis, const void *pvBuf, size_t cb)
996	{
997	/*
998	* Add the frame to the send buffer and push it onto the network.
999	*/
1000	int rc = IntNetRingWriteFrame(&pThis->pBufR3->Send, pvBuf, (uint32_t)cb);
1001	if ( rc == VERR_BUFFER_OVERFLOW
1002	&& pThis->pBufR3->cbSend < cb)
1003	{
1004	INTNETIFSENDREQ SendReq;
1005	SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1006	SendReq.Hdr.cbReq = sizeof(SendReq);
1007	SendReq.pSession = NIL_RTR0PTR;
1008	SendReq.hIf = pThis->hIf;
1009	PDMDrvHlpSUPCallVMMR0Ex(pThis->pDrvInsR3, VMMR0_DO_INTNET_IF_SEND, &SendReq, sizeof(SendReq));
1010
1011	rc = IntNetRingWriteFrame(&pThis->pBufR3->Send, pvBuf, (uint32_t)cb);
1012	}
1013
1014	if (RT_SUCCESS(rc))
1015	{
1016	INTNETIFSENDREQ SendReq;
1017	SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1018	SendReq.Hdr.cbReq = sizeof(SendReq);
1019	SendReq.pSession = NIL_RTR0PTR;
1020	SendReq.hIf = pThis->hIf;
1021	rc = PDMDrvHlpSUPCallVMMR0Ex(pThis->pDrvInsR3, VMMR0_DO_INTNET_IF_SEND, &SendReq, sizeof(SendReq));
1022	}
1023
1024	AssertRC(rc);
1025	return rc;
1026	}
1027
1028
1029	/**
1030	* Resume notification.
1031	*
1032	* @param pDrvIns The driver instance.
1033	*/
1034	static DECLCALLBACK(void) drvR3IntNetResume(PPDMDRVINS pDrvIns)
1035	{
1036	LogFlow(("drvR3IntNetPowerResume\n"));
1037	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
1038	VMRESUMEREASON enmReason = PDMDrvHlpVMGetResumeReason(pDrvIns);
1039
1040	if (!pThis->fActivateEarlyDeactivateLate)
1041	{
1042	ASMAtomicXchgSize(&pThis->enmRecvState, RECVSTATE_RUNNING);
1043	RTSemEventSignal(pThis->hRecvEvt);
1044	drvR3IntNetUpdateMacAddress(pThis); /* (could be a state restore) */
1045	drvR3IntNetSetActive(pThis, true /* fActive */);
1046	}
1047
1048	switch (enmReason)
1049	{
1050	case VMRESUMEREASON_HOST_RESUME:
1051	{
1052	uint32_t u32TrunkType;
1053	int rc = CFGMR3QueryU32(pDrvIns->pCfg, "TrunkType", &u32TrunkType);
1054	AssertRC(rc);
1055
1056	/*
1057	* Only do the disconnect for bridged networking. Host-only and
1058	* internal networks are not affected by a host resume.
1059	*/
1060	if ( RT_SUCCESS(rc)
1061	&& u32TrunkType == kIntNetTrunkType_NetFlt)
1062	{
1063	rc = pThis->pIAboveConfigR3->pfnSetLinkState(pThis->pIAboveConfigR3,
1064	PDMNETWORKLINKSTATE_DOWN_RESUME);
1065	AssertRC(rc);
1066	}
1067	break;
1068	}
1069	case VMRESUMEREASON_TELEPORTED:
1070	case VMRESUMEREASON_TELEPORT_FAILED:
1071	{
1072	if ( PDMDrvHlpVMTeleportedAndNotFullyResumedYet(pDrvIns)
1073	&& pThis->pIAboveConfigR3)
1074	{
1075	/*
1076	* We've just been teleported and need to drop a hint to the switch
1077	* since we're likely to have changed to a different port. We just
1078	* push out some ethernet frame that doesn't mean anything to anyone.
1079	* For this purpose ethertype 0x801e was chosen since it was registered
1080	* to Sun (dunno what it is/was used for though).
1081	*/
1082	union
1083	{
1084	RTNETETHERHDR Hdr;
1085	uint8_t ab[128];
1086	} Frame;
1087	RT_ZERO(Frame);
1088	Frame.Hdr.DstMac.au16[0] = 0xffff;
1089	Frame.Hdr.DstMac.au16[1] = 0xffff;
1090	Frame.Hdr.DstMac.au16[2] = 0xffff;
1091	Frame.Hdr.EtherType = RT_H2BE_U16_C(0x801e);
1092	int rc = pThis->pIAboveConfigR3->pfnGetMac(pThis->pIAboveConfigR3,
1093	&Frame.Hdr.SrcMac);
1094	if (RT_SUCCESS(rc))
1095	rc = drvR3IntNetResumeSend(pThis, &Frame, sizeof(Frame));
1096	if (RT_FAILURE(rc))
1097	LogRel(("IntNet#%u: Sending dummy frame failed: %Rrc\n",
1098	pDrvIns->iInstance, rc));
1099	}
1100	break;
1101	}
1102	default: /* ignore every other resume reason else */
1103	break;
1104	} /* end of switch(enmReason) */
1105	}
1106
1107
1108	/**
1109	* Suspend notification.
1110	*
1111	* @param pDrvIns The driver instance.
1112	*/
1113	static DECLCALLBACK(void) drvR3IntNetSuspend(PPDMDRVINS pDrvIns)
1114	{
1115	LogFlow(("drvR3IntNetPowerSuspend\n"));
1116	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
1117	if (!pThis->fActivateEarlyDeactivateLate)
1118	{
1119	ASMAtomicXchgSize(&pThis->enmRecvState, RECVSTATE_SUSPENDED);
1120	drvR3IntNetSetActive(pThis, false /* fActive */);
1121	}
1122	}
1123
1124
1125	/**
1126	* Power On notification.
1127	*
1128	* @param pDrvIns The driver instance.
1129	*/
1130	static DECLCALLBACK(void) drvR3IntNetPowerOn(PPDMDRVINS pDrvIns)
1131	{
1132	LogFlow(("drvR3IntNetPowerOn\n"));
1133	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
1134	if (!pThis->fActivateEarlyDeactivateLate)
1135	{
1136	ASMAtomicXchgSize(&pThis->enmRecvState, RECVSTATE_RUNNING);
1137	RTSemEventSignal(pThis->hRecvEvt);
1138	drvR3IntNetUpdateMacAddress(pThis);
1139	drvR3IntNetSetActive(pThis, true /* fActive */);
1140	}
1141	}
1142
1143
1144	/**
1145	* @interface_method_impl{PDMDRVREG,pfnRelocate}
1146	*/
1147	static DECLCALLBACK(void) drvR3IntNetRelocate(PPDMDRVINS pDrvIns, RTGCINTPTR offDelta)
1148	{
1149	/* nothing to do here yet */
1150	}
1151
1152
1153	/**
1154	* Destruct a driver instance.
1155	*
1156	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
1157	* resources can be freed correctly.
1158	*
1159	* @param pDrvIns The driver instance data.
1160	*/
1161	static DECLCALLBACK(void) drvR3IntNetDestruct(PPDMDRVINS pDrvIns)
1162	{
1163	LogFlow(("drvR3IntNetDestruct\n"));
1164	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
1165	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1166
1167	/*
1168	* Indicate to the receive thread that it's time to quit.
1169	*/
1170	ASMAtomicXchgSize(&pThis->enmRecvState, RECVSTATE_TERMINATE);
1171	ASMAtomicXchgSize(&pThis->fLinkDown, true);
1172	RTSEMEVENT hRecvEvt = pThis->hRecvEvt;
1173	pThis->hRecvEvt = NIL_RTSEMEVENT;
1174
1175	if (hRecvEvt != NIL_RTSEMEVENT)
1176	RTSemEventSignal(hRecvEvt);
1177
1178	if (pThis->hIf != INTNET_HANDLE_INVALID)
1179	{
1180	INTNETIFABORTWAITREQ AbortWaitReq;
1181	AbortWaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1182	AbortWaitReq.Hdr.cbReq = sizeof(AbortWaitReq);
1183	AbortWaitReq.pSession = NIL_RTR0PTR;
1184	AbortWaitReq.hIf = pThis->hIf;
1185	AbortWaitReq.fNoMoreWaits = true;
1186	int rc = PDMDrvHlpSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_ABORT_WAIT, &AbortWaitReq, sizeof(AbortWaitReq));
1187	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_SEM_DESTROYED, ("%Rrc\n", rc));
1188	}
1189
1190	/*
1191	* Wait for the threads to terminate.
1192	*/
1193	if (pThis->pXmitThread)
1194	{
1195	int rc = PDMR3ThreadDestroy(pThis->pXmitThread, NULL);
1196	AssertRC(rc);
1197	pThis->pXmitThread = NULL;
1198	}
1199
1200	if (pThis->hRecvThread != NIL_RTTHREAD)
1201	{
1202	int rc = RTThreadWait(pThis->hRecvThread, 5000, NULL);
1203	AssertRC(rc);
1204	pThis->hRecvThread = NIL_RTTHREAD;
1205	}
1206
1207	/*
1208	* Deregister statistics in case we're being detached.
1209	*/
1210	if (pThis->pBufR3)
1211	{
1212	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->Recv.cStatFrames);
1213	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->Recv.cbStatWritten);
1214	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->Recv.cOverflows);
1215	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->Send.cStatFrames);
1216	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->Send.cbStatWritten);
1217	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->Send.cOverflows);
1218	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->cStatYieldsOk);
1219	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->cStatYieldsNok);
1220	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->cStatLost);
1221	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->cStatBadFrames);
1222	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->StatSend1);
1223	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->StatSend2);
1224	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->StatRecv1);
1225	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->StatRecv2);
1226	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->pBufR3->StatReserved);
1227	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatReceivedGso);
1228	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatSentGso);
1229	#ifdef VBOX_WITH_STATISTICS
1230	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatReceive);
1231	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatTransmit);
1232	#endif
1233	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatXmitWakeupR0);
1234	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatXmitWakeupR3);
1235	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatXmitProcessRing);
1236	}
1237
1238	/*
1239	* Close the interface
1240	*/
1241	if (pThis->hIf != INTNET_HANDLE_INVALID)
1242	{
1243	INTNETIFCLOSEREQ CloseReq;
1244	CloseReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1245	CloseReq.Hdr.cbReq = sizeof(CloseReq);
1246	CloseReq.pSession = NIL_RTR0PTR;
1247	CloseReq.hIf = pThis->hIf;
1248	pThis->hIf = INTNET_HANDLE_INVALID;
1249	int rc = PDMDrvHlpSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_CLOSE, &CloseReq, sizeof(CloseReq));
1250	AssertRC(rc);
1251	}
1252
1253
1254	/*
1255	* Destroy the semaphores, S/G cache and xmit lock.
1256	*/
1257	if (hRecvEvt != NIL_RTSEMEVENT)
1258	RTSemEventDestroy(hRecvEvt);
1259
1260	if (pThis->hXmitEvt != NIL_SUPSEMEVENT)
1261	{
1262	SUPSemEventClose(pThis->pSupDrvSession, pThis->hXmitEvt);
1263	pThis->hXmitEvt = NIL_SUPSEMEVENT;
1264	}
1265
1266	RTMemCacheDestroy(pThis->hSgCache);
1267	pThis->hSgCache = NIL_RTMEMCACHE;
1268
1269	if (PDMCritSectIsInitialized(&pThis->XmitLock))
1270	PDMR3CritSectDelete(&pThis->XmitLock);
1271	}
1272
1273
1274	/**
1275	* Queries a policy config value and translates it into open network flag.
1276	*
1277	* @returns VBox status code (error set on failure).
1278	* @param pDrvIns The driver instance.
1279	* @param pszName The value name.
1280	* @param paFlags The open network flag descriptors.
1281	* @param cFlags The number of descriptors.
1282	* @param fFlags The fixed flag.
1283	* @param pfFlags The flags variable to update.
1284	*/
1285	static int drvIntNetR3CfgGetPolicy(PPDMDRVINS pDrvIns, const char *pszName, PCDRVINTNETFLAG paFlags, size_t cFlags,
1286	uint32_t fFixedFlag, uint32_t *pfFlags)
1287	{
1288	char szValue[64];
1289	int rc = CFGMR3QueryString(pDrvIns->pCfg, pszName, szValue, sizeof(szValue));
1290	if (RT_FAILURE(rc))
1291	{
1292	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1293	return VINF_SUCCESS;
1294	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1295	N_("Configuration error: Failed to query value of \"%s\""), pszName);
1296	}
1297
1298	/*
1299	* Check for +fixed first, so it can be stripped off.
1300	*/
1301	char *pszSep = strpbrk(szValue, "+,;");
1302	if (pszSep)
1303	{
1304	*pszSep++ = '\0';
1305	const char *pszFixed = RTStrStripL(pszSep);
1306	if (strcmp(pszFixed, "fixed"))
1307	{
1308	*pszSep = '+';
1309	return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
1310	N_("Configuration error: The value of \"%s\" is unknown: \"%s\""), pszName, szValue);
1311	}
1312	*pfFlags \|= fFixedFlag;
1313	RTStrStripR(szValue);
1314	}
1315
1316	/*
1317	* Match against the flag values.
1318	*/
1319	size_t i = cFlags;
1320	while (i-- > 0)
1321	if (!strcmp(paFlags[i].pszChoice, szValue))
1322	{
1323	*pfFlags \|= paFlags[i].fFlag;
1324	return VINF_SUCCESS;
1325	}
1326
1327	if (!strcmp(szValue, "none"))
1328	return VINF_SUCCESS;
1329
1330	if (!strcmp(szValue, "fixed"))
1331	{
1332	*pfFlags \|= fFixedFlag;
1333	return VINF_SUCCESS;
1334	}
1335
1336	return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
1337	N_("Configuration error: The value of \"%s\" is unknown: \"%s\""), pszName, szValue);
1338	}
1339
1340
1341	/**
1342	* Construct a TAP network transport driver instance.
1343	*
1344	* @copydoc FNPDMDRVCONSTRUCT
1345	*/
1346	static DECLCALLBACK(int) drvR3IntNetConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1347	{
1348	PDRVINTNET pThis = PDMINS_2_DATA(pDrvIns, PDRVINTNET);
1349	bool f;
1350	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1351
1352	/*
1353	* Init the static parts.
1354	*/
1355	pThis->pDrvInsR3 = pDrvIns;
1356	#ifdef VBOX_WITH_DRVINTNET_IN_R0
1357	pThis->pDrvInsR0 = PDMDRVINS_2_R0PTR(pDrvIns);
1358	#endif
1359	pThis->hIf = INTNET_HANDLE_INVALID;
1360	pThis->hRecvThread = NIL_RTTHREAD;
1361	pThis->hRecvEvt = NIL_RTSEMEVENT;
1362	pThis->pXmitThread = NULL;
1363	pThis->hXmitEvt = NIL_SUPSEMEVENT;
1364	pThis->pSupDrvSession = PDMDrvHlpGetSupDrvSession(pDrvIns);
1365	pThis->hSgCache = NIL_RTMEMCACHE;
1366	pThis->enmRecvState = RECVSTATE_SUSPENDED;
1367	pThis->fActivateEarlyDeactivateLate = false;
1368	/* IBase* */
1369	pDrvIns->IBase.pfnQueryInterface = drvR3IntNetIBase_QueryInterface;
1370	pThis->IBaseR0.pfnQueryInterface = drvR3IntNetIBaseR0_QueryInterface;
1371	pThis->IBaseRC.pfnQueryInterface = drvR3IntNetIBaseRC_QueryInterface;
1372	/* INetworkUp */
1373	pThis->INetworkUpR3.pfnBeginXmit = drvIntNetUp_BeginXmit;
1374	pThis->INetworkUpR3.pfnAllocBuf = drvIntNetUp_AllocBuf;
1375	pThis->INetworkUpR3.pfnFreeBuf = drvIntNetUp_FreeBuf;
1376	pThis->INetworkUpR3.pfnSendBuf = drvIntNetUp_SendBuf;
1377	pThis->INetworkUpR3.pfnEndXmit = drvIntNetUp_EndXmit;
1378	pThis->INetworkUpR3.pfnSetPromiscuousMode = drvIntNetUp_SetPromiscuousMode;
1379	pThis->INetworkUpR3.pfnNotifyLinkChanged = drvR3IntNetUp_NotifyLinkChanged;
1380
1381	/*
1382	* Validate the config.
1383	*/
1384	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns,
1385	"Network"
1386	"\|Trunk"
1387	"\|TrunkType"
1388	"\|ReceiveBufferSize"
1389	"\|SendBufferSize"
1390	"\|SharedMacOnWire"
1391	"\|RestrictAccess"
1392	"\|RequireExactPolicyMatch"
1393	"\|RequireAsRestrictivePolicy"
1394	"\|AccessPolicy"
1395	"\|PromiscPolicyClients"
1396	"\|PromiscPolicyHost"
1397	"\|PromiscPolicyWire"
1398	"\|IfPolicyPromisc"
1399	"\|TrunkPolicyHost"
1400	"\|TrunkPolicyWire"
1401	"\|IsService"
1402	"\|IgnoreConnectFailure"
1403	"\|Workaround1",
1404	"");
1405
1406	/*
1407	* Check that no-one is attached to us.
1408	*/
1409	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
1410	("Configuration error: Not possible to attach anything to this driver!\n"),
1411	VERR_PDM_DRVINS_NO_ATTACH);
1412
1413	/*
1414	* Query the network port interface.
1415	*/
1416	pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
1417	if (!pThis->pIAboveNet)
1418	{
1419	AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
1420	return VERR_PDM_MISSING_INTERFACE_ABOVE;
1421	}
1422	pThis->pIAboveConfigR3 = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
1423
1424	/*
1425	* Read the configuration.
1426	*/
1427	INTNETOPENREQ OpenReq;
1428	RT_ZERO(OpenReq);
1429	OpenReq.Hdr.cbReq = sizeof(OpenReq);
1430	OpenReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1431	OpenReq.pSession = NIL_RTR0PTR;
1432
1433	/** @cfgm{Network, string}
1434	* The name of the internal network to connect to.
1435	*/
1436	int rc = CFGMR3QueryString(pCfg, "Network", OpenReq.szNetwork, sizeof(OpenReq.szNetwork));
1437	if (RT_FAILURE(rc))
1438	return PDMDRV_SET_ERROR(pDrvIns, rc,
1439	N_("Configuration error: Failed to get the \"Network\" value"));
1440	strcpy(pThis->szNetwork, OpenReq.szNetwork);
1441
1442	/** @cfgm{TrunkType, uint32_t, kIntNetTrunkType_None}
1443	* The trunk connection type see INTNETTRUNKTYPE.
1444	*/
1445	uint32_t u32TrunkType;
1446	rc = CFGMR3QueryU32(pCfg, "TrunkType", &u32TrunkType);
1447	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1448	u32TrunkType = kIntNetTrunkType_None;
1449	else if (RT_FAILURE(rc))
1450	return PDMDRV_SET_ERROR(pDrvIns, rc,
1451	N_("Configuration error: Failed to get the \"TrunkType\" value"));
1452	OpenReq.enmTrunkType = (INTNETTRUNKTYPE)u32TrunkType;
1453
1454	/** @cfgm{Trunk, string, ""}
1455	* The name of the trunk connection.
1456	*/
1457	rc = CFGMR3QueryString(pCfg, "Trunk", OpenReq.szTrunk, sizeof(OpenReq.szTrunk));
1458	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1459	OpenReq.szTrunk[0] = '\0';
1460	else if (RT_FAILURE(rc))
1461	return PDMDRV_SET_ERROR(pDrvIns, rc,
1462	N_("Configuration error: Failed to get the \"Trunk\" value"));
1463
1464	OpenReq.fFlags = 0;
1465
1466	/** @cfgm{SharedMacOnWire, boolean, false}
1467	* Whether to shared the MAC address of the host interface when using the wire. When
1468	* attaching to a wireless NIC this option is usually a requirement.
1469	*/
1470	bool fSharedMacOnWire;
1471	rc = CFGMR3QueryBoolDef(pCfg, "SharedMacOnWire", &fSharedMacOnWire, false);
1472	if (RT_FAILURE(rc))
1473	return PDMDRV_SET_ERROR(pDrvIns, rc,
1474	N_("Configuration error: Failed to get the \"SharedMacOnWire\" value"));
1475	if (fSharedMacOnWire)
1476	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE;
1477
1478	/** @cfgm{RestrictAccess, boolean, true}
1479	* Whether to restrict the access to the network or if it should be public.
1480	* Everyone on the computer can connect to a public network.
1481	* @deprecated Use AccessPolicy instead.
1482	*/
1483	rc = CFGMR3QueryBool(pCfg, "RestrictAccess", &f);
1484	if (RT_SUCCESS(rc))
1485	{
1486	if (f)
1487	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_ACCESS_RESTRICTED;
1488	else
1489	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_ACCESS_PUBLIC;
1490	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_ACCESS_FIXED;
1491	}
1492	else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
1493	return PDMDRV_SET_ERROR(pDrvIns, rc,
1494	N_("Configuration error: Failed to get the \"RestrictAccess\" value"));
1495
1496	/** @cfgm{RequireExactPolicyMatch, boolean, false}
1497	* Whether to require that the current security and promiscuous policies of
1498	* the network is exactly as the ones specified in this open network
1499	* request. Use this with RequireAsRestrictivePolicy to prevent
1500	* restrictions from being lifted. If no further policy changes are
1501	* desired, apply the relevant fixed flags. */
1502	rc = CFGMR3QueryBoolDef(pCfg, "RequireExactPolicyMatch", &f, false);
1503	if (RT_FAILURE(rc))
1504	return PDMDRV_SET_ERROR(pDrvIns, rc,
1505	N_("Configuration error: Failed to get the \"RequireExactPolicyMatch\" value"));
1506	if (f)
1507	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_REQUIRE_EXACT;
1508
1509	/** @cfgm{RequireAsRestrictivePolicy, boolean, false}
1510	* Whether to require that the security and promiscuous policies of the
1511	* network is at least as restrictive as specified this request specifies
1512	* and prevent them being lifted later on.
1513	*/
1514	rc = CFGMR3QueryBoolDef(pCfg, "RequireAsRestrictivePolicy", &f, false);
1515	if (RT_FAILURE(rc))
1516	return PDMDRV_SET_ERROR(pDrvIns, rc,
1517	N_("Configuration error: Failed to get the \"RequireAsRestrictivePolicy\" value"));
1518	if (f)
1519	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_REQUIRE_AS_RESTRICTIVE_POLICIES;
1520
1521	/** @cfgm{AccessPolicy, string, "none"}
1522	* The access policy of the network:
1523	* public, public+fixed, restricted, restricted+fixed, none or fixed.
1524	*
1525	* A "public" network is accessible to everyone on the same host, while a
1526	* "restricted" one is only accessible to VMs & services started by the
1527	* same user. The "none" policy, which is the default, means no policy
1528	* change or choice is made and that the current (existing network) or
1529	* default (new) policy should be used. */
1530	static const DRVINTNETFLAG s_aAccessPolicyFlags[] =
1531	{
1532	{ "public", INTNET_OPEN_FLAGS_ACCESS_PUBLIC },
1533	{ "restricted", INTNET_OPEN_FLAGS_ACCESS_RESTRICTED }
1534	};
1535	rc = drvIntNetR3CfgGetPolicy(pDrvIns, "AccessPolicy", &s_aAccessPolicyFlags[0], RT_ELEMENTS(s_aAccessPolicyFlags),
1536	INTNET_OPEN_FLAGS_ACCESS_FIXED, &OpenReq.fFlags);
1537	AssertRCReturn(rc, rc);
1538
1539	/** @cfgm{PromiscPolicyClients, string, "none"}
1540	* The network wide promiscuous mode policy for client (non-trunk)
1541	* interfaces: allow, allow+fixed, deny, deny+fixed, none or fixed. */
1542	static const DRVINTNETFLAG s_aPromiscPolicyClient[] =
1543	{
1544	{ "allow", INTNET_OPEN_FLAGS_PROMISC_ALLOW_CLIENTS },
1545	{ "deny", INTNET_OPEN_FLAGS_PROMISC_DENY_CLIENTS }
1546	};
1547	rc = drvIntNetR3CfgGetPolicy(pDrvIns, "PromiscPolicyClients", &s_aPromiscPolicyClient[0], RT_ELEMENTS(s_aPromiscPolicyClient),
1548	INTNET_OPEN_FLAGS_PROMISC_FIXED, &OpenReq.fFlags);
1549	AssertRCReturn(rc, rc);
1550	/** @cfgm{PromiscPolicyHost, string, "none"}
1551	* The promiscuous mode policy for the trunk-host
1552	* connection: allow, allow+fixed, deny, deny+fixed, none or fixed. */
1553	static const DRVINTNETFLAG s_aPromiscPolicyHost[] =
1554	{
1555	{ "allow", INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_HOST },
1556	{ "deny", INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_HOST }
1557	};
1558	rc = drvIntNetR3CfgGetPolicy(pDrvIns, "PromiscPolicyHost", &s_aPromiscPolicyHost[0], RT_ELEMENTS(s_aPromiscPolicyHost),
1559	INTNET_OPEN_FLAGS_PROMISC_FIXED, &OpenReq.fFlags);
1560	AssertRCReturn(rc, rc);
1561	/** @cfgm{PromiscPolicyWire, string, "none"}
1562	* The promiscuous mode policy for the trunk-host
1563	* connection: allow, allow+fixed, deny, deny+fixed, none or fixed. */
1564	static const DRVINTNETFLAG s_aPromiscPolicyWire[] =
1565	{
1566	{ "allow", INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_WIRE },
1567	{ "deny", INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_WIRE }
1568	};
1569	rc = drvIntNetR3CfgGetPolicy(pDrvIns, "PromiscPolicyWire", &s_aPromiscPolicyWire[0], RT_ELEMENTS(s_aPromiscPolicyWire),
1570	INTNET_OPEN_FLAGS_PROMISC_FIXED, &OpenReq.fFlags);
1571	AssertRCReturn(rc, rc);
1572
1573
1574	/** @cfgm{IfPolicyPromisc, string, "none"}
1575	* The promiscuous mode policy for this
1576	* interface: deny, deny+fixed, allow-all, allow-all+fixed, allow-network,
1577	* allow-network+fixed, none or fixed. */
1578	static const DRVINTNETFLAG s_aIfPolicyPromisc[] =
1579	{
1580	{ "allow-all", INTNET_OPEN_FLAGS_IF_PROMISC_ALLOW \| INTNET_OPEN_FLAGS_IF_PROMISC_SEE_TRUNK },
1581	{ "allow-network", INTNET_OPEN_FLAGS_IF_PROMISC_ALLOW \| INTNET_OPEN_FLAGS_IF_PROMISC_NO_TRUNK },
1582	{ "deny", INTNET_OPEN_FLAGS_IF_PROMISC_DENY }
1583	};
1584	rc = drvIntNetR3CfgGetPolicy(pDrvIns, "IfPolicyPromisc", &s_aIfPolicyPromisc[0], RT_ELEMENTS(s_aIfPolicyPromisc),
1585	INTNET_OPEN_FLAGS_IF_FIXED, &OpenReq.fFlags);
1586	AssertRCReturn(rc, rc);
1587
1588
1589	/** @cfgm{TrunkPolicyHost, string, "none"}
1590	* The trunk-host policy: promisc, promisc+fixed, enabled, enabled+fixed,
1591	* disabled, disabled+fixed, none or fixed
1592	*
1593	* This can be used to prevent packages to be routed to the host. */
1594	static const DRVINTNETFLAG s_aTrunkPolicyHost[] =
1595	{
1596	{ "promisc", INTNET_OPEN_FLAGS_TRUNK_HOST_ENABLED \| INTNET_OPEN_FLAGS_TRUNK_HOST_PROMISC_MODE },
1597	{ "enabled", INTNET_OPEN_FLAGS_TRUNK_HOST_ENABLED },
1598	{ "disabled", INTNET_OPEN_FLAGS_TRUNK_HOST_DISABLED }
1599	};
1600	rc = drvIntNetR3CfgGetPolicy(pDrvIns, "TrunkPolicyHost", &s_aTrunkPolicyHost[0], RT_ELEMENTS(s_aTrunkPolicyHost),
1601	INTNET_OPEN_FLAGS_TRUNK_FIXED, &OpenReq.fFlags);
1602	AssertRCReturn(rc, rc);
1603	/** @cfgm{TrunkPolicyWire, string, "none"}
1604	* The trunk-host policy: promisc, promisc+fixed, enabled, enabled+fixed,
1605	* disabled, disabled+fixed, none or fixed.
1606	*
1607	* This can be used to prevent packages to be routed to the wire. */
1608	static const DRVINTNETFLAG s_aTrunkPolicyWire[] =
1609	{
1610	{ "promisc", INTNET_OPEN_FLAGS_TRUNK_WIRE_ENABLED \| INTNET_OPEN_FLAGS_TRUNK_WIRE_PROMISC_MODE },
1611	{ "enabled", INTNET_OPEN_FLAGS_TRUNK_WIRE_ENABLED },
1612	{ "disabled", INTNET_OPEN_FLAGS_TRUNK_WIRE_DISABLED }
1613	};
1614	rc = drvIntNetR3CfgGetPolicy(pDrvIns, "TrunkPolicyWire", &s_aTrunkPolicyWire[0], RT_ELEMENTS(s_aTrunkPolicyWire),
1615	INTNET_OPEN_FLAGS_TRUNK_FIXED, &OpenReq.fFlags);
1616	AssertRCReturn(rc, rc);
1617
1618
1619	/** @cfgm{ReceiveBufferSize, uint32_t, 318 KB}
1620	* The size of the receive buffer.
1621	*/
1622	rc = CFGMR3QueryU32(pCfg, "ReceiveBufferSize", &OpenReq.cbRecv);
1623	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1624	OpenReq.cbRecv = 318 * _1K ;
1625	else if (RT_FAILURE(rc))
1626	return PDMDRV_SET_ERROR(pDrvIns, rc,
1627	N_("Configuration error: Failed to get the \"ReceiveBufferSize\" value"));
1628
1629	/** @cfgm{SendBufferSize, uint32_t, 196 KB}
1630	* The size of the send (transmit) buffer.
1631	* This should be more than twice the size of the larges frame size because
1632	* the ring buffer is very simple and doesn't support splitting up frames
1633	* nor inserting padding. So, if this is too close to the frame size the
1634	* header will fragment the buffer such that the frame won't fit on either
1635	* side of it and the code will get very upset about it all.
1636	*/
1637	rc = CFGMR3QueryU32(pCfg, "SendBufferSize", &OpenReq.cbSend);
1638	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1639	OpenReq.cbSend = RT_ALIGN_Z(VBOX_MAX_GSO_SIZE * 3, _1K);
1640	else if (RT_FAILURE(rc))
1641	return PDMDRV_SET_ERROR(pDrvIns, rc,
1642	N_("Configuration error: Failed to get the \"SendBufferSize\" value"));
1643	if (OpenReq.cbSend < 128)
1644	return PDMDRV_SET_ERROR(pDrvIns, rc,
1645	N_("Configuration error: The \"SendBufferSize\" value is too small"));
1646	if (OpenReq.cbSend < VBOX_MAX_GSO_SIZE * 3)
1647	LogRel(("DrvIntNet: Warning! SendBufferSize=%u, Recommended minimum size %u butes.\n", OpenReq.cbSend, VBOX_MAX_GSO_SIZE * 4));
1648
1649	/** @cfgm{IsService, boolean, true}
1650	* This alterns the way the thread is suspended and resumed. When it's being used by
1651	* a service such as LWIP/iSCSI it shouldn't suspend immediately like for a NIC.
1652	*/
1653	rc = CFGMR3QueryBool(pCfg, "IsService", &pThis->fActivateEarlyDeactivateLate);
1654	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1655	pThis->fActivateEarlyDeactivateLate = false;
1656	else if (RT_FAILURE(rc))
1657	return PDMDRV_SET_ERROR(pDrvIns, rc,
1658	N_("Configuration error: Failed to get the \"IsService\" value"));
1659
1660
1661	/** @cfgm{IgnoreConnectFailure, boolean, false}
1662	* When set only raise a runtime error if we cannot connect to the internal
1663	* network. */
1664	bool fIgnoreConnectFailure;
1665	rc = CFGMR3QueryBoolDef(pCfg, "IgnoreConnectFailure", &fIgnoreConnectFailure, false);
1666	if (RT_FAILURE(rc))
1667	return PDMDRV_SET_ERROR(pDrvIns, rc,
1668	N_("Configuration error: Failed to get the \"IgnoreConnectFailure\" value"));
1669
1670	/** @cfgm{Workaround1, boolean, depends}
1671	* Enables host specific workarounds, the default is depends on the whether
1672	* we think the host requires it or not.
1673	*/
1674	bool fWorkaround1 = false;
1675	#ifdef RT_OS_DARWIN
1676	if (OpenReq.fFlags & INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE)
1677	{
1678	char szKrnlVer[256];
1679	RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szKrnlVer, sizeof(szKrnlVer));
1680	if (strcmp(szKrnlVer, "10.7.0") >= 0)
1681	{
1682	LogRel(("IntNet#%u: Enables the workaround (ip_tos=0) for the little endian ip header checksum problem\n"));
1683	fWorkaround1 = true;
1684	}
1685	}
1686	#endif
1687	rc = CFGMR3QueryBoolDef(pCfg, "Workaround1", &fWorkaround1, fWorkaround1);
1688	if (RT_FAILURE(rc))
1689	return PDMDRV_SET_ERROR(pDrvIns, rc,
1690	N_("Configuration error: Failed to get the \"Workaround1\" value"));
1691	if (fWorkaround1)
1692	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_WORKAROUND_1;
1693
1694	LogRel(("IntNet#%u: szNetwork={%s} enmTrunkType=%d szTrunk={%s} fFlags=%#x cbRecv=%u cbSend=%u fIgnoreConnectFailure=%RTbool\n",
1695	pDrvIns->iInstance, OpenReq.szNetwork, OpenReq.enmTrunkType, OpenReq.szTrunk, OpenReq.fFlags,
1696	OpenReq.cbRecv, OpenReq.cbSend, fIgnoreConnectFailure));
1697
1698	#ifdef RT_OS_DARWIN
1699	/* Temporary hack: attach to a network with the name 'if=en0' and you're hitting the wire. */
1700	if ( !OpenReq.szTrunk[0]
1701	&& OpenReq.enmTrunkType == kIntNetTrunkType_None
1702	&& !strncmp(pThis->szNetwork, RT_STR_TUPLE("if=en"))
1703	&& RT_C_IS_DIGIT(pThis->szNetwork[sizeof("if=en") - 1])
1704	&& !pThis->szNetwork[sizeof("if=en")])
1705	{
1706	OpenReq.enmTrunkType = kIntNetTrunkType_NetFlt;
1707	strcpy(OpenReq.szTrunk, &pThis->szNetwork[sizeof("if=") - 1]);
1708	}
1709	/* Temporary hack: attach to a network with the name 'wif=en0' and you're on the air. */
1710	if ( !OpenReq.szTrunk[0]
1711	&& OpenReq.enmTrunkType == kIntNetTrunkType_None
1712	&& !strncmp(pThis->szNetwork, RT_STR_TUPLE("wif=en"))
1713	&& RT_C_IS_DIGIT(pThis->szNetwork[sizeof("wif=en") - 1])
1714	&& !pThis->szNetwork[sizeof("wif=en")])
1715	{
1716	OpenReq.enmTrunkType = kIntNetTrunkType_NetFlt;
1717	OpenReq.fFlags \|= INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE;
1718	strcpy(OpenReq.szTrunk, &pThis->szNetwork[sizeof("wif=") - 1]);
1719	}
1720	#endif /* DARWIN */
1721
1722	/*
1723	* Create the event semaphore, S/G cache and xmit critsect.
1724	*/
1725	rc = RTSemEventCreate(&pThis->hRecvEvt);
1726	if (RT_FAILURE(rc))
1727	return rc;
1728	rc = RTMemCacheCreate(&pThis->hSgCache, sizeof(PDMSCATTERGATHER), 0, UINT32_MAX, NULL, NULL, pThis, 0);
1729	if (RT_FAILURE(rc))
1730	return rc;
1731	rc = PDMDrvHlpCritSectInit(pDrvIns, &pThis->XmitLock, RT_SRC_POS, "IntNetXmit");
1732	if (RT_FAILURE(rc))
1733	return rc;
1734
1735	/*
1736	* Create the interface.
1737	*/
1738	OpenReq.hIf = INTNET_HANDLE_INVALID;
1739	rc = PDMDrvHlpSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_OPEN, &OpenReq, sizeof(OpenReq));
1740	if (RT_FAILURE(rc))
1741	{
1742	if (fIgnoreConnectFailure)
1743	{
1744	/*
1745	* During VM restore it is fatal if the network is not available because the
1746	* VM settings are locked and the user has no chance to fix network settings.
1747	* Therefore don't abort but just raise a runtime warning.
1748	*/
1749	PDMDrvHlpVMSetRuntimeError(pDrvIns, 0 /fFlags/, "HostIfNotConnecting",
1750	N_ ("Cannot connect to the network interface '%s'. The virtual "
1751	"network card will appear to work but the guest will not "
1752	"be able to connect. Please choose a different network in the "
1753	"network settings"), OpenReq.szTrunk);
1754
1755	return VERR_PDM_NO_ATTACHED_DRIVER;
1756	}
1757	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1758	N_("Failed to open/create the internal network '%s'"), pThis->szNetwork);
1759	}
1760
1761	AssertRelease(OpenReq.hIf != INTNET_HANDLE_INVALID);
1762	pThis->hIf = OpenReq.hIf;
1763	Log(("IntNet%d: hIf=%RX32 '%s'\n", pDrvIns->iInstance, pThis->hIf, pThis->szNetwork));
1764
1765	/*
1766	* Get default buffer.
1767	*/
1768	INTNETIFGETBUFFERPTRSREQ GetBufferPtrsReq;
1769	GetBufferPtrsReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1770	GetBufferPtrsReq.Hdr.cbReq = sizeof(GetBufferPtrsReq);
1771	GetBufferPtrsReq.pSession = NIL_RTR0PTR;
1772	GetBufferPtrsReq.hIf = pThis->hIf;
1773	GetBufferPtrsReq.pRing3Buf = NULL;
1774	GetBufferPtrsReq.pRing0Buf = NIL_RTR0PTR;
1775	rc = PDMDrvHlpSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS, &GetBufferPtrsReq, sizeof(GetBufferPtrsReq));
1776	if (RT_FAILURE(rc))
1777	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1778	N_("Failed to get ring-3 buffer for the newly created interface to '%s'"), pThis->szNetwork);
1779	AssertRelease(VALID_PTR(GetBufferPtrsReq.pRing3Buf));
1780	pThis->pBufR3 = GetBufferPtrsReq.pRing3Buf;
1781	pThis->pBufR0 = GetBufferPtrsReq.pRing0Buf;
1782
1783	/*
1784	* Register statistics.
1785	*/
1786	PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->pBufR3->Recv.cbStatWritten, "Bytes/Received", STAMUNIT_BYTES, "Number of received bytes.");
1787	PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->pBufR3->Send.cbStatWritten, "Bytes/Sent", STAMUNIT_BYTES, "Number of sent bytes.");
1788	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->Recv.cOverflows, "Overflows/Recv", "Number overflows.");
1789	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->Send.cOverflows, "Overflows/Sent", "Number overflows.");
1790	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->Recv.cStatFrames, "Packets/Received", "Number of received packets.");
1791	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->Send.cStatFrames, "Packets/Sent", "Number of sent packets.");
1792	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatReceivedGso, "Packets/Received-Gso", "The GSO portion of the received packets.");
1793	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatSentGso, "Packets/Sent-Gso", "The GSO portion of the sent packets.");
1794	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatSentR0, "Packets/Sent-R0", "The ring-0 portion of the sent packets.");
1795
1796	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->cStatLost, "Packets/Lost", "Number of lost packets.");
1797	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->cStatYieldsNok, "YieldOk", "Number of times yielding helped fix an overflow.");
1798	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->cStatYieldsOk, "YieldNok", "Number of times yielding didn't help fix an overflow.");
1799	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->pBufR3->cStatBadFrames, "BadFrames", "Number of bad frames seed by the consumers.");
1800	PDMDrvHlpSTAMRegProfile(pDrvIns, &pThis->pBufR3->StatSend1, "Send1", "Profiling IntNetR0IfSend.");
1801	PDMDrvHlpSTAMRegProfile(pDrvIns, &pThis->pBufR3->StatSend2, "Send2", "Profiling sending to the trunk.");
1802	PDMDrvHlpSTAMRegProfile(pDrvIns, &pThis->pBufR3->StatRecv1, "Recv1", "Reserved for future receive profiling.");
1803	PDMDrvHlpSTAMRegProfile(pDrvIns, &pThis->pBufR3->StatRecv2, "Recv2", "Reserved for future receive profiling.");
1804	PDMDrvHlpSTAMRegProfile(pDrvIns, &pThis->pBufR3->StatReserved, "Reserved", "Reserved for future use.");
1805	#ifdef VBOX_WITH_STATISTICS
1806	PDMDrvHlpSTAMRegProfileAdv(pDrvIns, &pThis->StatReceive, "Receive", "Profiling packet receive runs.");
1807	PDMDrvHlpSTAMRegProfile(pDrvIns, &pThis->StatTransmit, "Transmit", "Profiling packet transmit runs.");
1808	#endif
1809	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitWakeupR0, "XmitWakeup-R0", "Xmit thread wakeups from ring-0.");
1810	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitWakeupR3, "XmitWakeup-R3", "Xmit thread wakeups from ring-3.");
1811	PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitProcessRing, "XmitProcessRing", "Time xmit thread was told to process the ring.");
1812
1813	/*
1814	* Create the async I/O threads.
1815	* Note! Using a PDM thread here doesn't fit with the IsService=true operation.
1816	*/
1817	rc = RTThreadCreate(&pThis->hRecvThread, drvR3IntNetRecvThread, pThis, 0,
1818	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "INTNET-RECV");
1819	if (RT_FAILURE(rc))
1820	{
1821	AssertRC(rc);
1822	return rc;
1823	}
1824
1825	rc = SUPSemEventCreate(pThis->pSupDrvSession, &pThis->hXmitEvt);
1826	AssertRCReturn(rc, rc);
1827
1828	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pXmitThread, pThis,
1829	drvR3IntNetXmitThread, drvR3IntNetXmitWakeUp, 0, RTTHREADTYPE_IO, "INTNET-XMIT");
1830	AssertRCReturn(rc, rc);
1831
1832	#ifdef VBOX_WITH_DRVINTNET_IN_R0
1833	/*
1834	* Resolve the ring-0 context interface addresses.
1835	*/
1836	rc = pDrvIns->pHlpR3->pfnLdrGetR0InterfaceSymbols(pDrvIns, &pThis->INetworkUpR0, sizeof(pThis->INetworkUpR0),
1837	"drvIntNetUp_", PDMINETWORKUP_SYM_LIST);
1838	AssertLogRelRCReturn(rc, rc);
1839	#endif
1840
1841	/*
1842	* Activate data transmission as early as possible
1843	*/
1844	if (pThis->fActivateEarlyDeactivateLate)
1845	{
1846	ASMAtomicXchgSize(&pThis->enmRecvState, RECVSTATE_RUNNING);
1847	RTSemEventSignal(pThis->hRecvEvt);
1848
1849	drvR3IntNetUpdateMacAddress(pThis);
1850	drvR3IntNetSetActive(pThis, true /* fActive */);
1851	}
1852
1853	return rc;
1854	}
1855
1856
1857
1858	/**
1859	* Internal networking transport driver registration record.
1860	*/
1861	const PDMDRVREG g_DrvIntNet =
1862	{
1863	/* u32Version */
1864	PDM_DRVREG_VERSION,
1865	/* szName */
1866	"IntNet",
1867	/* szRCMod */
1868	"VBoxDDRC.rc",
1869	/* szR0Mod */
1870	"VBoxDDR0.r0",
1871	/* pszDescription */
1872	"Internal Networking Transport Driver",
1873	/* fFlags */
1874	#ifdef VBOX_WITH_DRVINTNET_IN_R0
1875	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DRVREG_FLAGS_R0,
1876	#else
1877	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1878	#endif
1879	/* fClass. */
1880	PDM_DRVREG_CLASS_NETWORK,
1881	/* cMaxInstances */
1882	~0U,
1883	/* cbInstance */
1884	sizeof(DRVINTNET),
1885	/* pfnConstruct */
1886	drvR3IntNetConstruct,
1887	/* pfnDestruct */
1888	drvR3IntNetDestruct,
1889	/* pfnRelocate */
1890	drvR3IntNetRelocate,
1891	/* pfnIOCtl */
1892	NULL,
1893	/* pfnPowerOn */
1894	drvR3IntNetPowerOn,
1895	/* pfnReset */
1896	NULL,
1897	/* pfnSuspend */
1898	drvR3IntNetSuspend,
1899	/* pfnResume */
1900	drvR3IntNetResume,
1901	/* pfnAttach */
1902	NULL,
1903	/* pfnDetach */
1904	NULL,
1905	/* pfnPowerOff */
1906	drvR3IntNetPowerOff,
1907	/* pfnSoftReset */
1908	NULL,
1909	/* u32EndVersion */
1910	PDM_DRVREG_VERSION
1911	};
1912
1913	#endif /* IN_RING3 */
1914

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

source: vbox/trunk/src/VBox/Devices/Network/DrvIntNet.cpp@ 61541

Download in other formats: