VBoxNetFlt-linux.c@ 19599

最後變更在這個檔案從19599是 19148,由 vboxsync 提交於 16 年前
typo
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 37.7 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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

以其他格式下載: