VBoxNetFlt-linux.c@ 15894

Last change on this file since 15894 was 15894, checked in by vboxsync, 16 years ago
Linux vboxnetflt: remove some warnings with older kernels
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.4 KB

Line
1	/* $Id: VBoxNetFlt-linux.c 15894 2009-01-12 14:17:55Z 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	#include "the-linux-kernel.h"
26	#include "version-generated.h"
27	#include <linux/netdevice.h>
28	#include <linux/etherdevice.h>
29	#include <linux/rtnetlink.h>
30
31	#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
32	#include <VBox/log.h>
33	#include <VBox/err.h>
34	#include <iprt/alloca.h>
35	#include <iprt/assert.h>
36	#include <iprt/spinlock.h>
37	#include <iprt/semaphore.h>
38	#include <iprt/initterm.h>
39	#include <iprt/process.h>
40	#include <iprt/mem.h>
41	#include <iprt/log.h>
42	#include <iprt/mp.h>
43	#include <iprt/mem.h>
44	#include <iprt/time.h>
45
46	#define VBOXNETFLT_OS_SPECFIC 1
47	#include "../VBoxNetFltInternal.h"
48
49	#define VBOX_FLT_NB_TO_INST(pNB) ((PVBOXNETFLTINS)((uint8_t *)pNB - \
50	RT_OFFSETOF(VBOXNETFLTINS, u.s.Notifier)))
51	#define VBOX_FLT_PT_TO_INST(pPT) ((PVBOXNETFLTINS)((uint8_t *)pPT - \
52	RT_OFFSETOF(VBOXNETFLTINS, u.s.PacketType)))
53	#define VBOX_FLT_XT_TO_INST(pXT) ((PVBOXNETFLTINS)((uint8_t *)pXT - \
54	RT_OFFSETOF(VBOXNETFLTINS, u.s.XmitTask)))
55
56	#define VBOX_GET_PCOUNT(pDev) (pDev->promiscuity)
57
58	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
59	# define VBOX_SKB_RESET_NETWORK_HDR(skb) skb_reset_network_header(skb)
60	# define VBOX_SKB_RESET_MAC_HDR(skb) skb_reset_mac_header(skb)
61	#else /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22) */
62	# define VBOX_SKB_RESET_NETWORK_HDR(skb) skb->nh.raw = skb->data
63	# define VBOX_SKB_RESET_MAC_HDR(skb) skb->mac.raw = skb->data
64	#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22) */
65
66	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
67	# define VBOX_SKB_CHECKSUM_HELP(skb) skb_checksum_help(skb)
68	#else /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) */
69	# define CHECKSUM_PARTIAL CHECKSUM_HW
70	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 10)
71	# define VBOX_SKB_CHECKSUM_HELP(skb) skb_checksum_help(skb, 0)
72	# else /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10) */
73	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 7)
74	# define VBOX_SKB_CHECKSUM_HELP(skb) skb_checksum_help(&skb, 0)
75	# else /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 7) */
76	# define VBOX_SKB_CHECKSUM_HELP(skb) (!skb_checksum_help(skb))
77	# endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 7) */
78	# endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10) */
79	#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) */
80
81	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
82	# define VBOX_SKB_IS_GSO(skb) skb_is_gso(skb)
83	/* No features, very dumb device */
84	# define VBOX_SKB_GSO_SEGMENT(skb) skb_gso_segment(skb, 0)
85	#else /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18) */
86	# define VBOX_SKB_IS_GSO(skb) false
87	# define VBOX_SKB_GSO_SEGMENT(skb) NULL
88	#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18) */
89
90	#ifndef NET_IP_ALIGN
91	# define NET_IP_ALIGN 2
92	#endif
93
94	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12)
95	unsigned dev_get_flags(const struct net_device *dev)
96	{
97	unsigned flags;
98
99	flags = (dev->flags & ~(IFF_PROMISC \|
100	IFF_ALLMULTI \|
101	IFF_RUNNING)) \|
102	(dev->gflags & (IFF_PROMISC \|
103	IFF_ALLMULTI));
104
105	if (netif_running(dev) && netif_carrier_ok(dev))
106	flags \|= IFF_RUNNING;
107
108	return flags;
109	}
110	#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12) */
111
112	/*******************************************************************************
113	* Internal Functions *
114	*******************************************************************************/
115	static int VBoxNetFltLinuxInit(void);
116	static void VBoxNetFltLinuxUnload(void);
117
118
119	/*******************************************************************************
120	* Global Variables *
121	*******************************************************************************/
122	/**
123	* The (common) global data.
124	*/
125	static VBOXNETFLTGLOBALS g_VBoxNetFltGlobals;
126
127	module_init(VBoxNetFltLinuxInit);
128	module_exit(VBoxNetFltLinuxUnload);
129
130	MODULE_AUTHOR("Sun Microsystems, Inc.");
131	MODULE_DESCRIPTION("VirtualBox Network Filter Driver");
132	MODULE_LICENSE("GPL");
133	#ifdef MODULE_VERSION
134	# define xstr(s) str(s)
135	# define str(s) #s
136	MODULE_VERSION(VBOX_VERSION_STRING " (" xstr(INTNETTRUNKIFPORT_VERSION) ")");
137	#endif
138
139	/**
140	* The (common) global data.
141	*/
142	static VBOXNETFLTGLOBALS g_VBoxNetFltGlobals;
143
144
145	/**
146	* Initialize module.
147	*
148	* @returns appropriate status code.
149	*/
150	static int __init VBoxNetFltLinuxInit(void)
151	{
152	int rc;
153	Log(("VBoxNetFltLinuxInit\n"));
154
155	/*
156	* Initialize IPRT.
157	*/
158	rc = RTR0Init(0);
159	if (RT_SUCCESS(rc))
160	{
161	/*
162	* Initialize the globals and connect to the support driver.
163	*
164	* This will call back vboxNetFltOsOpenSupDrv (and maybe vboxNetFltOsCloseSupDrv)
165	* for establishing the connect to the support driver.
166	*/
167	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
168	rc = vboxNetFltInitGlobals(&g_VBoxNetFltGlobals);
169	if (RT_SUCCESS(rc))
170	{
171	LogRel(("VBoxNetFlt: Successfully started.\n"));
172	return 0;
173	}
174
175	LogRel(("VBoxNetFlt: failed to initialize device extension (rc=%d)\n", rc));
176	RTR0Term();
177	}
178	else
179	LogRel(("VBoxNetFlt: failed to initialize IPRT (rc=%d)\n", rc));
180
181	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
182	return -RTErrConvertToErrno(rc);
183	}
184
185
186	/**
187	* Unload the module.
188	*
189	* @todo We have to prevent this if we're busy!
190	*/
191	static void __exit VBoxNetFltLinuxUnload(void)
192	{
193	int rc;
194	Log(("VBoxNetFltLinuxUnload\n"));
195	Assert(vboxNetFltCanUnload(&g_VBoxNetFltGlobals));
196
197	/*
198	* Undo the work done during start (in reverse order).
199	*/
200	rc = vboxNetFltTryDeleteGlobals(&g_VBoxNetFltGlobals);
201	AssertRC(rc); NOREF(rc);
202
203	RTR0Term();
204
205	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
206
207	Log(("VBoxNetFltLinuxUnload - done\n"));
208	}
209
210
211	/**
212	* Reads and retains the host interface handle.
213	*
214	* @returns The handle, NULL if detached.
215	* @param pThis
216	*/
217	DECLINLINE(struct net_device *) vboxNetFltLinuxRetainNetDev(PVBOXNETFLTINS pThis)
218	{
219	#if 0
220	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
221	struct net_device *pDev = NULL;
222
223	Log(("vboxNetFltLinuxRetainNetDev\n"));
224	/*
225	* Be careful here to avoid problems racing the detached callback.
226	*/
227	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
228	if (!ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost))
229	{
230	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
231	if (pDev)
232	{
233	dev_hold(pDev);
234	Log(("vboxNetFltLinuxRetainNetDev: Device %p(%s) retained. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
235	}
236	}
237	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
238
239	Log(("vboxNetFltLinuxRetainNetDev - done\n"));
240	return pDev;
241	#else
242	return (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
243	#endif
244	}
245
246
247	/**
248	* Release the host interface handle previously retained
249	* by vboxNetFltLinuxRetainNetDev.
250	*
251	* @param pThis The instance.
252	* @param pDev The vboxNetFltLinuxRetainNetDev
253	* return value, NULL is fine.
254	*/
255	DECLINLINE(void) vboxNetFltLinuxReleaseNetDev(PVBOXNETFLTINS pThis, struct net_device *pDev)
256	{
257	#if 0
258	Log(("vboxNetFltLinuxReleaseNetDev\n"));
259	NOREF(pThis);
260	if (pDev)
261	{
262	dev_put(pDev);
263	Log(("vboxNetFltLinuxReleaseNetDev: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
264	}
265	Log(("vboxNetFltLinuxReleaseNetDev - done\n"));
266	#endif
267	}
268
269	#define VBOXNETFLT_CB_TAG 0xA1C9D7C3
270	#define VBOXNETFLT_SKB_CB(skb) ((uint32_t)&((skb)->cb[0]))
271
272	/**
273	* Checks whether this is an mbuf created by vboxNetFltLinuxMBufFromSG,
274	* i.e. a buffer which we're pushing and should be ignored by the filter callbacks.
275	*
276	* @returns true / false accordingly.
277	* @param pBuf The sk_buff.
278	*/
279	DECLINLINE(bool) vboxNetFltLinuxSkBufIsOur(struct sk_buff *pBuf)
280	{
281	return VBOXNETFLT_SKB_CB(pBuf) == VBOXNETFLT_CB_TAG ;
282	}
283
284
285	/**
286	* Internal worker that create a linux sk_buff for a
287	* (scatter/)gather list.
288	*
289	* @returns Pointer to the sk_buff.
290	* @param pThis The instance.
291	* @param pSG The (scatter/)gather list.
292	*/
293	static struct sk_buff *vboxNetFltLinuxSkBufFromSG(PVBOXNETFLTINS pThis, PINTNETSG pSG, bool fDstWire)
294	{
295	struct sk_buff *pPkt;
296	struct net_device *pDev;
297	/*
298	* Because we're lazy, we will ASSUME that all SGs coming from INTNET
299	* will only contain one single segment.
300	*/
301	if (pSG->cSegsUsed != 1 \|\| pSG->cbTotal != pSG->aSegs[0].cb)
302	{
303	LogRel(("VBoxNetFlt: Dropped multi-segment(%d) packet coming from internal network.\n", pSG->cSegsUsed));
304	return NULL;
305	}
306	if (pSG->cbTotal == 0)
307	{
308	LogRel(("VBoxNetFlt: Dropped empty packet coming from internal network.\n"));
309	return NULL;
310	}
311
312	/*
313	* Allocate a packet and copy over the data.
314	*
315	*/
316	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
317	pPkt = dev_alloc_skb(pSG->cbTotal + NET_IP_ALIGN);
318	if (pPkt)
319	{
320	pPkt->dev = pDev;
321	/* Align IP header on 16-byte boundary: 2 + 14 (ethernet hdr size). */
322	skb_reserve(pPkt, NET_IP_ALIGN);
323	skb_put(pPkt, pSG->cbTotal);
324	memcpy(pPkt->data, pSG->aSegs[0].pv, pSG->cbTotal);
325	/* Set protocol and packet_type fields. */
326	pPkt->protocol = eth_type_trans(pPkt, pDev);
327	pPkt->ip_summed = CHECKSUM_NONE;
328	if (fDstWire)
329	{
330	VBOX_SKB_RESET_NETWORK_HDR(pPkt);
331	/* Restore ethernet header back. */
332	skb_push(pPkt, ETH_HLEN);
333	VBOX_SKB_RESET_MAC_HDR(pPkt);
334	}
335	VBOXNETFLT_SKB_CB(pPkt) = VBOXNETFLT_CB_TAG;
336
337	return pPkt;
338	}
339	else
340	Log(("vboxNetFltLinuxSkBufFromSG: Failed to allocate sk_buff(%u).\n", pSG->cbTotal));
341	pSG->pvUserData = NULL;
342
343	return NULL;
344	}
345
346
347	/**
348	* Initializes a SG list from an sk_buff.
349	*
350	* @returns Number of segments.
351	* @param pThis The instance.
352	* @param pBuf The sk_buff.
353	* @param pSG The SG.
354	* @param pvFrame The frame pointer, optional.
355	* @param cSegs The number of segments allocated for the SG.
356	* This should match the number in the mbuf exactly!
357	* @param fSrc The source of the frame.
358	*/
359	DECLINLINE(void) vboxNetFltLinuxSkBufToSG(PVBOXNETFLTINS pThis, struct sk_buff *pBuf, PINTNETSG pSG, unsigned cSegs, uint32_t fSrc)
360	{
361	int i;
362	NOREF(pThis);
363
364	Assert(!skb_shinfo(pBuf)->frag_list);
365	pSG->pvOwnerData = NULL;
366	pSG->pvUserData = NULL;
367	pSG->pvUserData2 = NULL;
368	pSG->cUsers = 1;
369	pSG->fFlags = INTNETSG_FLAGS_TEMP;
370	pSG->cSegsAlloc = cSegs;
371
372	if (fSrc & INTNETTRUNKDIR_WIRE)
373	{
374	/*
375	* The packet came from wire, ethernet header was removed by device driver.
376	* Restore it.
377	*/
378	skb_push(pBuf, ETH_HLEN);
379	}
380	pSG->cbTotal = pBuf->len;
381	#ifdef VBOXNETFLT_SG_SUPPORT
382	pSG->aSegs[0].cb = skb_headlen(pBuf);
383	pSG->aSegs[0].pv = pBuf->data;
384	pSG->aSegs[0].Phys = NIL_RTHCPHYS;
385
386	for (i = 0; i < skb_shinfo(pBuf)->nr_frags; i++)
387	{
388	skb_frag_t *pFrag = &skb_shinfo(pBuf)->frags[i];
389	pSG->aSegs[i+1].cb = pFrag->size;
390	pSG->aSegs[i+1].pv = kmap(pFrag->page);
391	printk("%p = kmap()\n", pSG->aSegs[i+1].pv);
392	pSG->aSegs[i+1].Phys = NIL_RTHCPHYS;
393	}
394	pSG->cSegsUsed = ++i;
395	#else
396	pSG->aSegs[0].cb = pBuf->len;
397	pSG->aSegs[0].pv = pBuf->data;
398	pSG->aSegs[0].Phys = NIL_RTHCPHYS;
399	pSG->cSegsUsed = i = 1;
400	#endif
401
402
403	#ifdef PADD_RUNT_FRAMES_FROM_HOST
404	/*
405	* Add a trailer if the frame is too small.
406	*
407	* Since we're getting to the packet before it is framed, it has not
408	* yet been padded. The current solution is to add a segment pointing
409	* to a buffer containing all zeros and pray that works for all frames...
410	*/
411	if (pSG->cbTotal < 60 && (fSrc & INTNETTRUNKDIR_HOST))
412	{
413	static uint8_t const s_abZero[128] = {0};
414
415	AssertReturnVoid(i < cSegs);
416
417	pSG->aSegs[i].Phys = NIL_RTHCPHYS;
418	pSG->aSegs[i].pv = (void *)&s_abZero[0];
419	pSG->aSegs[i].cb = 60 - pSG->cbTotal;
420	pSG->cbTotal = 60;
421	pSG->cSegsUsed++;
422	}
423	#endif
424	Log2(("vboxNetFltLinuxSkBufToSG: allocated=%d, segments=%d frags=%d next=%p frag_list=%p pkt_type=%x fSrc=%x\n",
425	pSG->cSegsAlloc, pSG->cSegsUsed, skb_shinfo(pBuf)->nr_frags, pBuf->next, skb_shinfo(pBuf)->frag_list, pBuf->pkt_type, fSrc));
426	for (i = 0; i < pSG->cSegsUsed; i++)
427	Log2(("vboxNetFltLinuxSkBufToSG: #%d: cb=%d pv=%p\n",
428	i, pSG->aSegs[i].cb, pSG->aSegs[i].pv));
429	}
430
431	/**
432	* Packet handler,
433	*
434	* @returns 0 or EJUSTRETURN.
435	* @param pThis The instance.
436	* @param pMBuf The mbuf.
437	* @param pvFrame The start of the frame, optional.
438	* @param fSrc Where the packet (allegedly) comes from, one INTNETTRUNKDIR_* value.
439	* @param eProtocol The protocol.
440	*/
441	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
442	static int vboxNetFltLinuxPacketHandler(struct sk_buff *pBuf,
443	struct net_device *pSkbDev,
444	struct packet_type *pPacketType,
445	struct net_device *pOrigDev)
446	#else
447	static int vboxNetFltLinuxPacketHandler(struct sk_buff *pBuf,
448	struct net_device *pSkbDev,
449	struct packet_type *pPacketType)
450	#endif
451	{
452	PVBOXNETFLTINS pThis;
453	struct net_device *pDev;
454	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
455	Log2(("vboxNetFltLinuxPacketHandler: pBuf=%p pSkbDev=%p pPacketType=%p pOrigDev=%p\n",
456	pBuf, pSkbDev, pPacketType, pOrigDev));
457	#else
458	Log2(("vboxNetFltLinuxPacketHandler: pBuf=%p pSkbDev=%p pPacketType=%p\n",
459	pBuf, pSkbDev, pPacketType));
460	#endif
461	/*
462	* Drop it immediately?
463	*/
464	if (!pBuf)
465	return 0;
466	pThis = VBOX_FLT_PT_TO_INST(pPacketType);
467	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
468	if (pThis->u.s.pDev != pSkbDev)
469	{
470	Log(("vboxNetFltLinuxPacketHandler: Devices do not match, pThis may be wrong! pThis=%p\n", pThis));
471	return 0;
472	}
473
474	if (vboxNetFltLinuxSkBufIsOur(pBuf))
475	{
476	dev_kfree_skb(pBuf);
477	return 0;
478	}
479
480	/* Add the packet to transmit queue and schedule the bottom half. */
481	skb_queue_tail(&pThis->u.s.XmitQueue, pBuf);
482	schedule_work(&pThis->u.s.XmitTask);
483	Log2(("vboxNetFltLinuxPacketHandler: scheduled work %p for sk_buff %p\n",
484	&pThis->u.s.XmitTask, pBuf));
485	/* It does not really matter what we return, it is ignored by the kernel. */
486	return 0;
487	}
488
489	static unsigned vboxNetFltLinuxSGSegments(PVBOXNETFLTINS pThis, struct sk_buff *pBuf)
490	{
491	#ifdef VBOXNETFLT_SG_SUPPORT
492	unsigned cSegs = 1 + skb_shinfo(pBuf)->nr_frags;
493	#else
494	unsigned cSegs = 1;
495	#endif
496	#ifdef PADD_RUNT_FRAMES_FROM_HOST
497	/*
498	* Add a trailer if the frame is too small.
499	*/
500	if (pBuf->len < 60)
501	cSegs++;
502	#endif
503	return cSegs;
504	}
505
506	/* WARNING! This function should only be called after vboxNetFltLinuxSkBufToSG()! */
507	static void vboxNetFltLinuxFreeSkBuff(struct sk_buff *pBuf, PINTNETSG pSG)
508	{
509	#ifdef VBOXNETFLT_SG_SUPPORT
510	int i;
511
512	for (i = 0; i < skb_shinfo(pBuf)->nr_frags; i++)
513	{
514	printk("kunmap(%p)\n", pSG->aSegs[i+1].pv);
515	kunmap(pSG->aSegs[i+1].pv);
516	}
517	#endif
518
519	dev_kfree_skb(pBuf);
520	}
521
522	static int vboxNetFltLinuxForwardSegment(PVBOXNETFLTINS pThis, struct sk_buff *pBuf, uint32_t fSrc)
523	{
524	unsigned cSegs = vboxNetFltLinuxSGSegments(pThis, pBuf);
525	if (cSegs < MAX_SKB_FRAGS)
526	{
527	uint8_t *pTmp;
528	PINTNETSG pSG = (PINTNETSG)alloca(RT_OFFSETOF(INTNETSG, aSegs[cSegs]));
529	if (!pSG)
530	{
531	Log(("VBoxNetFlt: Failed to allocate SG buffer.\n"));
532	return VERR_NO_MEMORY;
533	}
534	vboxNetFltLinuxSkBufToSG(pThis, pBuf, pSG, cSegs, fSrc);
535
536	pTmp = pSG->aSegs[0].pv;
537	Log(("VBoxNetFlt: (int)%02x:%02x:%02x:%02x:%02x:%02x"
538	" <-- (%s)%02x:%02x:%02x:%02x:%02x:%02x (%u bytes)\n",
539	pTmp[0], pTmp[1], pTmp[2], pTmp[3], pTmp[4], pTmp[5],
540	(fSrc & INTNETTRUNKDIR_HOST) ? "host" : "wire",
541	pTmp[6], pTmp[7], pTmp[8], pTmp[9], pTmp[10], pTmp[11],
542	pSG->cbTotal));
543	pThis->pSwitchPort->pfnRecv(pThis->pSwitchPort, pSG, fSrc);
544	Log2(("VBoxNetFlt: Dropping the sk_buff.\n"));
545	vboxNetFltLinuxFreeSkBuff(pBuf, pSG);
546	}
547
548	return VINF_SUCCESS;
549	}
550
551	static void vboxNetFltLinuxForwardToIntNet(PVBOXNETFLTINS pThis, struct sk_buff *pBuf)
552	{
553	uint32_t fSrc = pBuf->pkt_type == PACKET_OUTGOING ? INTNETTRUNKDIR_HOST : INTNETTRUNKDIR_WIRE;
554
555	#ifndef VBOXNETFLT_SG_SUPPORT
556	/*
557	* Get rid of fragmented packets, they cause too much trouble.
558	*/
559	struct sk_buff *pCopy = skb_copy(pBuf, GFP_KERNEL);
560	kfree_skb(pBuf);
561	if (!pCopy)
562	{
563	LogRel(("VBoxNetFlt: Failed to allocate packet buffer, dropping the packet.\n"));
564	return;
565	}
566	pBuf = pCopy;
567	#endif
568
569	if (VBOX_SKB_IS_GSO(pBuf))
570	{
571	/* Need to segment the packet */
572	struct sk_buff pNext, pSegment;
573	//Log2(("vboxNetFltLinuxForwardToIntNet: cb=%u gso_size=%u gso_segs=%u gso_type=%u\n",
574	// pBuf->len, skb_shinfo(pBuf)->gso_size, skb_shinfo(pBuf)->gso_segs, skb_shinfo(pBuf)->gso_type));
575
576	for (pSegment = VBOX_SKB_GSO_SEGMENT(pBuf); pSegment; pSegment = pNext)
577	{
578	pNext = pSegment->next;
579	pSegment->next = 0;
580	vboxNetFltLinuxForwardSegment(pThis, pSegment, fSrc);
581	}
582	dev_kfree_skb(pBuf);
583	}
584	else
585	{
586	if (pBuf->ip_summed == CHECKSUM_PARTIAL)
587	if (VBOX_SKB_CHECKSUM_HELP(pBuf))
588	{
589	LogRel(("VBoxNetFlt: Failed to compute checksum, dropping the packet.\n"));
590	dev_kfree_skb(pBuf);
591	return;
592	}
593	vboxNetFltLinuxForwardSegment(pThis, pBuf, fSrc);
594	}
595	/*
596	* Create a (scatter/)gather list for the sk_buff and feed it to the internal network.
597	*/
598	}
599
600	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
601	static void vboxNetFltLinuxXmitTask(struct work_struct *pWork)
602	#else
603	static void vboxNetFltLinuxXmitTask(void *pWork)
604	#endif
605	{
606	struct sk_buff *pBuf;
607	bool fActive;
608	PVBOXNETFLTINS pThis;
609	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
610
611	Log2(("vboxNetFltLinuxXmitTask: Got work %p.\n", pWork));
612	pThis = VBOX_FLT_XT_TO_INST(pWork);
613	/*
614	* Active? Retain the instance and increment the busy counter.
615	*/
616	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
617	fActive = ASMAtomicUoReadBool(&pThis->fActive);
618	if (fActive)
619	vboxNetFltRetain(pThis, true /* fBusy */);
620	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
621	if (!fActive)
622	return;
623
624	while ((pBuf = skb_dequeue(&pThis->u.s.XmitQueue)) != 0)
625	vboxNetFltLinuxForwardToIntNet(pThis, pBuf);
626
627	vboxNetFltRelease(pThis, true /* fBusy */);
628	}
629
630	/**
631	* Internal worker for vboxNetFltOsInitInstance and vboxNetFltOsMaybeRediscovered.
632	*
633	* @returns VBox status code.
634	* @param pThis The instance.
635	* @param fRediscovery If set we're doing a rediscovery attempt, so, don't
636	* flood the release log.
637	*/
638	static int vboxNetFltLinuxAttachToInterface(PVBOXNETFLTINS pThis, struct net_device *pDev)
639	{
640	struct packet_type *pt;
641	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
642
643	LogFlow(("vboxNetFltLinuxAttachToInterface: pThis=%p (%s)\n", pThis, pThis->szName));
644
645	if (!pDev)
646	{
647	Log(("VBoxNetFlt: failed to find device '%s'\n", pThis->szName));
648	return VERR_INTNET_FLT_IF_NOT_FOUND;
649	}
650
651	dev_hold(pDev);
652	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
653	ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, pDev);
654	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
655
656	Log(("vboxNetFltLinuxAttachToInterface: Device %p(%s) retained. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
657	Log(("vboxNetFltLinuxAttachToInterface: Got pDev=%p pThis=%p pThis->u.s.pDev=%p\n", pDev, pThis, ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev)));
658	/*
659	* Get the mac address while we still have a valid ifnet reference.
660	*/
661	memcpy(&pThis->u.s.Mac, pDev->dev_addr, sizeof(pThis->u.s.Mac));
662
663	pt = &pThis->u.s.PacketType;
664	pt->type = __constant_htons(ETH_P_ALL);
665	pt->dev = pDev;
666	pt->func = vboxNetFltLinuxPacketHandler;
667	dev_add_pack(pt);
668	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
669	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
670	if (pDev)
671	{
672	ASMAtomicUoWriteBool(&pThis->fDisconnectedFromHost, false);
673	ASMAtomicUoWriteBool(&pThis->u.s.fRegistered, true);
674	pDev = NULL; /* don't dereference it */
675	}
676	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
677	Log(("vboxNetFltLinuxAttachToInterface: this=%p: Packet handler installed.\n", pThis));
678
679	/* Release the interface on failure. */
680	if (pDev)
681	{
682	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
683	ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, NULL);
684	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
685	dev_put(pDev);
686	Log(("vboxNetFltLinuxAttachToInterface: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
687	}
688
689	LogRel(("VBoxNetFlt: attached to '%s' / %.*Rhxs\n", pThis->szName, sizeof(pThis->u.s.Mac), &pThis->u.s.Mac));
690	return VINF_SUCCESS;
691	}
692
693
694	static int vboxNetFltLinuxUnregisterDevice(PVBOXNETFLTINS pThis, struct net_device *pDev)
695	{
696	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
697
698	Assert(!pThis->fDisconnectedFromHost);
699	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
700	ASMAtomicWriteBool(&pThis->u.s.fRegistered, false);
701	ASMAtomicWriteBool(&pThis->fDisconnectedFromHost, true);
702	ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, NULL);
703	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
704
705	dev_remove_pack(&pThis->u.s.PacketType);
706	skb_queue_purge(&pThis->u.s.XmitQueue);
707	Log(("vboxNetFltLinuxUnregisterDevice: this=%p: Packet handler removed, xmit queue purged.\n", pThis));
708	Log(("vboxNetFltLinuxUnregisterDevice: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
709	dev_put(pDev);
710
711	return NOTIFY_OK;
712	}
713
714	static int vboxNetFltLinuxDeviceIsUp(PVBOXNETFLTINS pThis, struct net_device *pDev)
715	{
716	/* Check if we are not suspended and promiscuous mode has not been set. */
717	if (ASMAtomicUoReadBool(&pThis->fActive) && !ASMAtomicUoReadBool(&pThis->u.s.fPromiscuousSet))
718	{
719	/* Note that there is no need for locking as the kernel got hold of the lock already. */
720	dev_set_promiscuity(pDev, 1);
721	ASMAtomicWriteBool(&pThis->u.s.fPromiscuousSet, true);
722	Log(("vboxNetFltLinuxDeviceIsUp: enabled promiscuous mode on %s (%d)\n", pThis->szName, VBOX_GET_PCOUNT(pDev)));
723	}
724	else
725	Log(("vboxNetFltLinuxDeviceIsUp: no need to enable promiscuous mode on %s (%d)\n", pThis->szName, VBOX_GET_PCOUNT(pDev)));
726	return NOTIFY_OK;
727	}
728
729	static int vboxNetFltLinuxDeviceGoingDown(PVBOXNETFLTINS pThis, struct net_device *pDev)
730	{
731	/* Undo promiscuous mode if we has set it. */
732	if (ASMAtomicUoReadBool(&pThis->u.s.fPromiscuousSet))
733	{
734	/* Note that there is no need for locking as the kernel got hold of the lock already. */
735	dev_set_promiscuity(pDev, -1);
736	ASMAtomicWriteBool(&pThis->u.s.fPromiscuousSet, false);
737	Log(("vboxNetFltLinuxDeviceGoingDown: disabled promiscuous mode on %s (%d)\n", pThis->szName, VBOX_GET_PCOUNT(pDev)));
738	}
739	else
740	Log(("vboxNetFltLinuxDeviceGoingDown: no need to disable promiscuous mode on %s (%d)\n", pThis->szName, VBOX_GET_PCOUNT(pDev)));
741	return NOTIFY_OK;
742	}
743
744	static int vboxNetFltLinuxNotifierCallback(struct notifier_block self, unsigned long ulEventType, void ptr)
745
746	{
747	int rc = NOTIFY_OK;
748	#ifdef DEBUG
749	char *pszEvent = "<unknown>";
750	#endif
751	struct net_device pDev = (struct net_device )ptr;
752	PVBOXNETFLTINS pThis = VBOX_FLT_NB_TO_INST(self);
753
754	#ifdef DEBUG
755	switch (ulEventType)
756	{
757	case NETDEV_REGISTER: pszEvent = "NETDEV_REGISTER"; break;
758	case NETDEV_UNREGISTER: pszEvent = "NETDEV_UNREGISTER"; break;
759	case NETDEV_UP: pszEvent = "NETDEV_UP"; break;
760	case NETDEV_DOWN: pszEvent = "NETDEV_DOWN"; break;
761	case NETDEV_REBOOT: pszEvent = "NETDEV_REBOOT"; break;
762	case NETDEV_CHANGENAME: pszEvent = "NETDEV_CHANGENAME"; break;
763	case NETDEV_CHANGE: pszEvent = "NETDEV_CHANGE"; break;
764	case NETDEV_CHANGEMTU: pszEvent = "NETDEV_CHANGEMTU"; break;
765	case NETDEV_CHANGEADDR: pszEvent = "NETDEV_CHANGEADDR"; break;
766	case NETDEV_GOING_DOWN: pszEvent = "NETDEV_GOING_DOWN"; break;
767	}
768	Log(("VBoxNetFlt: got event %s(0x%lx) on %s, pDev=%p pThis=%p pThis->u.s.pDev=%p\n",
769	pszEvent, ulEventType, pDev->name, pDev, pThis, ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev)));
770	#endif
771	if (ulEventType == NETDEV_REGISTER && !strcmp(pDev->name, pThis->szName))
772	{
773	vboxNetFltLinuxAttachToInterface(pThis, pDev);
774	}
775	else
776	{
777	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
778	if (pDev != ptr)
779	return NOTIFY_OK;
780	rc = NOTIFY_OK;
781	switch (ulEventType)
782	{
783	case NETDEV_UNREGISTER:
784	rc = vboxNetFltLinuxUnregisterDevice(pThis, pDev);
785	break;
786	case NETDEV_UP:
787	rc = vboxNetFltLinuxDeviceIsUp(pThis, pDev);
788	break;
789	case NETDEV_GOING_DOWN:
790	rc = vboxNetFltLinuxDeviceGoingDown(pThis, pDev);
791	break;
792	case NETDEV_CHANGENAME:
793	break;
794	}
795	}
796
797	return rc;
798	}
799
800	bool vboxNetFltOsMaybeRediscovered(PVBOXNETFLTINS pThis)
801	{
802	return !ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost);
803	}
804
805
806	int vboxNetFltPortOsXmit(PVBOXNETFLTINS pThis, PINTNETSG pSG, uint32_t fDst)
807	{
808	uint8_t *pTmp;
809	struct net_device * pDev;
810	int err;
811	int rc = VINF_SUCCESS;
812
813	LogFlow(("vboxNetFltPortOsXmit: pThis=%p (%s)\n", pThis, pThis->szName));
814
815	pTmp = pSG->aSegs[0].pv;
816
817	pDev = vboxNetFltLinuxRetainNetDev(pThis);
818	if (pDev)
819	{
820	/*
821	* Create a sk_buff for the gather list and push it onto the wire.
822	*/
823	if (fDst & INTNETTRUNKDIR_WIRE)
824	{
825	struct sk_buff *pBuf = vboxNetFltLinuxSkBufFromSG(pThis, pSG, true);
826	if (pBuf)
827	{
828	Log(("VBoxNetFlt: (int)%02x:%02x:%02x:%02x:%02x:%02x"
829	" --> (wire)%02x:%02x:%02x:%02x:%02x:%02x (%u bytes)\n",
830	pTmp[6], pTmp[7], pTmp[8], pTmp[9], pTmp[10], pTmp[11],
831	pTmp[0], pTmp[1], pTmp[2], pTmp[3], pTmp[4], pTmp[5],
832	pSG->cbTotal));
833	err = dev_queue_xmit(pBuf);
834	if (err)
835	rc = RTErrConvertFromErrno(err);
836	}
837	else
838	rc = VERR_NO_MEMORY;
839	}
840
841	/*
842	* Create a sk_buff for the gather list and push it onto the host stack.
843	*/
844	if (fDst & INTNETTRUNKDIR_HOST)
845	{
846	struct sk_buff *pBuf = vboxNetFltLinuxSkBufFromSG(pThis, pSG, false);
847	if (pBuf)
848	{
849	Log(("VBoxNetFlt: (int)%02x:%02x:%02x:%02x:%02x:%02x"
850	" --> (host)%02x:%02x:%02x:%02x:%02x:%02x (%u bytes)\n",
851	pTmp[6], pTmp[7], pTmp[8], pTmp[9], pTmp[10], pTmp[11],
852	pTmp[0], pTmp[1], pTmp[2], pTmp[3], pTmp[4], pTmp[5],
853	pSG->cbTotal));
854	err = netif_rx_ni(pBuf);
855	if (err)
856	rc = RTErrConvertFromErrno(err);
857	}
858	else
859	rc = VERR_NO_MEMORY;
860	}
861
862	vboxNetFltLinuxReleaseNetDev(pThis, pDev);
863	}
864
865	return rc;
866	}
867
868
869	bool vboxNetFltPortOsIsPromiscuous(PVBOXNETFLTINS pThis)
870	{
871	bool fRc = false;
872	struct net_device * pDev = vboxNetFltLinuxRetainNetDev(pThis);
873	if (pDev)
874	{
875	fRc = !!(pDev->promiscuity - (ASMAtomicUoReadBool(&pThis->u.s.fPromiscuousSet) & 1));
876	Log(("vboxNetFltPortOsIsPromiscuous: returns %d, pDev->promiscuity=%d, fPromiscuousSet=%d\n",
877	fRc, pDev->promiscuity, pThis->u.s.fPromiscuousSet));
878	vboxNetFltLinuxReleaseNetDev(pThis, pDev);
879	}
880	return fRc;
881	}
882
883
884	void vboxNetFltPortOsGetMacAddress(PVBOXNETFLTINS pThis, PRTMAC pMac)
885	{
886	*pMac = pThis->u.s.Mac;
887	}
888
889
890	bool vboxNetFltPortOsIsHostMac(PVBOXNETFLTINS pThis, PCRTMAC pMac)
891	{
892	/* ASSUMES that the MAC address never changes. */
893	return pThis->u.s.Mac.au16[0] == pMac->au16[0]
894	&& pThis->u.s.Mac.au16[1] == pMac->au16[1]
895	&& pThis->u.s.Mac.au16[2] == pMac->au16[2];
896	}
897
898
899	void vboxNetFltPortOsSetActive(PVBOXNETFLTINS pThis, bool fActive)
900	{
901	struct net_device * pDev;
902
903	LogFlow(("vboxNetFltPortOsSetActive: pThis=%p (%s), fActive=%s\n",
904	pThis, pThis->szName, fActive?"true":"false"));
905
906	pDev = vboxNetFltLinuxRetainNetDev(pThis);
907	if (pDev)
908	{
909	/*
910	* This api is a bit weird, the best reference is the code.
911	*
912	* Also, we have a bit or race conditions wrt the maintance of
913	* host the interface promiscuity for vboxNetFltPortOsIsPromiscuous.
914	*/
915	u_int16_t fIf;
916	#ifdef LOG_ENABLED
917	unsigned const cPromiscBefore = VBOX_GET_PCOUNT(pDev);
918	#endif
919	if (fActive)
920	{
921	Assert(!pThis->u.s.fPromiscuousSet);
922
923	#if 0
924	/*
925	* Try bring the interface up and running if it's down.
926	*/
927	fIf = dev_get_flags(pDev);
928	if ((fIf & (IFF_UP \| IFF_RUNNING)) != (IFF_UP \| IFF_RUNNING))
929	{
930	rtnl_lock();
931	int err = dev_change_flags(pDev, fIf \| IFF_UP);
932	rtnl_unlock();
933	fIf = dev_get_flags(pDev);
934	}
935
936	/*
937	* Is it already up? If it isn't, leave it to the link event or
938	* we'll upset if_pcount (as stated above, ifnet_set_promiscuous is weird).
939	*/
940	if ((fIf & (IFF_UP \| IFF_RUNNING)) == (IFF_UP \| IFF_RUNNING)
941	&& !ASMAtomicReadBool(&pThis->u.s.fPromiscuousSet))
942	{
943	#endif
944	rtnl_lock();
945	dev_set_promiscuity(pDev, 1);
946	rtnl_unlock();
947	pThis->u.s.fPromiscuousSet = true;
948	Log(("vboxNetFltPortOsSetActive: enabled promiscuous mode on %s (%d)\n", pThis->szName, VBOX_GET_PCOUNT(pDev)));
949	#if 0
950	/* check if it actually worked, this stuff is not always behaving well. */
951	if (!(dev_get_flags(pDev) & IFF_PROMISC))
952	{
953	err = dev_change_flags(pDev, fIf \| IFF_PROMISC);
954	if (!err)
955	Log(("vboxNetFlt: fixed IFF_PROMISC on %s (%d->%d)\n", pThis->szName, cPromiscBefore, VBOX_GET_PCOUNT(pDev)));
956	else
957	Log(("VBoxNetFlt: failed to fix IFF_PROMISC on %s, err=%d (%d->%d)\n",
958	pThis->szName, err, cPromiscBefore, VBOX_GET_PCOUNT(pDev)));
959	}
960	#endif
961	#if 0
962	}
963	else if (!err)
964	Log(("VBoxNetFlt: Waiting for the link to come up... (%d->%d)\n", cPromiscBefore, VBOX_GET_PCOUNT(pDev)));
965	if (err)
966	LogRel(("VBoxNetFlt: Failed to put '%s' into promiscuous mode, err=%d (%d->%d)\n", pThis->szName, err, cPromiscBefore, VBOX_GET_PCOUNT(pDev)));
967	#endif
968	}
969	else
970	{
971	if (pThis->u.s.fPromiscuousSet)
972	{
973	rtnl_lock();
974	dev_set_promiscuity(pDev, -1);
975	rtnl_unlock();
976	Log(("vboxNetFltPortOsSetActive: disabled promiscuous mode on %s (%d)\n", pThis->szName, VBOX_GET_PCOUNT(pDev)));
977	}
978	pThis->u.s.fPromiscuousSet = false;
979
980	fIf = dev_get_flags(pDev);
981	Log(("VBoxNetFlt: fIf=%#x; %d->%d\n", fIf, cPromiscBefore, VBOX_GET_PCOUNT(pDev)));
982	}
983
984	vboxNetFltLinuxReleaseNetDev(pThis, pDev);
985	}
986	}
987
988
989	int vboxNetFltOsDisconnectIt(PVBOXNETFLTINS pThis)
990	{
991	/* Nothing to do here. */
992	return VINF_SUCCESS;
993	}
994
995
996	int vboxNetFltOsConnectIt(PVBOXNETFLTINS pThis)
997	{
998	/* Nothing to do here. */
999	return VINF_SUCCESS;
1000	}
1001
1002
1003	void vboxNetFltOsDeleteInstance(PVBOXNETFLTINS pThis)
1004	{
1005	struct net_device *pDev;
1006	bool fRegistered;
1007	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
1008
1009	RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
1010	pDev = (struct net_device )ASMAtomicUoReadPtr((void volatile *)&pThis->u.s.pDev);
1011	fRegistered = ASMAtomicUoReadBool(&pThis->u.s.fRegistered);
1012	RTSpinlockRelease(pThis->hSpinlock, &Tmp);
1013	if (fRegistered)
1014	{
1015	dev_remove_pack(&pThis->u.s.PacketType);
1016	skb_queue_purge(&pThis->u.s.XmitQueue);
1017	Log(("vboxNetFltOsDeleteInstance: this=%p: Packet handler removed, xmit queue purged.\n", pThis));
1018	Log(("vboxNetFltOsDeleteInstance: Device %p(%s) released. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
1019	dev_put(pDev);
1020	}
1021	Log(("vboxNetFltOsDeleteInstance: this=%p: Notifier removed.\n", pThis));
1022	unregister_netdevice_notifier(&pThis->u.s.Notifier);
1023	}
1024
1025
1026	int vboxNetFltOsInitInstance(PVBOXNETFLTINS pThis)
1027	{
1028	int err;
1029	pThis->u.s.Notifier.notifier_call = vboxNetFltLinuxNotifierCallback;
1030	err = register_netdevice_notifier(&pThis->u.s.Notifier);
1031	if (err)
1032	return VERR_INTNET_FLT_IF_FAILED;
1033	if (!pThis->u.s.fRegistered)
1034	{
1035	unregister_netdevice_notifier(&pThis->u.s.Notifier);
1036	LogRel(("VBoxNetFlt: failed to find %s.\n", pThis->szName));
1037	return VERR_INTNET_FLT_IF_NOT_FOUND;
1038	}
1039	Log(("vboxNetFltOsInitInstance: this=%p: Notifier installed.\n", pThis));
1040	return pThis->fDisconnectedFromHost ? VERR_INTNET_FLT_IF_FAILED : VINF_SUCCESS;
1041	}
1042
1043	int vboxNetFltOsPreInitInstance(PVBOXNETFLTINS pThis)
1044	{
1045	/*
1046	* Init the linux specific members.
1047	*/
1048	pThis->u.s.pDev = NULL;
1049	pThis->u.s.fRegistered = false;
1050	pThis->u.s.fPromiscuousSet = false;
1051	memset(&pThis->u.s.PacketType, 0, sizeof(pThis->u.s.PacketType));
1052	skb_queue_head_init(&pThis->u.s.XmitQueue);
1053	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
1054	INIT_WORK(&pThis->u.s.XmitTask, vboxNetFltLinuxXmitTask);
1055	#else
1056	INIT_WORK(&pThis->u.s.XmitTask, vboxNetFltLinuxXmitTask, &pThis->u.s.XmitTask);
1057	#endif
1058
1059	return VINF_SUCCESS;
1060	}
1061

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

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

Download in other formats: