VBoxNetFlt-linux.c@ 28703

Last change on this file since 28703 was 28703, checked in by vboxsync, 15 years ago
VBoxNetFlt/linux: Added VBOXNETFLT_LINUX_NO_XMIT_QUEUE since we can call pfnRecv at interrupt / atomic time now.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 61.3 KB

Line
1	/* $Id: VBoxNetFlt-linux.c 28703 2010-04-25 00:37:30Z vboxsync $ */
2	/** @file
3	* VBoxNetFlt - Network Filter Driver (Host), Linux Specific Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2008 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
26	#define VBOXNETFLT_LINUX_NO_XMIT_QUEUE
27	#include "the-linux-kernel.h"
28	#include "version-generated.h"
29	#include "product-generated.h"
30	#include <linux/netdevice.h>
31	#include <linux/etherdevice.h>
32	#include <linux/rtnetlink.h>
33	#include <linux/miscdevice.h>
34	#include <linux/ip.h>
35
36	#include <VBox/log.h>
37	#include <VBox/err.h>
38	#include <VBox/intnetinline.h>
39	#include <VBox/pdmnetinline.h>
40	#include <VBox/param.h>
41	#include <iprt/alloca.h>
42	#include <iprt/assert.h>
43	#include <iprt/spinlock.h>
44	#include <iprt/semaphore.h>
45	#include <iprt/initterm.h>
46	#include <iprt/process.h>
47	#include <iprt/mem.h>
48	#include <iprt/net.h>
49	#include <iprt/log.h>
50	#include <iprt/mp.h>
51	#include <iprt/mem.h>
52	#include <iprt/time.h>
53
54	#define VBOXNETFLT_OS_SPECFIC 1
55	#include "../VBoxNetFltInternal.h"
56
57
58	/*******************************************************************************
59	* Defined Constants And Macros *
60	*******************************************************************************/
61	#define VBOX_FLT_NB_TO_INST(pNB) RT_FROM_MEMBER(pNB, VBOXNETFLTINS, u.s.Notifier)
62	#define VBOX_FLT_PT_TO_INST(pPT) RT_FROM_MEMBER(pPT, VBOXNETFLTINS, u.s.PacketType)
63	#ifndef VBOXNETFLT_LINUX_NO_XMIT_QUEUE
64	# define VBOX_FLT_XT_TO_INST(pXT) RT_FROM_MEMBER(pXT, VBOXNETFLTINS, u.s.XmitTask)
65	#endif
66
67	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
68	# define VBOX_SKB_RESET_NETWORK_HDR(skb) skb_reset_network_header(skb)
69	# define VBOX_SKB_RESET_MAC_HDR(skb) skb_reset_mac_header(skb)
70	#else
71	# define VBOX_SKB_RESET_NETWORK_HDR(skb) skb->nh.raw = skb->data
72	# define VBOX_SKB_RESET_MAC_HDR(skb) skb->mac.raw = skb->data
73	#endif
74
75	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
76	# define VBOX_SKB_CHECKSUM_HELP(skb) skb_checksum_help(skb)
77	#else
78	# define CHECKSUM_PARTIAL CHECKSUM_HW
79	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 10)
80	# define VBOX_SKB_CHECKSUM_HELP(skb) skb_checksum_help(skb, 0)
81	# else
82	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 7)
83	# define VBOX_SKB_CHECKSUM_HELP(skb) skb_checksum_help(&skb, 0)
84	# else
85	# define VBOX_SKB_CHECKSUM_HELP(skb) (!skb_checksum_help(skb))
86	# endif
87	# endif
88	#endif
89
90	#ifndef NET_IP_ALIGN
91	# define NET_IP_ALIGN 2
92	#endif
93
94	#if 0
95	/** Create scatter / gather segments for fragments. When not used, we will
96	* linearize the socket buffer before creating the internal networking SG. */
97	# define VBOXNETFLT_SG_SUPPORT 1
98	#endif
99
100	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
101	/** Indicates that the linux kernel may send us GSO frames. */
102	# define VBOXNETFLT_WITH_GSO 1
103
104	/** This enables or disables the transmitting of GSO frame from the internal
105	* network and to the host. */
106	# define VBOXNETFLT_WITH_GSO_XMIT_HOST 1
107
108	# if 0 /** @todo This is currently disable because it causes performance loss of 5-10%. */
109	/** This enables or disables the transmitting of GSO frame from the internal
110	* network and to the wire. */
111	# define VBOXNETFLT_WITH_GSO_XMIT_WIRE 1
112	# endif
113
114	/** This enables or disables the forwarding/flooding of GSO frame from the host
115	* to the internal network. */
116	# define VBOXNETFLT_WITH_GSO_RECV 1
117
118	#endif
119
120
121	/*******************************************************************************
122	* Internal Functions *
123	*******************************************************************************/
124	static int VBoxNetFltLinuxInit(void);
125	static void VBoxNetFltLinuxUnload(void);
126	static void vboxNetFltLinuxForwardToIntNet(PVBOXNETFLTINS pThis, struct sk_buff *pBuf);
127
128
129	/*******************************************************************************
130	* Global Variables *
131	*******************************************************************************/
132	/**
133	* The (common) global data.
134	*/
135	static VBOXNETFLTGLOBALS g_VBoxNetFltGlobals;
136
137	module_init(VBoxNetFltLinuxInit);
138	module_exit(VBoxNetFltLinuxUnload);
139
140	MODULE_AUTHOR(VBOX_VENDOR);
141	MODULE_DESCRIPTION(VBOX_PRODUCT " Network Filter Driver");
142	MODULE_LICENSE("GPL");
143	#ifdef MODULE_VERSION
144	MODULE_VERSION(VBOX_VERSION_STRING " (" RT_XSTR(INTNETTRUNKIFPORT_VERSION) ")");
145	#endif
146
147
148	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12) && defined(LOG_ENABLED)
149	unsigned dev_get_flags(const struct net_device *dev)
150	{
151	unsigned flags;
152
153	flags = (dev->flags & ~(IFF_PROMISC \|
154	IFF_ALLMULTI \|
155	IFF_RUNNING)) \|
156	(dev->gflags & (IFF_PROMISC \|
157	IFF_ALLMULTI));
158
159	if (netif_running(dev) && netif_carrier_ok(dev))
160	flags \|= IFF_RUNNING;
161
162	return flags;
163	}
164	#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12) */
165
166
167	/**
168	* Initialize module.
169	*
170	* @returns appropriate status code.
171	*/
172	static int __init VBoxNetFltLinuxInit(void)
173	{
174	int rc;
175	/*
176	* Initialize IPRT.
177	*/
178	rc = RTR0Init(0);
179	if (RT_SUCCESS(rc))
180	{
181	Log(("VBoxNetFltLinuxInit\n"));
182
183	/*
184	* Initialize the globals and connect to the support driver.
185	*
186	* This will call back vboxNetFltOsOpenSupDrv (and maybe vboxNetFltOsCloseSupDrv)
187	* for establishing the connect to the support driver.
188	*/
189	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
190	rc = vboxNetFltInitGlobalsAndIdc(&g_VBoxNetFltGlobals);
191	if (RT_SUCCESS(rc))
192	{
193	LogRel(("VBoxNetFlt: Successfully started.\n"));
194	return 0;
195	}
196
197	LogRel(("VBoxNetFlt: failed to initialize device extension (rc=%d)\n", rc));
198	RTR0Term();
199	}
200	else
201	LogRel(("VBoxNetFlt: failed to initialize IPRT (rc=%d)\n", rc));
202
203	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
204	return -RTErrConvertToErrno(rc);
205	}
206
207
208	/**
209	* Unload the module.
210	*
211	* @todo We have to prevent this if we're busy!
212	*/
213	static void __exit VBoxNetFltLinuxUnload(void)
214	{
215	int rc;
216	Log(("VBoxNetFltLinuxUnload\n"));
217	Assert(vboxNetFltCanUnload(&g_VBoxNetFltGlobals));
218
219	/*
220	* Undo the work done during start (in reverse order).
221	*/
222	rc = vboxNetFltTryDeleteIdcAndGlobals(&g_VBoxNetFltGlobals);
223	AssertRC(rc); NOREF(rc);
224
225	RTR0Term();
226
227	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
228
229	Log(("VBoxNetFltLinuxUnload - done\n"));
230	}
231
232	/**
233	* Experiment where we filter trafic from the host to the internal network
234	* before it reaches the NIC driver.
235	*
236	* The current code uses a very ugly hack and only works on kernels using the
237	* net_device_ops (>= 2.6.29). It has been shown to give us a
238	* performance boost of 60-100% though. So, we have to find some less hacky way
239	* of getting this job done eventually.
240	*
241	* #define VBOXNETFLT_WITH_FILTER_HOST2GUEST_SKBS_EXPERIMENT
242	*/
243	#ifdef VBOXNETFLT_WITH_FILTER_HOST2GUEST_SKBS_EXPERIMENT
244
245	/**
246	* The overridden net_device_ops of the device we're attached to.
247	*
248	* Requires Linux 2.6.29 or later.
249	*
250	* This is a very dirty hack that was create to explore how much we can improve
251	* the host to guest transfers by not CC'ing the NIC.
252	*/
253	typedef struct VBoxNetDeviceOpsOverride
254	{
255	/** Our overridden ops. */
256	struct net_device_ops Ops;
257	/** Magic word. */
258	uint32_t u32Magic;
259	/** Pointer to the original ops. */
260	struct net_device_ops const *pOrgOps;
261	/** Pointer to the net filter instance. */
262	PVBOXNETFLTINS pVBoxNetFlt;
263	/** The number of filtered packages. */
264	uint64_t cFiltered;
265	/** The total number of packets */
266	uint64_t cTotal;
267	} VBOXNETDEVICEOPSOVERRIDE, *PVBOXNETDEVICEOPSOVERRIDE;
268	/** VBOXNETDEVICEOPSOVERRIDE::u32Magic value. */
269	#define VBOXNETDEVICEOPSOVERRIDE_MAGIC UINT32_C(0x00c0ffee)
270
271	/**
272	* ndo_start_xmit wrapper that drops packets that shouldn't go to the wire
273	* because they belong on the internal network.
274	*
275	* @returns NETDEV_TX_XXX.
276	* @param pSkb The socket buffer to transmit.
277	* @param pDev The net device.
278	*/
279	static int vboxNetFltLinuxStartXmitFilter(struct sk_buff pSkb, struct net_device pDev)
280	{
281	PVBOXNETDEVICEOPSOVERRIDE pOverride = (PVBOXNETDEVICEOPSOVERRIDE)pDev->netdev_ops;
282	uint8_t abHdrBuf[sizeof(RTNETETHERHDR) + sizeof(uint32_t) + RTNETIPV4_MIN_LEN];
283	PCRTNETETHERHDR pEtherHdr;
284	PINTNETTRUNKSWPORT pSwitchPort;
285
286
287	/*
288	* Validate the override structure.
289	*
290	* Note! We're racing vboxNetFltLinuxUnhookDev here. If this was supposed
291	* to be production quality code, we would have to be much more
292	* careful here and avoid the race.
293	*/
294	if ( !VALID_PTR(pOverride)
295	\|\| pOverride->u32Magic != VBOXNETDEVICEOPSOVERRIDE_MAGIC
296	\|\| !VALID_PTR(pOverride->pOrgOps))
297	{
298	printk("vboxNetFltLinuxStartXmitFilter: bad override %p\n", pOverride);
299	dev_kfree_skb(pSkb);
300	return NETDEV_TX_OK;
301	}
302	pOverride->cTotal++;
303
304	/*
305	* Do the filtering base on the defaul OUI of our virtual NICs
306	*
307	* Note! In a real solution, we would ask the switch whether the
308	* destination MAC is 100% to be on the internal network and then
309	* drop it.
310	*/
311	pEtherHdr = (PCRTNETETHERHDR)skb_header_pointer(pSkb, 0, sizeof(abHdrBuf), &abHdrBuf[0]);
312	if ( pEtherHdr
313	&& VALID_PTR(pOverride->pVBoxNetFlt)
314	&& (pSwitchPort = pOverride->pVBoxNetFlt->pSwitchPort) != NULL
315	&& VALID_PTR(pSwitchPort)
316	)
317	{
318	INTNETSWDECISION enmDecision;
319	uint32_t cbHdrs = skb_headlen(pSkb);
320	cbHdrs = RT_MAX(cbHdrs, sizeof(abHdrBuf));
321
322	/** @todo consider reference counting, etc. */
323	enmDecision = pSwitchPort->pfnPreRecv(pSwitchPort, pEtherHdr, cbHdrs, INTNETTRUNKDIR_HOST);
324	if (enmDecision == INTNETSWDECISION_INTNET)
325	{
326	dev_kfree_skb(pSkb);
327	pOverride->cFiltered++;
328	return NETDEV_TX_OK;
329	}
330	}
331
332	return pOverride->pOrgOps->ndo_start_xmit(pSkb, pDev);
333	}
334
335	/**
336	* Hooks the device ndo_start_xmit operation of the device.
337	*
338	* @param pThis The net filter instance.
339	* @param pDev The net device.
340	*/
341	static void vboxNetFltLinuxHookDev(PVBOXNETFLTINS pThis, struct net_device *pDev)
342	{
343	PVBOXNETDEVICEOPSOVERRIDE pOverride;
344	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
345
346	pOverride = RTMemAlloc(sizeof(*pOverride));
347	if (!pOverride)
348	return;
349	pOverride->pOrgOps = pDev->netdev_ops;
350	pOverride->Ops = *pDev->netdev_ops;
351	pOverride->Ops.ndo_start_xmit = vboxNetFltLinuxStartXmitFilter;
352	pOverride->u32Magic = VBOXNETDEVICEOPSOVERRIDE_MAGIC;
353	pOverride->cTotal = 0;
354	pOverride->cFiltered = 0;
355	pOverride->pVBoxNetFlt = pThis;
356
357	RTSpinlockAcquire(pThis->hSpinlock, &Tmp); /* (this isn't necessary, but so what) */
358	ASMAtomicXchgPtr((void * volatile *)&pDev->netdev_ops, pOverride);
359	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
360	}
361
362	/**
363	* Undos what vboxNetFltLinuxHookDev did.
364	*
365	* @param pThis The net filter instance.
366	* @param pDev The net device. Can be NULL, in which case
367	* we'll try retrieve it from @a pThis.
368	*/
369	static void vboxNetFltLinuxUnhookDev(PVBOXNETFLTINS pThis, struct net_device *pDev)
370	{
371	PVBOXNETDEVICEOPSOVERRIDE pOverride;
372	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
373
374	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
375	if (!pDev)
376	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
377	if (VALID_PTR(pDev))
378	{
379	pOverride = (PVBOXNETDEVICEOPSOVERRIDE)pDev->netdev_ops;
380	if ( VALID_PTR(pOverride)
381	&& pOverride->u32Magic == VBOXNETDEVICEOPSOVERRIDE_MAGIC
382	&& VALID_PTR(pOverride->pOrgOps)
383	)
384	{
385	ASMAtomicXchgPtr((void * volatile *)&pDev->netdev_ops, pOverride->pOrgOps);
386	ASMAtomicWriteU32(&pOverride->u32Magic, 0);
387	}
388	else
389	pOverride = NULL;
390	}
391	else
392	pOverride = NULL;
393	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
394
395	if (pOverride)
396	{
397	printk("vboxnetflt: dropped %llu out of %llu packets\n", pOverride->cFiltered, pOverride->cTotal);
398	RTMemFree(pOverride);
399	}
400	}
401
402	#endif /* VBOXNETFLT_WITH_FILTER_HOST2GUEST_SKBS_EXPERIMENT */
403
404
405	/**
406	* Reads and retains the host interface handle.
407	*
408	* @returns The handle, NULL if detached.
409	* @param pThis
410	*/
411	DECLINLINE(struct net_device *) vboxNetFltLinuxRetainNetDev(PVBOXNETFLTINS pThis)
412	{
413	#if 0
414	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
415	struct net_device *pDev = NULL;
416
417	Log(("vboxNetFltLinuxRetainNetDev\n"));
418	/*
419	* Be careful here to avoid problems racing the detached callback.
420	*/
421	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
422	if (!ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost))
423	{
424	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
425	if (pDev)
426	{
427	dev_hold(pDev);
428	Log(("vboxNetFltLinuxRetainNetDev: Device %p(%s) retained. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
429	}
430	}
431	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
432
433	Log(("vboxNetFltLinuxRetainNetDev - done\n"));
434	return pDev;
435	#else
436	return (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
437	#endif
438	}
439
440
441	/**
442	* Release the host interface handle previously retained
443	* by vboxNetFltLinuxRetainNetDev.
444	*
445	* @param pThis The instance.
446	* @param pDev The vboxNetFltLinuxRetainNetDev
447	* return value, NULL is fine.
448	*/
449	DECLINLINE(void) vboxNetFltLinuxReleaseNetDev(PVBOXNETFLTINS pThis, struct net_device *pDev)
450	{
451	#if 0
452	Log(("vboxNetFltLinuxReleaseNetDev\n"));
453	NOREF(pThis);
454	if (pDev)
455	{
456	dev_put(pDev);
457	Log(("vboxNetFltLinuxReleaseNetDev: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
458	}
459	Log(("vboxNetFltLinuxReleaseNetDev - done\n"));
460	#endif
461	}
462
463	#define VBOXNETFLT_CB_TAG(skb) (0xA1C90000 \| (skb->dev->ifindex & 0xFFFF))
464	#define VBOXNETFLT_SKB_TAG(skb) ((uint32_t)&((skb)->cb[sizeof((skb)->cb)-sizeof(uint32_t)]))
465
466	/**
467	* Checks whether this is an mbuf created by vboxNetFltLinuxMBufFromSG,
468	* i.e. a buffer which we're pushing and should be ignored by the filter callbacks.
469	*
470	* @returns true / false accordingly.
471	* @param pBuf The sk_buff.
472	*/
473	DECLINLINE(bool) vboxNetFltLinuxSkBufIsOur(struct sk_buff *pBuf)
474	{
475	return VBOXNETFLT_SKB_TAG(pBuf) == VBOXNETFLT_CB_TAG(pBuf);
476	}
477
478
479	/**
480	* Internal worker that create a linux sk_buff for a
481	* (scatter/)gather list.
482	*
483	* @returns Pointer to the sk_buff.
484	* @param pThis The instance.
485	* @param pSG The (scatter/)gather list.
486	* @param fDstWire Set if the destination is the wire.
487	*/
488	static struct sk_buff *vboxNetFltLinuxSkBufFromSG(PVBOXNETFLTINS pThis, PINTNETSG pSG, bool fDstWire)
489	{
490	struct sk_buff *pPkt;
491	struct net_device *pDev;
492	unsigned fGsoType = 0;
493
494	if (pSG->cbTotal == 0)
495	{
496	LogRel(("VBoxNetFlt: Dropped empty packet coming from internal network.\n"));
497	return NULL;
498	}
499
500	/** @todo We should use fragments mapping the SG buffers with large packets.
501	* 256 bytes seems to be the a threshold used a lot for this. It
502	* requires some nasty work on the intnet side though... */
503	/*
504	* Allocate a packet and copy over the data.
505	*/
506	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
507	pPkt = dev_alloc_skb(pSG->cbTotal + NET_IP_ALIGN);
508	if (RT_UNLIKELY(!pPkt))
509	{
510	Log(("vboxNetFltLinuxSkBufFromSG: Failed to allocate sk_buff(%u).\n", pSG->cbTotal));
511	pSG->pvUserData = NULL;
512	return NULL;
513	}
514	pPkt->dev = pDev;
515	pPkt->ip_summed = CHECKSUM_NONE;
516
517	/* Align IP header on 16-byte boundary: 2 + 14 (ethernet hdr size). */
518	skb_reserve(pPkt, NET_IP_ALIGN);
519
520	/* Copy the segments. */
521	skb_put(pPkt, pSG->cbTotal);
522	INTNETSgRead(pSG, pPkt->data);
523
524	#if defined(VBOXNETFLT_WITH_GSO_XMIT_WIRE) \|\| defined(VBOXNETFLT_WITH_GSO_XMIT_HOST)
525	/*
526	* Setup GSO if used by this packet.
527	*/
528	switch ((PDMNETWORKGSOTYPE)pSG->GsoCtx.u8Type)
529	{
530	default:
531	AssertMsgFailed(("%u (%s)\n", pSG->GsoCtx.u8Type, PDMNetGsoTypeName((PDMNETWORKGSOTYPE)pSG->GsoCtx.u8Type) ));
532	/* fall thru */
533	case PDMNETWORKGSOTYPE_INVALID:
534	fGsoType = 0;
535	break;
536	case PDMNETWORKGSOTYPE_IPV4_TCP:
537	fGsoType = SKB_GSO_TCPV4;
538	break;
539	case PDMNETWORKGSOTYPE_IPV4_UDP:
540	fGsoType = SKB_GSO_UDP;
541	break;
542	case PDMNETWORKGSOTYPE_IPV6_TCP:
543	fGsoType = SKB_GSO_TCPV6;
544	break;
545	}
546	if (fGsoType)
547	{
548	struct skb_shared_info *pShInfo = skb_shinfo(pPkt);
549
550	pShInfo->gso_type = fGsoType \| SKB_GSO_DODGY;
551	pShInfo->gso_size = pSG->GsoCtx.cbMaxSeg;
552	pShInfo->gso_segs = PDMNetGsoCalcSegmentCount(&pSG->GsoCtx, pSG->cbTotal);
553
554	if (fDstWire)
555	{
556	Assert(skb_headlen(pPkt) >= pSG->GsoCtx.cbHdrs);
557	pPkt->ip_summed = CHECKSUM_PARTIAL;
558	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
559	pPkt->csum_start = skb_headroom(pPkt) + pSG->GsoCtx.offHdr2;
560	if (fGsoType & (SKB_GSO_TCPV4 \| SKB_GSO_TCPV6))
561	pPkt->csum_offset = RT_OFFSETOF(RTNETTCP, th_sum);
562	else
563	pPkt->csum_offset = RT_OFFSETOF(RTNETUDP, uh_sum);
564	# else
565	pPkt->h.raw = pPkt->data + pSG->GsoCtx.offHdr2;
566	if (fGsoType & (SKB_GSO_TCPV4 \| SKB_GSO_TCPV6))
567	pPkt->csum = RT_OFFSETOF(RTNETTCP, th_sum);
568	else
569	pPkt->csum = RT_OFFSETOF(RTNETUDP, uh_sum);
570	# endif
571	}
572	else
573	{
574	pPkt->ip_summed = CHECKSUM_UNNECESSARY;
575	pPkt->csum = 0;
576	PDMNetGsoPrepForDirectUse(&pSG->GsoCtx, pPkt->data, pSG->cbTotal, false /fPayloadChecksum/);
577	}
578	}
579	#endif /* VBOXNETFLT_WITH_GSO_XMIT_WIRE \|\| VBOXNETFLT_WITH_GSO_XMIT_HOST */
580
581	/*
582	* Finish up the socket buffer.
583	*/
584	pPkt->protocol = eth_type_trans(pPkt, pDev);
585	if (fDstWire)
586	{
587	VBOX_SKB_RESET_NETWORK_HDR(pPkt);
588
589	/* Restore ethernet header back. */
590	skb_push(pPkt, ETH_HLEN); /** @todo VLAN: +4 if VLAN? */
591	VBOX_SKB_RESET_MAC_HDR(pPkt);
592	}
593	VBOXNETFLT_SKB_TAG(pPkt) = VBOXNETFLT_CB_TAG(pPkt);
594
595	return pPkt;
596	}
597
598
599	/**
600	* Initializes a SG list from an sk_buff.
601	*
602	* @returns Number of segments.
603	* @param pThis The instance.
604	* @param pBuf The sk_buff.
605	* @param pSG The SG.
606	* @param pvFrame The frame pointer, optional.
607	* @param cSegs The number of segments allocated for the SG.
608	* This should match the number in the mbuf exactly!
609	* @param fSrc The source of the frame.
610	* @param pGso Pointer to the GSO context if it's a GSO
611	* internal network frame. NULL if regular frame.
612	*/
613	DECLINLINE(void) vboxNetFltLinuxSkBufToSG(PVBOXNETFLTINS pThis, struct sk_buff *pBuf, PINTNETSG pSG,
614	unsigned cSegs, uint32_t fSrc, PCPDMNETWORKGSO pGsoCtx)
615	{
616	int i;
617	NOREF(pThis);
618
619	Assert(!skb_shinfo(pBuf)->frag_list);
620
621	if (fSrc & INTNETTRUNKDIR_WIRE)
622	{
623	/*
624	* The packet came from wire, ethernet header was removed by device driver.
625	* Restore it.
626	*/
627	skb_push(pBuf, ETH_HLEN);
628	}
629
630	if (!pGsoCtx)
631	INTNETSgInitTempSegs(pSG, pBuf->len, cSegs, 0 /cSegsUsed/);
632	else
633	INTNETSgInitTempSegsGso(pSG, pBuf->len, cSegs, 0 /cSegsUsed/, pGsoCtx);
634
635	#ifdef VBOXNETFLT_SG_SUPPORT
636	pSG->aSegs[0].cb = skb_headlen(pBuf);
637	pSG->aSegs[0].pv = pBuf->data;
638	pSG->aSegs[0].Phys = NIL_RTHCPHYS;
639
640	for (i = 0; i < skb_shinfo(pBuf)->nr_frags; i++)
641	{
642	skb_frag_t *pFrag = &skb_shinfo(pBuf)->frags[i];
643	pSG->aSegs[i+1].cb = pFrag->size;
644	pSG->aSegs[i+1].pv = kmap(pFrag->page);
645	printk("%p = kmap()\n", pSG->aSegs[i+1].pv);
646	pSG->aSegs[i+1].Phys = NIL_RTHCPHYS;
647	}
648	++i;
649
650	#else
651	pSG->aSegs[0].cb = pBuf->len;
652	pSG->aSegs[0].pv = pBuf->data;
653	pSG->aSegs[0].Phys = NIL_RTHCPHYS;
654	i = 1;
655	#endif
656
657	pSG->cSegsUsed = i;
658
659	#ifdef PADD_RUNT_FRAMES_FROM_HOST
660	/*
661	* Add a trailer if the frame is too small.
662	*
663	* Since we're getting to the packet before it is framed, it has not
664	* yet been padded. The current solution is to add a segment pointing
665	* to a buffer containing all zeros and pray that works for all frames...
666	*/
667	if (pSG->cbTotal < 60 && (fSrc & INTNETTRUNKDIR_HOST))
668	{
669	static uint8_t const s_abZero[128] = {0};
670
671	AssertReturnVoid(i < cSegs);
672
673	pSG->aSegs[i].Phys = NIL_RTHCPHYS;
674	pSG->aSegs[i].pv = (void *)&s_abZero[0];
675	pSG->aSegs[i].cb = 60 - pSG->cbTotal;
676	pSG->cbTotal = 60;
677	pSG->cSegsUsed++;
678	Assert(i + 1 <= pSG->cSegsAlloc)
679	}
680	#endif
681
682	Log4(("vboxNetFltLinuxSkBufToSG: allocated=%d, segments=%d frags=%d next=%p frag_list=%p pkt_type=%x fSrc=%x\n",
683	pSG->cSegsAlloc, pSG->cSegsUsed, skb_shinfo(pBuf)->nr_frags, pBuf->next, skb_shinfo(pBuf)->frag_list, pBuf->pkt_type, fSrc));
684	for (i = 0; i < pSG->cSegsUsed; i++)
685	Log4(("vboxNetFltLinuxSkBufToSG: #%d: cb=%d pv=%p\n",
686	i, pSG->aSegs[i].cb, pSG->aSegs[i].pv));
687	}
688
689	/**
690	* Packet handler,
691	*
692	* @returns 0 or EJUSTRETURN.
693	* @param pThis The instance.
694	* @param pMBuf The mbuf.
695	* @param pvFrame The start of the frame, optional.
696	* @param fSrc Where the packet (allegedly) comes from, one INTNETTRUNKDIR_* value.
697	* @param eProtocol The protocol.
698	*/
699	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
700	static int vboxNetFltLinuxPacketHandler(struct sk_buff *pBuf,
701	struct net_device *pSkbDev,
702	struct packet_type *pPacketType,
703	struct net_device *pOrigDev)
704	#else
705	static int vboxNetFltLinuxPacketHandler(struct sk_buff *pBuf,
706	struct net_device *pSkbDev,
707	struct packet_type *pPacketType)
708	#endif
709	{
710	PVBOXNETFLTINS pThis;
711	struct net_device *pDev;
712	LogFlow(("vboxNetFltLinuxPacketHandler: pBuf=%p pSkbDev=%p pPacketType=%p\n",
713	pBuf, pSkbDev, pPacketType));
714	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
715	Log3(("vboxNetFltLinuxPacketHandler: skb len=%u data_len=%u truesize=%u next=%p nr_frags=%u gso_size=%u gso_seqs=%u gso_type=%x frag_list=%p pkt_type=%x\n",
716	pBuf->len, pBuf->data_len, pBuf->truesize, pBuf->next, skb_shinfo(pBuf)->nr_frags, skb_shinfo(pBuf)->gso_size, skb_shinfo(pBuf)->gso_segs, skb_shinfo(pBuf)->gso_type, skb_shinfo(pBuf)->frag_list, pBuf->pkt_type));
717	#else
718	Log3(("vboxNetFltLinuxPacketHandler: skb len=%u data_len=%u truesize=%u next=%p nr_frags=%u tso_size=%u tso_seqs=%u frag_list=%p pkt_type=%x\n",
719	pBuf->len, pBuf->data_len, pBuf->truesize, pBuf->next, skb_shinfo(pBuf)->nr_frags, skb_shinfo(pBuf)->tso_size, skb_shinfo(pBuf)->tso_segs, skb_shinfo(pBuf)->frag_list, pBuf->pkt_type));
720	#endif
721	/*
722	* Drop it immediately?
723	*/
724	if (!pBuf)
725	return 0;
726
727	pThis = VBOX_FLT_PT_TO_INST(pPacketType);
728	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
729	if (pThis->u.s.pDev != pSkbDev)
730	{
731	Log(("vboxNetFltLinuxPacketHandler: Devices do not match, pThis may be wrong! pThis=%p\n", pThis));
732	return 0;
733	}
734
735	Log4(("vboxNetFltLinuxPacketHandler: pBuf->cb dump:\n%.*Rhxd\n", sizeof(pBuf->cb), pBuf->cb));
736	if (vboxNetFltLinuxSkBufIsOur(pBuf))
737	{
738	Log2(("vboxNetFltLinuxPacketHandler: got our own sk_buff, drop it.\n"));
739	dev_kfree_skb(pBuf);
740	return 0;
741	}
742
743	#ifndef VBOXNETFLT_SG_SUPPORT
744	{
745	/*
746	* Get rid of fragmented packets, they cause too much trouble.
747	*/
748	struct sk_buff *pCopy = skb_copy(pBuf, GFP_ATOMIC);
749	kfree_skb(pBuf);
750	if (!pCopy)
751	{
752	LogRel(("VBoxNetFlt: Failed to allocate packet buffer, dropping the packet.\n"));
753	return 0;
754	}
755	pBuf = pCopy;
756	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
757	Log3(("vboxNetFltLinuxPacketHandler: skb copy len=%u data_len=%u truesize=%u next=%p nr_frags=%u gso_size=%u gso_seqs=%u gso_type=%x frag_list=%p pkt_type=%x\n",
758	pBuf->len, pBuf->data_len, pBuf->truesize, pBuf->next, skb_shinfo(pBuf)->nr_frags, skb_shinfo(pBuf)->gso_size, skb_shinfo(pBuf)->gso_segs, skb_shinfo(pBuf)->gso_type, skb_shinfo(pBuf)->frag_list, pBuf->pkt_type));
759	# else
760	Log3(("vboxNetFltLinuxPacketHandler: skb copy len=%u data_len=%u truesize=%u next=%p nr_frags=%u tso_size=%u tso_seqs=%u frag_list=%p pkt_type=%x\n",
761	pBuf->len, pBuf->data_len, pBuf->truesize, pBuf->next, skb_shinfo(pBuf)->nr_frags, skb_shinfo(pBuf)->tso_size, skb_shinfo(pBuf)->tso_segs, skb_shinfo(pBuf)->frag_list, pBuf->pkt_type));
762	# endif
763	}
764	#endif
765
766	#ifdef VBOXNETFLT_LINUX_NO_XMIT_QUEUE
767	/* Forward it to the internal network. */
768	vboxNetFltLinuxForwardToIntNet(pThis, pBuf);
769	#else
770	/* Add the packet to transmit queue and schedule the bottom half. */
771	skb_queue_tail(&pThis->u.s.XmitQueue, pBuf);
772	schedule_work(&pThis->u.s.XmitTask);
773	Log4(("vboxNetFltLinuxPacketHandler: scheduled work %p for sk_buff %p\n",
774	&pThis->u.s.XmitTask, pBuf));
775	#endif
776
777	/* It does not really matter what we return, it is ignored by the kernel. */
778	return 0;
779	}
780
781	/**
782	* Calculate the number of INTNETSEG segments the socket buffer will need.
783	*
784	* @returns Segment count.
785	* @param pBuf The socket buffer.
786	*/
787	DECLINLINE(unsigned) vboxNetFltLinuxCalcSGSegments(struct sk_buff *pBuf)
788	{
789	#ifdef VBOXNETFLT_SG_SUPPORT
790	unsigned cSegs = 1 + skb_shinfo(pBuf)->nr_frags;
791	#else
792	unsigned cSegs = 1;
793	#endif
794	#ifdef PADD_RUNT_FRAMES_FROM_HOST
795	/* vboxNetFltLinuxSkBufToSG adds a padding segment if it's a runt. */
796	if (pBuf->len < 60)
797	cSegs++;
798	#endif
799	return cSegs;
800	}
801
802	/**
803	* Destroy the intnet scatter / gather buffer created by
804	* vboxNetFltLinuxSkBufToSG.
805	*/
806	static void vboxNetFltLinuxDestroySG(PINTNETSG pSG)
807	{
808	#ifdef VBOXNETFLT_SG_SUPPORT
809	int i;
810
811	for (i = 0; i < skb_shinfo(pBuf)->nr_frags; i++)
812	{
813	printk("kunmap(%p)\n", pSG->aSegs[i+1].pv);
814	kunmap(pSG->aSegs[i+1].pv);
815	}
816	#endif
817	NOREF(pSG);
818	}
819
820	#ifdef LOG_ENABLED
821	/**
822	* Logging helper.
823	*/
824	static void vboxNetFltDumpPacket(PINTNETSG pSG, bool fEgress, const char *pszWhere, int iIncrement)
825	{
826	uint8_t pInt, pExt;
827	static int iPacketNo = 1;
828	iPacketNo += iIncrement;
829	if (fEgress)
830	{
831	pExt = pSG->aSegs[0].pv;
832	pInt = pExt + 6;
833	}
834	else
835	{
836	pInt = pSG->aSegs[0].pv;
837	pExt = pInt + 6;
838	}
839	Log(("VBoxNetFlt: (int)%02x:%02x:%02x:%02x:%02x:%02x"
840	" %s (%s)%02x:%02x:%02x:%02x:%02x:%02x (%u bytes) packet #%u\n",
841	pInt[0], pInt[1], pInt[2], pInt[3], pInt[4], pInt[5],
842	fEgress ? "-->" : "<--", pszWhere,
843	pExt[0], pExt[1], pExt[2], pExt[3], pExt[4], pExt[5],
844	pSG->cbTotal, iPacketNo));
845	Log3(("%.*Rhxd\n", pSG->aSegs[0].cb, pSG->aSegs[0].pv));
846	}
847	#else
848	# define vboxNetFltDumpPacket(a, b, c, d) do {} while (0)
849	#endif
850
851	#ifdef VBOXNETFLT_WITH_GSO_RECV
852
853	/**
854	* Worker for vboxNetFltLinuxForwardToIntNet that checks if we can forwards a
855	* GSO socket buffer without having to segment it.
856	*
857	* @returns true on success, false if needs segmenting.
858	* @param pThis The net filter instance.
859	* @param pSkb The GSO socket buffer.
860	* @param fSrc The source.
861	* @param pGsoCtx Where to return the GSO context on success.
862	*/
863	static bool vboxNetFltLinuxCanForwardAsGso(PVBOXNETFLTINS pThis, struct sk_buff *pSkb, uint32_t fSrc,
864	PPDMNETWORKGSO pGsoCtx)
865	{
866	PDMNETWORKGSOTYPE enmGsoType;
867	uint16_t uEtherType;
868	unsigned int cbTransport;
869	unsigned int offTransport;
870	unsigned int cbTransportHdr;
871	unsigned uProtocol;
872	union
873	{
874	RTNETIPV4 IPv4;
875	RTNETIPV6 IPv6;
876	RTNETTCP Tcp;
877	uint8_t ab[40];
878	uint16_t au16[40/2];
879	uint32_t au32[40/4];
880	} Buf;
881
882	/*
883	* Check the GSO properties of the socket buffer and make sure it fits.
884	*/
885	/** @todo Figure out how to handle SKB_GSO_TCP_ECN! */
886	if (RT_UNLIKELY( skb_shinfo(pSkb)->gso_type & ~(SKB_GSO_UDP \| SKB_GSO_DODGY \| SKB_GSO_TCPV6 \| SKB_GSO_TCPV4) ))
887	{
888	Log5(("vboxNetFltLinuxCanForwardAsGso: gso_type=%#x\n", skb_shinfo(pSkb)->gso_type));
889	return false;
890	}
891	if (RT_UNLIKELY( skb_shinfo(pSkb)->gso_size < 1
892	\|\| pSkb->len > VBOX_MAX_GSO_SIZE ))
893	{
894	Log5(("vboxNetFltLinuxCanForwardAsGso: gso_size=%#x skb_len=%#x (max=%#x)\n", skb_shinfo(pSkb)->gso_size, pSkb->len, VBOX_MAX_GSO_SIZE));
895	return false;
896	}
897	if (RT_UNLIKELY(fSrc & INTNETTRUNKDIR_WIRE))
898	{
899	Log5(("vboxNetFltLinuxCanForwardAsGso: fSrc=wire\n"));
900	return false;
901	}
902
903	/*
904	* skb_gso_segment does the following. Do we need to do it as well?
905	*/
906	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
907	skb_reset_mac_header(pSkb);
908	pSkb->mac_len = pSkb->network_header - pSkb->mac_header;
909	#else
910	pSkb->mac.raw = pSkb->data;
911	pSkb->mac_len = pSkb->nh.raw - pSkb->data;
912	#endif
913
914	/*
915	* Switch on the ethertype.
916	*/
917	uEtherType = pSkb->protocol;
918	if ( uEtherType == RT_H2N_U16_C(RTNET_ETHERTYPE_VLAN)
919	&& pSkb->mac_len == sizeof(RTNETETHERHDR) + sizeof(uint32_t))
920	{
921	uint16_t const *puEtherType = skb_header_pointer(pSkb, sizeof(RTNETETHERHDR) + sizeof(uint16_t), sizeof(uint16_t), &Buf);
922	if (puEtherType)
923	uEtherType = *puEtherType;
924	}
925	switch (uEtherType)
926	{
927	case RT_H2N_U16_C(RTNET_ETHERTYPE_IPV4):
928	{
929	unsigned int cbHdr;
930	PCRTNETIPV4 pIPv4 = (PCRTNETIPV4)skb_header_pointer(pSkb, pSkb->mac_len, sizeof(Buf.IPv4), &Buf);
931	if (RT_UNLIKELY(!pIPv4))
932	{
933	Log5(("vboxNetFltLinuxCanForwardAsGso: failed to access IPv4 hdr\n"));
934	return false;
935	}
936
937	cbHdr = pIPv4->ip_hl * 4;
938	cbTransport = RT_N2H_U16(pIPv4->ip_len);
939	if (RT_UNLIKELY( cbHdr < RTNETIPV4_MIN_LEN
940	\|\| cbHdr > cbTransport ))
941	{
942	Log5(("vboxNetFltLinuxCanForwardAsGso: invalid IPv4 lengths: ip_hl=%u ip_len=%u\n", pIPv4->ip_hl, RT_N2H_U16(pIPv4->ip_len)));
943	return false;
944	}
945	cbTransport -= cbHdr;
946	offTransport = pSkb->mac_len + cbHdr;
947	uProtocol = pIPv4->ip_p;
948	if (uProtocol == RTNETIPV4_PROT_TCP)
949	enmGsoType = PDMNETWORKGSOTYPE_IPV4_TCP;
950	else if (uProtocol == RTNETIPV4_PROT_UDP)
951	enmGsoType = PDMNETWORKGSOTYPE_IPV4_UDP;
952	else /** @todo IPv6: 4to6 tunneling */
953	enmGsoType = PDMNETWORKGSOTYPE_INVALID;
954	break;
955	}
956
957	case RT_H2N_U16_C(RTNET_ETHERTYPE_IPV6):
958	{
959	PCRTNETIPV6 pIPv6 = (PCRTNETIPV6)skb_header_pointer(pSkb, pSkb->mac_len, sizeof(Buf.IPv6), &Buf);
960	if (RT_UNLIKELY(!pIPv6))
961	{
962	Log5(("vboxNetFltLinuxCanForwardAsGso: failed to access IPv6 hdr\n"));
963	return false;
964	}
965
966	cbTransport = RT_N2H_U16(pIPv6->ip6_plen);
967	offTransport = pSkb->mac_len + sizeof(RTNETIPV6);
968	uProtocol = pIPv6->ip6_nxt;
969	/** @todo IPv6: Dig our way out of the other headers. */
970	if (uProtocol == RTNETIPV4_PROT_TCP)
971	enmGsoType = PDMNETWORKGSOTYPE_IPV6_TCP;
972	else if (uProtocol == RTNETIPV4_PROT_UDP)
973	enmGsoType = PDMNETWORKGSOTYPE_IPV4_UDP;
974	else
975	enmGsoType = PDMNETWORKGSOTYPE_INVALID;
976	break;
977	}
978
979	default:
980	Log5(("vboxNetFltLinuxCanForwardAsGso: uEtherType=%#x\n", RT_H2N_U16(uEtherType)));
981	return false;
982	}
983
984	if (enmGsoType == PDMNETWORKGSOTYPE_INVALID)
985	{
986	Log5(("vboxNetFltLinuxCanForwardAsGso: Unsupported protocol %d\n", uProtocol));
987	return false;
988	}
989
990	if (RT_UNLIKELY( offTransport + cbTransport <= offTransport
991	\|\| offTransport + cbTransport > pSkb->len
992	\|\| cbTransport < (uProtocol == RTNETIPV4_PROT_TCP ? RTNETTCP_MIN_LEN : RTNETUDP_MIN_LEN)) )
993	{
994	Log5(("vboxNetFltLinuxCanForwardAsGso: Bad transport length; off=%#x + cb=%#x => %#x; skb_len=%#x (%s)\n",
995	offTransport, cbTransport, offTransport + cbTransport, pSkb->len, PDMNetGsoTypeName(enmGsoType) ));
996	return false;
997	}
998
999	/*
1000	* Check the TCP/UDP bits.
1001	*/
1002	if (uProtocol == RTNETIPV4_PROT_TCP)
1003	{
1004	PCRTNETTCP pTcp = (PCRTNETTCP)skb_header_pointer(pSkb, offTransport, sizeof(Buf.Tcp), &Buf);
1005	if (RT_UNLIKELY(!pTcp))
1006	{
1007	Log5(("vboxNetFltLinuxCanForwardAsGso: failed to access TCP hdr\n"));
1008	return false;
1009	}
1010
1011	cbTransportHdr = pTcp->th_off * 4;
1012	if (RT_UNLIKELY( cbTransportHdr < RTNETTCP_MIN_LEN
1013	\|\| cbTransportHdr > cbTransport
1014	\|\| offTransport + cbTransportHdr >= UINT8_MAX
1015	\|\| offTransport + cbTransportHdr >= pSkb->len ))
1016	{
1017	Log5(("vboxNetFltLinuxCanForwardAsGso: No space for TCP header; off=%#x cb=%#x skb_len=%#x\n", offTransport, cbTransportHdr, pSkb->len));
1018	return false;
1019	}
1020
1021	}
1022	else
1023	{
1024	Assert(uProtocol == RTNETIPV4_PROT_UDP);
1025	cbTransportHdr = sizeof(RTNETUDP);
1026	if (RT_UNLIKELY( offTransport + cbTransportHdr >= UINT8_MAX
1027	\|\| offTransport + cbTransportHdr >= pSkb->len ))
1028	{
1029	Log5(("vboxNetFltLinuxCanForwardAsGso: No space for UDP header; off=%#x skb_len=%#x\n", offTransport, pSkb->len));
1030	return false;
1031	}
1032	}
1033
1034	/*
1035	* We're good, init the GSO context.
1036	*/
1037	pGsoCtx->u8Type = enmGsoType;
1038	pGsoCtx->cbHdrs = offTransport + cbTransportHdr;
1039	pGsoCtx->cbMaxSeg = skb_shinfo(pSkb)->gso_size;
1040	pGsoCtx->offHdr1 = pSkb->mac_len;
1041	pGsoCtx->offHdr2 = offTransport;
1042	pGsoCtx->au8Unused[0] = 0;
1043	pGsoCtx->au8Unused[1] = 0;
1044
1045	return true;
1046	}
1047
1048	/**
1049	* Forward the socket buffer as a GSO internal network frame.
1050	*
1051	* @returns IPRT status code.
1052	* @param pThis The net filter instance.
1053	* @param pSkb The GSO socket buffer.
1054	* @param fSrc The source.
1055	* @param pGsoCtx Where to return the GSO context on success.
1056	*/
1057	static int vboxNetFltLinuxForwardAsGso(PVBOXNETFLTINS pThis, struct sk_buff *pSkb, uint32_t fSrc, PCPDMNETWORKGSO pGsoCtx)
1058	{
1059	int rc;
1060	unsigned cSegs = vboxNetFltLinuxCalcSGSegments(pSkb);
1061	if (RT_LIKELY(cSegs <= MAX_SKB_FRAGS + 1))
1062	{
1063	PINTNETSG pSG = (PINTNETSG)alloca(RT_OFFSETOF(INTNETSG, aSegs[cSegs]));
1064	if (RT_LIKELY(pSG))
1065	{
1066	vboxNetFltLinuxSkBufToSG(pThis, pSkb, pSG, cSegs, fSrc, pGsoCtx);
1067
1068	vboxNetFltDumpPacket(pSG, false, (fSrc & INTNETTRUNKDIR_HOST) ? "host" : "wire", 1);
1069	pThis->pSwitchPort->pfnRecv(pThis->pSwitchPort, pSG, fSrc);
1070
1071	vboxNetFltLinuxDestroySG(pSG);
1072	rc = VINF_SUCCESS;
1073	}
1074	else
1075	{
1076	Log(("VBoxNetFlt: Dropping the sk_buff (failure case).\n"));
1077	rc = VERR_NO_MEMORY;
1078	}
1079	}
1080	else
1081	{
1082	Log(("VBoxNetFlt: Bad sk_buff? cSegs=%#x.\n", cSegs));
1083	rc = VERR_INTERNAL_ERROR_3;
1084	}
1085
1086	Log4(("VBoxNetFlt: Dropping the sk_buff.\n"));
1087	dev_kfree_skb(pSkb);
1088	return rc;
1089	}
1090
1091	#endif /* VBOXNETFLT_WITH_GSO_RECV */
1092
1093	/**
1094	* Worker for vboxNetFltLinuxForwardToIntNet.
1095	*
1096	* @returns VINF_SUCCESS or VERR_NO_MEMORY.
1097	* @param pThis The net filter instance.
1098	* @param pBuf The socket buffer.
1099	* @param fSrc The source.
1100	*/
1101	static int vboxNetFltLinuxForwardSegment(PVBOXNETFLTINS pThis, struct sk_buff *pBuf, uint32_t fSrc)
1102	{
1103	int rc;
1104	unsigned cSegs = vboxNetFltLinuxCalcSGSegments(pBuf);
1105	if (cSegs <= MAX_SKB_FRAGS + 1)
1106	{
1107	PINTNETSG pSG = (PINTNETSG)alloca(RT_OFFSETOF(INTNETSG, aSegs[cSegs]));
1108	if (RT_LIKELY(pSG))
1109	{
1110	vboxNetFltLinuxSkBufToSG(pThis, pBuf, pSG, cSegs, fSrc, NULL /pGsoCtx/);
1111
1112	vboxNetFltDumpPacket(pSG, false, (fSrc & INTNETTRUNKDIR_HOST) ? "host" : "wire", 1);
1113	pThis->pSwitchPort->pfnRecv(pThis->pSwitchPort, pSG, fSrc);
1114
1115	vboxNetFltLinuxDestroySG(pSG);
1116	rc = VINF_SUCCESS;
1117	}
1118	else
1119	{
1120	Log(("VBoxNetFlt: Failed to allocate SG buffer.\n"));
1121	rc = VERR_NO_MEMORY;
1122	}
1123	}
1124	else
1125	{
1126	Log(("VBoxNetFlt: Bad sk_buff? cSegs=%#x.\n", cSegs));
1127	rc = VERR_INTERNAL_ERROR_3;
1128	}
1129
1130	Log4(("VBoxNetFlt: Dropping the sk_buff.\n"));
1131	dev_kfree_skb(pBuf);
1132	return rc;
1133	}
1134
1135	/**
1136	*
1137	* @param pBuf The socket buffer. This is consumed by this function.
1138	*/
1139	static void vboxNetFltLinuxForwardToIntNet(PVBOXNETFLTINS pThis, struct sk_buff *pBuf)
1140	{
1141	uint32_t fSrc = pBuf->pkt_type == PACKET_OUTGOING ? INTNETTRUNKDIR_HOST : INTNETTRUNKDIR_WIRE;
1142
1143	#ifdef VBOXNETFLT_WITH_GSO
1144	if (skb_is_gso(pBuf))
1145	{
1146	PDMNETWORKGSO GsoCtx;
1147	Log3(("vboxNetFltLinuxForwardToIntNet: skb len=%u data_len=%u truesize=%u next=%p nr_frags=%u gso_size=%u gso_seqs=%u gso_type=%x frag_list=%p pkt_type=%x ip_summed=%d\n",
1148	pBuf->len, pBuf->data_len, pBuf->truesize, pBuf->next, skb_shinfo(pBuf)->nr_frags, skb_shinfo(pBuf)->gso_size, skb_shinfo(pBuf)->gso_segs, skb_shinfo(pBuf)->gso_type, skb_shinfo(pBuf)->frag_list, pBuf->pkt_type, pBuf->ip_summed));
1149	# ifdef VBOXNETFLT_WITH_GSO_RECV
1150	if ( (skb_shinfo(pBuf)->gso_type & (SKB_GSO_UDP \| SKB_GSO_TCPV6 \| SKB_GSO_TCPV4))
1151	&& vboxNetFltLinuxCanForwardAsGso(pThis, pBuf, fSrc, &GsoCtx) )
1152	vboxNetFltLinuxForwardAsGso(pThis, pBuf, fSrc, &GsoCtx);
1153	else
1154	# endif
1155	{
1156	/* Need to segment the packet */
1157	struct sk_buff *pNext;
1158	struct sk_buff pSegment = skb_gso_segment(pBuf, 0 /supported features*/);
1159	if (IS_ERR(pSegment))
1160	{
1161	dev_kfree_skb(pBuf);
1162	LogRel(("VBoxNetFlt: Failed to segment a packet (%d).\n", PTR_ERR(pSegment)));
1163	return;
1164	}
1165
1166	for (; pSegment; pSegment = pNext)
1167	{
1168	Log3(("vboxNetFltLinuxForwardToIntNet: segment len=%u data_len=%u truesize=%u next=%p nr_frags=%u gso_size=%u gso_seqs=%u gso_type=%x frag_list=%p pkt_type=%x\n",
1169	pSegment->len, pSegment->data_len, pSegment->truesize, pSegment->next, skb_shinfo(pSegment)->nr_frags, skb_shinfo(pSegment)->gso_size, skb_shinfo(pSegment)->gso_segs, skb_shinfo(pSegment)->gso_type, skb_shinfo(pSegment)->frag_list, pSegment->pkt_type));
1170	pNext = pSegment->next;
1171	pSegment->next = 0;
1172	vboxNetFltLinuxForwardSegment(pThis, pSegment, fSrc);
1173	}
1174	dev_kfree_skb(pBuf);
1175	}
1176	}
1177	else
1178	#endif /* VBOXNETFLT_WITH_GSO */
1179	{
1180	if (pBuf->ip_summed == CHECKSUM_PARTIAL && pBuf->pkt_type == PACKET_OUTGOING)
1181	{
1182	#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18)
1183	/*
1184	* Try to work around the problem with CentOS 4.7 and 5.2 (2.6.9
1185	* and 2.6.18 kernels), they pass wrong 'h' pointer down. We take IP
1186	* header length from the header itself and reconstruct 'h' pointer
1187	* to TCP (or whatever) header.
1188	*/
1189	unsigned char *tmp = pBuf->h.raw;
1190	if (pBuf->h.raw == pBuf->nh.raw && pBuf->protocol == htons(ETH_P_IP))
1191	pBuf->h.raw = pBuf->nh.raw + pBuf->nh.iph->ihl * 4;
1192	#endif /* LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18) */
1193	if (VBOX_SKB_CHECKSUM_HELP(pBuf))
1194	{
1195	LogRel(("VBoxNetFlt: Failed to compute checksum, dropping the packet.\n"));
1196	dev_kfree_skb(pBuf);
1197	return;
1198	}
1199	#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18)
1200	/* Restore the original (wrong) pointer. */
1201	pBuf->h.raw = tmp;
1202	#endif /* LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18) */
1203	}
1204	vboxNetFltLinuxForwardSegment(pThis, pBuf, fSrc);
1205	}
1206	}
1207
1208	#ifndef VBOXNETFLT_LINUX_NO_XMIT_QUEUE
1209	/**
1210	* Work queue handler that forwards the socket buffers queued by
1211	* vboxNetFltLinuxPacketHandler to the internal network.
1212	*
1213	* @param pWork The work queue.
1214	*/
1215	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
1216	static void vboxNetFltLinuxXmitTask(struct work_struct *pWork)
1217	# else
1218	static void vboxNetFltLinuxXmitTask(void *pWork)
1219	# endif
1220	{
1221	PVBOXNETFLTINS pThis = VBOX_FLT_XT_TO_INST(pWork);
1222	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
1223	struct sk_buff *pBuf;
1224
1225	Log4(("vboxNetFltLinuxXmitTask: Got work %p.\n", pWork));
1226
1227	/*
1228	* Active? Retain the instance and increment the busy counter.
1229	*/
1230	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1231	if (ASMAtomicUoReadBool(&pThis->fActive))
1232	{
1233	vboxNetFltRetain(pThis, true /* fBusy */);
1234	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1235
1236	while ((pBuf = skb_dequeue(&pThis->u.s.XmitQueue)) != NULL)
1237	vboxNetFltLinuxForwardToIntNet(pThis, pBuf);
1238
1239	vboxNetFltRelease(pThis, true /* fBusy */);
1240	}
1241	else
1242	{
1243	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1244	/** @todo Shouldn't we just drop the packets here? There is little point in
1245	* making them accumulate when the VM is paused and it'll only waste
1246	* kernel memory anyway... Hmm. maybe wait a short while (2-5 secs)
1247	* before start draining the packets (goes for the intnet ring buf
1248	* too)? */
1249	}
1250	}
1251	#endif /* !VBOXNETFLT_LINUX_NO_XMIT_QUEUE */
1252
1253	/**
1254	* Reports the GSO capabilites of the hardware NIC.
1255	*
1256	* @param pThis The net filter instance. The caller hold a
1257	* reference to this.
1258	*/
1259	static void vboxNetFltLinuxReportNicGsoCapabilities(PVBOXNETFLTINS pThis)
1260	{
1261	#ifdef VBOXNETFLT_WITH_GSO_XMIT_WIRE
1262	struct net_device *pDev;
1263	PINTNETTRUNKSWPORT pSwitchPort;
1264	unsigned int fFeatures;
1265	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
1266
1267	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1268
1269	pSwitchPort = pThis->pSwitchPort; /* this doesn't need to be here, but it doesn't harm. */
1270	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
1271	if (pDev)
1272	fFeatures = pDev->features;
1273	else
1274	fFeatures = 0;
1275
1276	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1277
1278	if (pThis->pSwitchPort)
1279	{
1280	/* Set/update the GSO capabilities of the NIC. */
1281	uint32_t fGsoCapabilites = 0;
1282	if (fFeatures & NETIF_F_TSO)
1283	fGsoCapabilites \|= RT_BIT_32(PDMNETWORKGSOTYPE_IPV4_TCP);
1284	if (fFeatures & NETIF_F_TSO6)
1285	fGsoCapabilites \|= RT_BIT_32(PDMNETWORKGSOTYPE_IPV6_TCP);
1286	# if 0 /** @todo GSO: Test UDP offloading (UFO) on linux. */
1287	if (fFeatures & NETIF_F_UFO)
1288	fGsoCapabilites \|= RT_BIT_32(PDMNETWORKGSOTYPE_IPV4_UDP);
1289	if (fFeatures & NETIF_F_UFO)
1290	fGsoCapabilites \|= RT_BIT_32(PDMNETWORKGSOTYPE_IPV6_UDP);
1291	# endif
1292	pThis->pSwitchPort->pfnReportGsoCapabilities(pThis->pSwitchPort, fGsoCapabilites, INTNETTRUNKDIR_WIRE);
1293	}
1294	#endif /* VBOXNETFLT_WITH_GSO_XMIT_WIRE */
1295	}
1296
1297	/**
1298	* Helper that determins whether the host (ignoreing us) is operating the
1299	* interface in promiscuous mode or not.
1300	*/
1301	static bool vboxNetFltLinuxPromiscuous(PVBOXNETFLTINS pThis)
1302	{
1303	bool fRc = false;
1304	struct net_device * pDev = vboxNetFltLinuxRetainNetDev(pThis);
1305	if (pDev)
1306	{
1307	fRc = !!(pDev->promiscuity - (ASMAtomicUoReadBool(&pThis->u.s.fPromiscuousSet) & 1));
1308	LogFlow(("vboxNetFltPortOsIsPromiscuous: returns %d, pDev->promiscuity=%d, fPromiscuousSet=%d\n",
1309	fRc, pDev->promiscuity, pThis->u.s.fPromiscuousSet));
1310	vboxNetFltLinuxReleaseNetDev(pThis, pDev);
1311	}
1312	return fRc;
1313	}
1314
1315	/**
1316	* Internal worker for vboxNetFltLinuxNotifierCallback.
1317	*
1318	* @returns VBox status code.
1319	* @param pThis The instance.
1320	* @param fRediscovery If set we're doing a rediscovery attempt, so, don't
1321	* flood the release log.
1322	*/
1323	static int vboxNetFltLinuxAttachToInterface(PVBOXNETFLTINS pThis, struct net_device *pDev)
1324	{
1325	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
1326	LogFlow(("vboxNetFltLinuxAttachToInterface: pThis=%p (%s)\n", pThis, pThis->szName));
1327
1328	/*
1329	* Retain and store the device.
1330	*/
1331	dev_hold(pDev);
1332
1333	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1334	ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, pDev);
1335	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1336
1337	Log(("vboxNetFltLinuxAttachToInterface: Device %p(%s) retained. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
1338	Log(("vboxNetFltLinuxAttachToInterface: Got pDev=%p pThis=%p pThis->u.s.pDev=%p\n", pDev, pThis, ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev)));
1339
1340	/* Get the mac address while we still have a valid net_device reference. */
1341	memcpy(&pThis->u.s.MacAddr, pDev->dev_addr, sizeof(pThis->u.s.MacAddr));
1342
1343	/*
1344	* Install a packet filter for this device with a protocol wildcard (ETH_P_ALL).
1345	*/
1346	pThis->u.s.PacketType.type = __constant_htons(ETH_P_ALL);
1347	pThis->u.s.PacketType.dev = pDev;
1348	pThis->u.s.PacketType.func = vboxNetFltLinuxPacketHandler;
1349	dev_add_pack(&pThis->u.s.PacketType);
1350
1351	#ifdef VBOXNETFLT_WITH_FILTER_HOST2GUEST_SKBS_EXPERIMENT
1352	vboxNetFltLinuxHookDev(pThis, pDev);
1353	#endif
1354
1355	/*
1356	* Set indicators that require the spinlock. Be abit paranoid about racing
1357	* the device notification handle.
1358	*/
1359	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1360	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
1361	if (pDev)
1362	{
1363	ASMAtomicUoWriteBool(&pThis->fDisconnectedFromHost, false);
1364	ASMAtomicUoWriteBool(&pThis->u.s.fRegistered, true);
1365	pDev = NULL; /* don't dereference it */
1366	}
1367	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1368	Log(("vboxNetFltLinuxAttachToInterface: this=%p: Packet handler installed.\n", pThis));
1369
1370	/*
1371	* If the above succeeded report GSO capabilites, if not undo and
1372	* release the device.
1373	*/
1374	if (!pDev)
1375	{
1376	Assert(pThis->pSwitchPort);
1377	vboxNetFltLinuxReportNicGsoCapabilities(pThis);
1378	pThis->pSwitchPort->pfnReportMacAddress(pThis->pSwitchPort, &pThis->u.s.MacAddr);
1379	pThis->pSwitchPort->pfnReportPromiscuousMode(pThis->pSwitchPort, vboxNetFltLinuxPromiscuous(pThis));
1380	}
1381	else
1382	{
1383	#ifdef VBOXNETFLT_WITH_FILTER_HOST2GUEST_SKBS_EXPERIMENT
1384	vboxNetFltLinuxUnhookDev(pThis, pDev);
1385	#endif
1386	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1387	ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, NULL);
1388	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1389	dev_put(pDev);
1390	Log(("vboxNetFltLinuxAttachToInterface: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
1391	}
1392
1393	LogRel(("VBoxNetFlt: attached to '%s' / %.*Rhxs\n", pThis->szName, sizeof(pThis->u.s.MacAddr), &pThis->u.s.MacAddr));
1394	return VINF_SUCCESS;
1395	}
1396
1397
1398	static int vboxNetFltLinuxUnregisterDevice(PVBOXNETFLTINS pThis, struct net_device *pDev)
1399	{
1400	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
1401
1402	Assert(!pThis->fDisconnectedFromHost);
1403
1404	#ifdef VBOXNETFLT_WITH_FILTER_HOST2GUEST_SKBS_EXPERIMENT
1405	vboxNetFltLinuxUnhookDev(pThis, pDev);
1406	#endif
1407
1408	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1409	ASMAtomicWriteBool(&pThis->u.s.fRegistered, false);
1410	ASMAtomicWriteBool(&pThis->fDisconnectedFromHost, true);
1411	ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, NULL);
1412	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1413
1414	dev_remove_pack(&pThis->u.s.PacketType);
1415	#ifndef VBOXNETFLT_LINUX_NO_XMIT_QUEUE
1416	skb_queue_purge(&pThis->u.s.XmitQueue);
1417	#endif
1418	Log(("vboxNetFltLinuxUnregisterDevice: this=%p: Packet handler removed, xmit queue purged.\n", pThis));
1419	Log(("vboxNetFltLinuxUnregisterDevice: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
1420	dev_put(pDev);
1421
1422	return NOTIFY_OK;
1423	}
1424
1425	static int vboxNetFltLinuxDeviceIsUp(PVBOXNETFLTINS pThis, struct net_device *pDev)
1426	{
1427	/* Check if we are not suspended and promiscuous mode has not been set. */
1428	if (ASMAtomicUoReadBool(&pThis->fActive) && !ASMAtomicUoReadBool(&pThis->u.s.fPromiscuousSet))
1429	{
1430	/* Note that there is no need for locking as the kernel got hold of the lock already. */
1431	dev_set_promiscuity(pDev, 1);
1432	ASMAtomicWriteBool(&pThis->u.s.fPromiscuousSet, true);
1433	Log(("vboxNetFltLinuxDeviceIsUp: enabled promiscuous mode on %s (%d)\n", pThis->szName, pDev->promiscuity));
1434	}
1435	else
1436	Log(("vboxNetFltLinuxDeviceIsUp: no need to enable promiscuous mode on %s (%d)\n", pThis->szName, pDev->promiscuity));
1437	return NOTIFY_OK;
1438	}
1439
1440	static int vboxNetFltLinuxDeviceGoingDown(PVBOXNETFLTINS pThis, struct net_device *pDev)
1441	{
1442	/* Undo promiscuous mode if we has set it. */
1443	if (ASMAtomicUoReadBool(&pThis->u.s.fPromiscuousSet))
1444	{
1445	/* Note that there is no need for locking as the kernel got hold of the lock already. */
1446	dev_set_promiscuity(pDev, -1);
1447	ASMAtomicWriteBool(&pThis->u.s.fPromiscuousSet, false);
1448	Log(("vboxNetFltLinuxDeviceGoingDown: disabled promiscuous mode on %s (%d)\n", pThis->szName, pDev->promiscuity));
1449	}
1450	else
1451	Log(("vboxNetFltLinuxDeviceGoingDown: no need to disable promiscuous mode on %s (%d)\n", pThis->szName, pDev->promiscuity));
1452	return NOTIFY_OK;
1453	}
1454
1455	#ifdef LOG_ENABLED
1456	/** Stringify the NETDEV_XXX constants. */
1457	static const char *vboxNetFltLinuxGetNetDevEventName(unsigned long ulEventType)
1458	{
1459	const char *pszEvent = "NETDRV_<unknown>";
1460	switch (ulEventType)
1461	{
1462	case NETDEV_REGISTER: pszEvent = "NETDEV_REGISTER"; break;
1463	case NETDEV_UNREGISTER: pszEvent = "NETDEV_UNREGISTER"; break;
1464	case NETDEV_UP: pszEvent = "NETDEV_UP"; break;
1465	case NETDEV_DOWN: pszEvent = "NETDEV_DOWN"; break;
1466	case NETDEV_REBOOT: pszEvent = "NETDEV_REBOOT"; break;
1467	case NETDEV_CHANGENAME: pszEvent = "NETDEV_CHANGENAME"; break;
1468	case NETDEV_CHANGE: pszEvent = "NETDEV_CHANGE"; break;
1469	case NETDEV_CHANGEMTU: pszEvent = "NETDEV_CHANGEMTU"; break;
1470	case NETDEV_CHANGEADDR: pszEvent = "NETDEV_CHANGEADDR"; break;
1471	case NETDEV_GOING_DOWN: pszEvent = "NETDEV_GOING_DOWN"; break;
1472	# ifdef NETDEV_FEAT_CHANGE
1473	case NETDEV_FEAT_CHANGE: pszEvent = "NETDEV_FEAT_CHANGE"; break;
1474	# endif
1475	}
1476	return pszEvent;
1477	}
1478	#endif /* LOG_ENABLED */
1479
1480	/**
1481	* Callback for listening to netdevice events.
1482	*
1483	* This works the rediscovery, clean up on unregistration, promiscuity on
1484	* up/down, and GSO feature changes from ethtool.
1485	*
1486	* @returns NOTIFY_OK
1487	* @param self Pointer to our notifier registration block.
1488	* @param ulEventType The event.
1489	* @param ptr Event specific, but it is usually the device it
1490	* relates to.
1491	*/
1492	static int vboxNetFltLinuxNotifierCallback(struct notifier_block self, unsigned long ulEventType, void ptr)
1493
1494	{
1495	PVBOXNETFLTINS pThis = VBOX_FLT_NB_TO_INST(self);
1496	struct net_device pDev = (struct net_device )ptr;
1497	int rc = NOTIFY_OK;
1498
1499	Log(("VBoxNetFlt: got event %s(0x%lx) on %s, pDev=%p pThis=%p pThis->u.s.pDev=%p\n",
1500	vboxNetFltLinuxGetNetDevEventName(ulEventType), ulEventType, pDev->name, pDev, pThis, ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev)));
1501	if ( ulEventType == NETDEV_REGISTER
1502	&& !strcmp(pDev->name, pThis->szName))
1503	{
1504	vboxNetFltLinuxAttachToInterface(pThis, pDev);
1505	}
1506	else
1507	{
1508	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
1509	if (pDev == ptr)
1510	{
1511	switch (ulEventType)
1512	{
1513	case NETDEV_UNREGISTER:
1514	rc = vboxNetFltLinuxUnregisterDevice(pThis, pDev);
1515	break;
1516	case NETDEV_UP:
1517	rc = vboxNetFltLinuxDeviceIsUp(pThis, pDev);
1518	break;
1519	case NETDEV_GOING_DOWN:
1520	rc = vboxNetFltLinuxDeviceGoingDown(pThis, pDev);
1521	break;
1522	case NETDEV_CHANGENAME:
1523	break;
1524	#ifdef NETDEV_FEAT_CHANGE
1525	case NETDEV_FEAT_CHANGE:
1526	vboxNetFltLinuxReportNicGsoCapabilities(pThis);
1527	break;
1528	#endif
1529	}
1530	}
1531	}
1532
1533	return rc;
1534	}
1535
1536	bool vboxNetFltOsMaybeRediscovered(PVBOXNETFLTINS pThis)
1537	{
1538	return !ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost);
1539	}
1540
1541	int vboxNetFltPortOsXmit(PVBOXNETFLTINS pThis, PINTNETSG pSG, uint32_t fDst)
1542	{
1543	struct net_device * pDev;
1544	int err;
1545	int rc = VINF_SUCCESS;
1546
1547	LogFlow(("vboxNetFltPortOsXmit: pThis=%p (%s)\n", pThis, pThis->szName));
1548
1549	pDev = vboxNetFltLinuxRetainNetDev(pThis);
1550	if (pDev)
1551	{
1552	/*
1553	* Create a sk_buff for the gather list and push it onto the wire.
1554	*/
1555	if (fDst & INTNETTRUNKDIR_WIRE)
1556	{
1557	struct sk_buff *pBuf = vboxNetFltLinuxSkBufFromSG(pThis, pSG, true);
1558	if (pBuf)
1559	{
1560	vboxNetFltDumpPacket(pSG, true, "wire", 1);
1561	Log4(("vboxNetFltPortOsXmit: pBuf->cb dump:\n%.*Rhxd\n", sizeof(pBuf->cb), pBuf->cb));
1562	Log4(("vboxNetFltPortOsXmit: dev_queue_xmit(%p)\n", pBuf));
1563	err = dev_queue_xmit(pBuf);
1564	if (err)
1565	rc = RTErrConvertFromErrno(err);
1566	}
1567	else
1568	rc = VERR_NO_MEMORY;
1569	}
1570
1571	/*
1572	* Create a sk_buff for the gather list and push it onto the host stack.
1573	*/
1574	if (fDst & INTNETTRUNKDIR_HOST)
1575	{
1576	struct sk_buff *pBuf = vboxNetFltLinuxSkBufFromSG(pThis, pSG, false);
1577	if (pBuf)
1578	{
1579	vboxNetFltDumpPacket(pSG, true, "host", (fDst & INTNETTRUNKDIR_WIRE) ? 0 : 1);
1580	Log4(("vboxNetFltPortOsXmit: pBuf->cb dump:\n%.*Rhxd\n", sizeof(pBuf->cb), pBuf->cb));
1581	Log4(("vboxNetFltPortOsXmit: netif_rx_ni(%p)\n", pBuf));
1582	err = netif_rx_ni(pBuf);
1583	if (err)
1584	rc = RTErrConvertFromErrno(err);
1585	}
1586	else
1587	rc = VERR_NO_MEMORY;
1588	}
1589
1590	vboxNetFltLinuxReleaseNetDev(pThis, pDev);
1591	}
1592
1593	return rc;
1594	}
1595
1596
1597	void vboxNetFltPortOsSetActive(PVBOXNETFLTINS pThis, bool fActive)
1598	{
1599	struct net_device * pDev;
1600
1601	LogFlow(("vboxNetFltPortOsSetActive: pThis=%p (%s), fActive=%s, fDisablePromiscuous=%s\n",
1602	pThis, pThis->szName, fActive?"true":"false",
1603	pThis->fDisablePromiscuous?"true":"false"));
1604
1605	if (pThis->fDisablePromiscuous)
1606	return;
1607
1608	pDev = vboxNetFltLinuxRetainNetDev(pThis);
1609	if (pDev)
1610	{
1611	/*
1612	* This api is a bit weird, the best reference is the code.
1613	*
1614	* Also, we have a bit or race conditions wrt the maintance of
1615	* host the interface promiscuity for vboxNetFltPortOsIsPromiscuous.
1616	*/
1617	#ifdef LOG_ENABLED
1618	u_int16_t fIf;
1619	unsigned const cPromiscBefore = pDev->promiscuity;
1620	#endif
1621	if (fActive)
1622	{
1623	Assert(!pThis->u.s.fPromiscuousSet);
1624
1625	rtnl_lock();
1626	dev_set_promiscuity(pDev, 1);
1627	rtnl_unlock();
1628	pThis->u.s.fPromiscuousSet = true;
1629	Log(("vboxNetFltPortOsSetActive: enabled promiscuous mode on %s (%d)\n", pThis->szName, pDev->promiscuity));
1630	}
1631	else
1632	{
1633	if (pThis->u.s.fPromiscuousSet)
1634	{
1635	rtnl_lock();
1636	dev_set_promiscuity(pDev, -1);
1637	rtnl_unlock();
1638	Log(("vboxNetFltPortOsSetActive: disabled promiscuous mode on %s (%d)\n", pThis->szName, pDev->promiscuity));
1639	}
1640	pThis->u.s.fPromiscuousSet = false;
1641
1642	#ifdef LOG_ENABLED
1643	fIf = dev_get_flags(pDev);
1644	Log(("VBoxNetFlt: fIf=%#x; %d->%d\n", fIf, cPromiscBefore, pDev->promiscuity));
1645	#endif
1646	}
1647
1648	vboxNetFltLinuxReleaseNetDev(pThis, pDev);
1649	}
1650	}
1651
1652
1653	int vboxNetFltOsDisconnectIt(PVBOXNETFLTINS pThis)
1654	{
1655	/* Nothing to do here. */
1656	return VINF_SUCCESS;
1657	}
1658
1659
1660	int vboxNetFltOsConnectIt(PVBOXNETFLTINS pThis)
1661	{
1662	/*
1663	* Report the GSO capabilities of the host and device (if connected).
1664	*/
1665	#if defined(VBOXNETFLT_WITH_GSO_XMIT_HOST)
1666	pThis->pSwitchPort->pfnReportGsoCapabilities(pThis->pSwitchPort,
1667	0
1668	\| RT_BIT_32(PDMNETWORKGSOTYPE_IPV4_TCP)
1669	\| RT_BIT_32(PDMNETWORKGSOTYPE_IPV6_TCP)
1670	# if 0 /** @todo GSO: Test UDP offloading (UFO) on linux. */
1671	\| RT_BIT_32(PDMNETWORKGSOTYPE_IPV4_UDP)
1672	\| RT_BIT_32(PDMNETWORKGSOTYPE_IPV6_UDP)
1673	# endif
1674	, INTNETTRUNKDIR_HOST);
1675
1676	#endif
1677	vboxNetFltLinuxReportNicGsoCapabilities(pThis);
1678
1679	return VINF_SUCCESS;
1680	}
1681
1682
1683	void vboxNetFltOsDeleteInstance(PVBOXNETFLTINS pThis)
1684	{
1685	struct net_device *pDev;
1686	bool fRegistered;
1687	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
1688
1689	#ifdef VBOXNETFLT_WITH_FILTER_HOST2GUEST_SKBS_EXPERIMENT
1690	vboxNetFltLinuxUnhookDev(pThis, NULL);
1691	#endif
1692
1693	/** @todo This code may race vboxNetFltLinuxUnregisterDevice (very very
1694	* unlikely, but none the less). Since it doesn't actually update the
1695	* state (just reads it), it is likely to panic in some interesting
1696	* ways. */
1697
1698	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1699	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
1700	fRegistered = ASMAtomicUoReadBool(&pThis->u.s.fRegistered);
1701	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1702
1703	if (fRegistered)
1704	{
1705	dev_remove_pack(&pThis->u.s.PacketType);
1706	#ifndef VBOXNETFLT_LINUX_NO_XMIT_QUEUE
1707	skb_queue_purge(&pThis->u.s.XmitQueue);
1708	#endif
1709	Log(("vboxNetFltOsDeleteInstance: this=%p: Packet handler removed, xmit queue purged.\n", pThis));
1710	Log(("vboxNetFltOsDeleteInstance: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
1711	dev_put(pDev);
1712	}
1713	Log(("vboxNetFltOsDeleteInstance: this=%p: Notifier removed.\n", pThis));
1714	unregister_netdevice_notifier(&pThis->u.s.Notifier);
1715	module_put(THIS_MODULE);
1716	}
1717
1718
1719	int vboxNetFltOsInitInstance(PVBOXNETFLTINS pThis, void *pvContext)
1720	{
1721	int err;
1722	NOREF(pvContext);
1723
1724	pThis->u.s.Notifier.notifier_call = vboxNetFltLinuxNotifierCallback;
1725	err = register_netdevice_notifier(&pThis->u.s.Notifier);
1726	if (err)
1727	return VERR_INTNET_FLT_IF_FAILED;
1728	if (!pThis->u.s.fRegistered)
1729	{
1730	unregister_netdevice_notifier(&pThis->u.s.Notifier);
1731	LogRel(("VBoxNetFlt: failed to find %s.\n", pThis->szName));
1732	return VERR_INTNET_FLT_IF_NOT_FOUND;
1733	}
1734
1735	Log(("vboxNetFltOsInitInstance: this=%p: Notifier installed.\n", pThis));
1736	if ( pThis->fDisconnectedFromHost
1737	\|\| !try_module_get(THIS_MODULE))
1738	return VERR_INTNET_FLT_IF_FAILED;
1739
1740	return VINF_SUCCESS;
1741	}
1742
1743	int vboxNetFltOsPreInitInstance(PVBOXNETFLTINS pThis)
1744	{
1745	/*
1746	* Init the linux specific members.
1747	*/
1748	pThis->u.s.pDev = NULL;
1749	pThis->u.s.fRegistered = false;
1750	pThis->u.s.fPromiscuousSet = false;
1751	memset(&pThis->u.s.PacketType, 0, sizeof(pThis->u.s.PacketType));
1752	#ifndef VBOXNETFLT_LINUX_NO_XMIT_QUEUE
1753	skb_queue_head_init(&pThis->u.s.XmitQueue);
1754	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
1755	INIT_WORK(&pThis->u.s.XmitTask, vboxNetFltLinuxXmitTask);
1756	# else
1757	INIT_WORK(&pThis->u.s.XmitTask, vboxNetFltLinuxXmitTask, &pThis->u.s.XmitTask);
1758	# endif
1759	#endif
1760
1761	return VINF_SUCCESS;
1762	}
1763

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

source: vbox/trunk/src/VBox/HostDrivers/VBoxNetFlt/linux/VBoxNetFlt-linux.c@ 28703

Download in other formats: