DrvIntNet.cpp@ 66058

Last change on this file since 66058 was 65919, checked in by vboxsync, 8 years ago
gcc 7: fall thru
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 74.2 KB

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

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

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

Download in other formats: