VBoxNetFlt.c@ 43417

Last change on this file since 43417 was 40806, checked in by vboxsync, 13 years ago
RTSpinlock: Redid the interface, eliminating NoInts and Tmp. Whether a spinlock is interrupt safe or not is now defined at creation time, preventing stupid bugs arrising from calling the wrong acquire and/or release methods somewhere. The saved flags are stored in the spinlock strucutre, eliminating the annoying Tmp variable. Needs testing on each platform before fixing the build burn.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 54.9 KB

Line
1	/* $Id: VBoxNetFlt.c 40806 2012-04-06 21:05:19Z vboxsync $ */
2	/** @file
3	* VBoxNetFlt - Network Filter Driver (Host), Common Code.
4	*/
5
6	/*
7	* Copyright (C) 2008-2009 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/** @page pg_netflt VBoxNetFlt - Network Interface Filter
19	*
20	* This is a kernel module that attaches to a real interface on the host and
21	* filters and injects packets.
22	*
23	* In the big picture we're one of the three trunk interface on the internal
24	* network, the one named "NIC Filter Driver": @image html Networking_Overview.gif
25	*
26	*
27	* @section sec_netflt_locking Locking and Potential Races
28	*
29	* The main challenge here is to make sure the netfilter and internal network
30	* instances won't be destroyed while someone is calling into them.
31	*
32	* The main calls into or out of of the filter driver are:
33	* - Send.
34	* - Async send completion (not implemented yet)
35	* - Release by the internal network.
36	* - Receive.
37	* - Disappearance of the host networking interface.
38	* - Reappearance of the host networking interface.
39	*
40	* The latter two calls are can be caused by driver unloading/loading or the
41	* device being physical unplugged (e.g. a USB network device). Actually, the
42	* unload scenario must fervently be prevent as it will cause panics because the
43	* internal network will assume the trunk is around until it releases it.
44	* @todo Need to figure which host allow unloading and block/fix it.
45	*
46	* Currently the netfilter instance lives until the internal network releases
47	* it. So, it is the internal networks responsibility to make sure there are no
48	* active calls when it releases the trunk and destroys the network. The
49	* netfilter assists in this by providing INTNETTRUNKIFPORT::pfnSetState and
50	* INTNETTRUNKIFPORT::pfnWaitForIdle. The trunk state is used to enable/disable
51	* promiscuous mode on the hardware NIC (or similar activation) as well
52	* indicating that disconnect is imminent and no further calls shall be made
53	* into the internal network. After changing the state to disconnecting and
54	* prior to invoking INTNETTRUNKIFPORT::pfnDisconnectAndRelease, the internal
55	* network will use INTNETTRUNKIFPORT::pfnWaitForIdle to wait for any still
56	* active calls to complete.
57	*
58	* The netfilter employs a busy counter and an internal state in addition to the
59	* public trunk state. All these variables are protected using a spinlock.
60	*
61	*
62	* @section sec_netflt_msc Locking / Sequence Diagrams - OBSOLETE
63	*
64	* !OBSOLETE! - THIS WAS THE OLD APPROACH!
65	*
66	* This secion contains a few sequence diagrams describing the problematic
67	* transitions of a host interface filter instance.
68	*
69	* The thing that makes it all a bit problematic is that multiple events may
70	* happen at the same time, and that we have to be very careful to avoid
71	* deadlocks caused by mixing our locks with the ones in the host kernel. The
72	* main events are receive, send, async send completion, disappearance of the
73	* host networking interface and its reappearance. The latter two events are
74	* can be caused by driver unloading/loading or the device being physical
75	* unplugged (e.g. a USB network device).
76	*
77	* The strategy for dealing with these issues are:
78	* - Use a simple state machine.
79	* - Require the user (IntNet) to serialize all its calls to us,
80	* while at the same time not owning any lock used by any of the
81	* the callbacks we might call on receive and async send completion.
82	* - Make sure we're 100% idle before disconnecting, and have a
83	* disconnected status on both sides to fend off async calls.
84	* - Protect the host specific interface handle and the state variables
85	* using a spinlock.
86	*
87	*
88	* @subsection subsec_netflt_msc_dis_rel Disconnect from the network and release - OBSOLETE
89	*
90	* @msc
91	* VM, IntNet, NetFlt, Kernel, Wire;
92	*
93	* VM->IntNet [label="pkt0", linecolor="green", textcolor="green"];
94	* IntNet=>IntNet [label="Lock Network", linecolor="green", textcolor="green" ];
95	* IntNet=>IntNet [label="Route packet -> wire", linecolor="green", textcolor="green" ];
96	* IntNet=>IntNet [label="Unlock Network", linecolor="green", textcolor="green" ];
97	* IntNet=>NetFlt [label="pkt0 to wire", linecolor="green", textcolor="green" ];
98	* NetFlt=>Kernel [label="pkt0 to wire", linecolor="green", textcolor="green"];
99	* Kernel->Wire [label="pkt0 to wire", linecolor="green", textcolor="green"];
100	*
101	* --- [label="Suspending the trunk interface"];
102	* IntNet=>IntNet [label="Lock Network"];
103	*
104	* Wire->Kernel [label="pkt1 - racing us", linecolor="red", textcolor="red"];
105	* Kernel=>>NetFlt [label="pkt1 - racing us", linecolor="red", textcolor="red"];
106	* NetFlt=>>IntNet [label="pkt1 recv - blocks", linecolor="red", textcolor="red"];
107	*
108	* IntNet=>IntNet [label="Mark Trunk Suspended"];
109	* IntNet=>IntNet [label="Unlock Network"];
110	*
111	* IntNet=>NetFlt [label="pfnSetActive(false)"];
112	* NetFlt=>NetFlt [label="Mark inactive (atomic)"];
113	* IntNet<<NetFlt;
114	* IntNet=>NetFlt [label="pfnWaitForIdle(forever)"];
115	*
116	* IntNet=>>NetFlt [label="pkt1 to host", linecolor="red", textcolor="red"];
117	* NetFlt=>>Kernel [label="pkt1 to host", linecolor="red", textcolor="red"];
118	*
119	* Kernel<-Wire [label="pkt0 on wire", linecolor="green", textcolor="green"];
120	* NetFlt<<Kernel [label="pkt0 on wire", linecolor="green", textcolor="green"];
121	* IntNet<<=NetFlt [label="pfnSGRelease", linecolor="green", textcolor="green"];
122	* IntNet<<=IntNet [label="Lock Net, free SG, Unlock Net", linecolor="green", textcolor="green"];
123	* IntNet>>NetFlt [label="pfnSGRelease", linecolor="green", textcolor="green"];
124	* NetFlt<-NetFlt [label="idle", linecolor="green", textcolor="green"];
125	*
126	* IntNet<<NetFlt [label="idle (pfnWaitForIdle)"];
127	*
128	* Wire->Kernel [label="pkt2", linecolor="red", textcolor="red"];
129	* Kernel=>>NetFlt [label="pkt2", linecolor="red", textcolor="red"];
130	* NetFlt=>>Kernel [label="pkt2 to host", linecolor="red", textcolor="red"];
131	*
132	* VM->IntNet [label="pkt3", linecolor="green", textcolor="green"];
133	* IntNet=>IntNet [label="Lock Network", linecolor="green", textcolor="green" ];
134	* IntNet=>IntNet [label="Route packet -> drop", linecolor="green", textcolor="green" ];
135	* IntNet=>IntNet [label="Unlock Network", linecolor="green", textcolor="green" ];
136	*
137	* --- [label="The trunk interface is idle now, disconnect it"];
138	* IntNet=>IntNet [label="Lock Network"];
139	* IntNet=>IntNet [label="Unlink Trunk"];
140	* IntNet=>IntNet [label="Unlock Network"];
141	* IntNet=>NetFlt [label="pfnDisconnectAndRelease"];
142	* NetFlt=>Kernel [label="iflt_detach"];
143	* NetFlt<<=Kernel [label="iff_detached"];
144	* NetFlt>>Kernel [label="iff_detached"];
145	* NetFlt<<Kernel [label="iflt_detach"];
146	* NetFlt=>NetFlt [label="Release"];
147	* IntNet<<NetFlt [label="pfnDisconnectAndRelease"];
148	*
149	* @endmsc
150	*
151	*
152	*
153	* @subsection subsec_netflt_msc_hif_rm Host Interface Removal - OBSOLETE
154	*
155	* The ifnet_t (pIf) is a tricky customer as any reference to it can potentially
156	* race the filter detaching. The simple way of solving it on Darwin is to guard
157	* all access to the pIf member with a spinlock. The other host systems will
158	* probably have similar race conditions, so the spinlock is a generic thing.
159	*
160	* @msc
161	* VM, IntNet, NetFlt, Kernel;
162	*
163	* VM->IntNet [label="pkt0", linecolor="green", textcolor="green"];
164	* IntNet=>IntNet [label="Lock Network", linecolor="green", textcolor="green" ];
165	* IntNet=>IntNet [label="Route packet -> wire", linecolor="green", textcolor="green" ];
166	* IntNet=>IntNet [label="Unlock Network", linecolor="green", textcolor="green" ];
167	* IntNet=>NetFlt [label="pkt0 to wire", linecolor="green", textcolor="green" ];
168	* NetFlt=>Kernel [label="ifnet_reference w/ spinlock", linecolor="green", textcolor="green" ];
169	* NetFlt<<Kernel [label="ifnet_reference", linecolor="green", textcolor="green" ];
170	* NetFlt=>Kernel [label="pkt0 to wire (blocks)", linecolor="green", textcolor="green" ];
171	*
172	* --- [label="The host interface is being disconnected"];
173	* Kernel->NetFlt [label="iff_detached"];
174	* NetFlt=>Kernel [label="ifnet_release w/ spinlock"];
175	* NetFlt<<Kernel [label="ifnet_release"];
176	* NetFlt=>NetFlt [label="fDisconnectedFromHost=true"];
177	* NetFlt>>Kernel [label="iff_detached"];
178	*
179	* NetFlt<<Kernel [label="dropped", linecolor="green", textcolor="green"];
180	* NetFlt=>NetFlt [label="Acquire spinlock", linecolor="green", textcolor="green"];
181	* NetFlt=>Kernel [label="ifnet_release", linecolor="green", textcolor="green"];
182	* NetFlt<<Kernel [label="ifnet_release", linecolor="green", textcolor="green"];
183	* NetFlt=>NetFlt [label="pIf=NULL", linecolor="green", textcolor="green"];
184	* NetFlt=>NetFlt [label="Release spinlock", linecolor="green", textcolor="green"];
185	* IntNet<=NetFlt [label="pfnSGRelease", linecolor="green", textcolor="green"];
186	* IntNet>>NetFlt [label="pfnSGRelease", linecolor="green", textcolor="green"];
187	* IntNet<<NetFlt [label="pkt0 to wire", linecolor="green", textcolor="green"];
188	*
189	* @endmsc
190	*
191	*
192	*
193	* @subsection subsec_netflt_msc_hif_rm Host Interface Rediscovery - OBSOLETE
194	*
195	* The rediscovery is performed when we receive a send request and a certain
196	* period have elapsed since the last attempt, i.e. we're polling it. We
197	* synchronize the rediscovery with disconnection from the internal network
198	* by means of the pfnWaitForIdle call, so no special handling is required.
199	*
200	* @msc
201	* VM2, VM1, IntNet, NetFlt, Kernel, Wire;
202	*
203	* --- [label="Rediscovery conditions are not met"];
204	* VM1->IntNet [label="pkt0"];
205	* IntNet=>IntNet [label="Lock Network"];
206	* IntNet=>IntNet [label="Route packet -> wire"];
207	* IntNet=>IntNet [label="Unlock Network"];
208	* IntNet=>NetFlt [label="pkt0 to wire"];
209	* NetFlt=>NetFlt [label="Read pIf(==NULL) w/ spinlock"];
210	* IntNet<<NetFlt [label="pkt0 to wire (dropped)"];
211	*
212	* --- [label="Rediscovery conditions"];
213	* VM1->IntNet [label="pkt1"];
214	* IntNet=>IntNet [label="Lock Network"];
215	* IntNet=>IntNet [label="Route packet -> wire"];
216	* IntNet=>IntNet [label="Unlock Network"];
217	* IntNet=>NetFlt [label="pkt1 to wire"];
218	* NetFlt=>NetFlt [label="Read pIf(==NULL) w/ spinlock"];
219	* NetFlt=>NetFlt [label="fRediscoveryPending=true w/ spinlock"];
220	* NetFlt=>Kernel [label="ifnet_find_by_name"];
221	* NetFlt<<Kernel [label="ifnet_find_by_name (success)"];
222	*
223	* VM2->IntNet [label="pkt2", linecolor="red", textcolor="red"];
224	* IntNet=>IntNet [label="Lock Network", linecolor="red", textcolor="red"];
225	* IntNet=>IntNet [label="Route packet -> wire", linecolor="red", textcolor="red"];
226	* IntNet=>IntNet [label="Unlock Network", linecolor="red", textcolor="red"];
227	* IntNet=>NetFlt [label="pkt2 to wire", linecolor="red", textcolor="red"];
228	* NetFlt=>NetFlt [label="!pIf \|\| fRediscoveryPending (w/ spinlock)", linecolor="red", textcolor="red"];
229	* IntNet<<NetFlt [label="pkt2 to wire (dropped)", linecolor="red", textcolor="red"];
230
231	* NetFlt=>Kernel [label="iflt_attach"];
232	* NetFlt<<Kernel [label="iflt_attach (success)"];
233	* NetFlt=>NetFlt [label="Acquire spinlock"];
234	* NetFlt=>NetFlt [label="Set pIf and update flags"];
235	* NetFlt=>NetFlt [label="Release spinlock"];
236	*
237	* NetFlt=>Kernel [label="pkt1 to wire"];
238	* Kernel->Wire [label="pkt1 to wire"];
239	* NetFlt<<Kernel [label="pkt1 to wire"];
240	* IntNet<<NetFlt [label="pkt1 to wire"];
241	*
242	*
243	* @endmsc
244	*
245	*/
246
247	/*******************************************************************************
248	* Header Files *
249	*******************************************************************************/
250	#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
251	#include "VBoxNetFltInternal.h"
252
253	#include <VBox/sup.h>
254	#include <VBox/log.h>
255	#include <VBox/err.h>
256	#include <iprt/assert.h>
257	#include <iprt/string.h>
258	#include <iprt/spinlock.h>
259	#include <iprt/uuid.h>
260	#include <iprt/mem.h>
261	#include <iprt/time.h>
262	#include <iprt/semaphore.h>
263	#include <iprt/thread.h>
264
265
266	/*******************************************************************************
267	* Defined Constants And Macros *
268	*******************************************************************************/
269	#define IFPORT_2_VBOXNETFLTINS(pIfPort) \
270	( (PVBOXNETFLTINS)((uint8_t *)pIfPort - RT_OFFSETOF(VBOXNETFLTINS, MyPort)) )
271
272
273	AssertCompileMemberSize(VBOXNETFLTINS, enmState, sizeof(uint32_t));
274
275	/**
276	* Sets the enmState member atomically.
277	*
278	* Used for all updates.
279	*
280	* @param pThis The instance.
281	* @param enmNewState The new value.
282	*/
283	DECLINLINE(void) vboxNetFltSetState(PVBOXNETFLTINS pThis, VBOXNETFTLINSSTATE enmNewState)
284	{
285	ASMAtomicWriteU32((uint32_t volatile *)&pThis->enmState, enmNewState);
286	}
287
288
289	/**
290	* Gets the enmState member atomically.
291	*
292	* Used for all reads.
293	*
294	* @returns The enmState value.
295	* @param pThis The instance.
296	*/
297	DECLINLINE(VBOXNETFTLINSSTATE) vboxNetFltGetState(PVBOXNETFLTINS pThis)
298	{
299	return (VBOXNETFTLINSSTATE)ASMAtomicUoReadU32((uint32_t volatile *)&pThis->enmState);
300	}
301
302
303	/**
304	* Finds a instance by its name, the caller does the locking.
305	*
306	* @returns Pointer to the instance by the given name. NULL if not found.
307	* @param pGlobals The globals.
308	* @param pszName The name of the instance.
309	*/
310	static PVBOXNETFLTINS vboxNetFltFindInstanceLocked(PVBOXNETFLTGLOBALS pGlobals, const char *pszName)
311	{
312	PVBOXNETFLTINS pCur;
313	for (pCur = pGlobals->pInstanceHead; pCur; pCur = pCur->pNext)
314	if (!strcmp(pszName, pCur->szName))
315	return pCur;
316	return NULL;
317	}
318
319
320	/**
321	* Finds a instance by its name, will request the mutex.
322	*
323	* No reference to the instance is retained, we're assuming the caller to
324	* already have one but just for some reason doesn't have the pointer to it.
325	*
326	* @returns Pointer to the instance by the given name. NULL if not found.
327	* @param pGlobals The globals.
328	* @param pszName The name of the instance.
329	*/
330	DECLHIDDEN(PVBOXNETFLTINS) vboxNetFltFindInstance(PVBOXNETFLTGLOBALS pGlobals, const char *pszName)
331	{
332	PVBOXNETFLTINS pRet;
333	int rc = RTSemFastMutexRequest(pGlobals->hFastMtx);
334	AssertRCReturn(rc, NULL);
335
336	pRet = vboxNetFltFindInstanceLocked(pGlobals, pszName);
337
338	rc = RTSemFastMutexRelease(pGlobals->hFastMtx);
339	AssertRC(rc);
340	return pRet;
341	}
342
343
344	/**
345	* Unlinks an instance from the chain.
346	*
347	* @param pGlobals The globals.
348	* @param pToUnlink The instance to unlink.
349	*/
350	static void vboxNetFltUnlinkLocked(PVBOXNETFLTGLOBALS pGlobals, PVBOXNETFLTINS pToUnlink)
351	{
352	if (pGlobals->pInstanceHead == pToUnlink)
353	pGlobals->pInstanceHead = pToUnlink->pNext;
354	else
355	{
356	PVBOXNETFLTINS pCur;
357	for (pCur = pGlobals->pInstanceHead; pCur; pCur = pCur->pNext)
358	if (pCur->pNext == pToUnlink)
359	{
360	pCur->pNext = pToUnlink->pNext;
361	break;
362	}
363	Assert(pCur);
364	}
365	pToUnlink->pNext = NULL;
366	}
367
368
369	/**
370	* Performs interface rediscovery if it was disconnected from the host.
371	*
372	* @returns true if successfully rediscovered and connected, false if not.
373	* @param pThis The instance.
374	*/
375	static bool vboxNetFltMaybeRediscovered(PVBOXNETFLTINS pThis)
376	{
377	uint64_t Now;
378	bool fRediscovered;
379	bool fDoIt;
380
381	/*
382	* Don't do rediscovery if we're called with preemption disabled.
383	*
384	* Note! This may cause trouble if we're always called with preemption
385	* disabled and vboxNetFltOsMaybeRediscovered actually does some real
386	* work. For the time being though, only Darwin and FreeBSD depends
387	* on these call outs and neither supports sending with preemption
388	* disabled.
389	*/
390	if (!RTThreadPreemptIsEnabled(NIL_RTTHREAD))
391	return false;
392
393	/*
394	* Rediscovered already? Time to try again?
395	*/
396	Now = RTTimeNanoTS();
397	RTSpinlockAcquire(pThis->hSpinlock);
398
399	fRediscovered = !ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost);
400	fDoIt = !fRediscovered
401	&& !ASMAtomicUoReadBool(&pThis->fRediscoveryPending)
402	&& Now - ASMAtomicUoReadU64(&pThis->NanoTSLastRediscovery) > UINT64_C(5000000000); /* 5 sec */
403	if (fDoIt)
404	ASMAtomicWriteBool(&pThis->fRediscoveryPending, true);
405
406	RTSpinlockReleaseNoInts(pThis->hSpinlock);
407
408	/*
409	* Call the OS specific code to do the job.
410	* Update the state when the call returns, that is everything except for
411	* the fDisconnectedFromHost flag which the OS specific code shall set.
412	*/
413	if (fDoIt)
414	{
415	fRediscovered = vboxNetFltOsMaybeRediscovered(pThis);
416
417	Assert(!fRediscovered \|\| !ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost));
418
419	ASMAtomicUoWriteU64(&pThis->NanoTSLastRediscovery, RTTimeNanoTS());
420	ASMAtomicWriteBool(&pThis->fRediscoveryPending, false);
421
422	if (fRediscovered)
423	/** @todo this isn't 100% serialized. */
424	vboxNetFltPortOsSetActive(pThis, pThis->enmTrunkState == INTNETTRUNKIFSTATE_ACTIVE);
425	}
426
427	return fRediscovered;
428	}
429
430
431	/**
432	* @copydoc INTNETTRUNKIFPORT::pfnXmit
433	*/
434	static DECLCALLBACK(int) vboxNetFltPortXmit(PINTNETTRUNKIFPORT pIfPort, void *pvIfData, PINTNETSG pSG, uint32_t fDst)
435	{
436	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
437	int rc = VINF_SUCCESS;
438
439	/*
440	* Input validation.
441	*/
442	AssertPtr(pThis);
443	AssertPtr(pSG);
444	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
445	AssertReturn(vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Connected, VERR_INVALID_STATE);
446
447	/*
448	* Do a busy retain and then make sure we're connected to the interface
449	* before invoking the OS specific code.
450	*/
451	if (RT_LIKELY(vboxNetFltTryRetainBusyActive(pThis)))
452	{
453	if ( !ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost)
454	\|\| vboxNetFltMaybeRediscovered(pThis))
455	rc = vboxNetFltPortOsXmit(pThis, pvIfData, pSG, fDst);
456	vboxNetFltRelease(pThis, true /* fBusy */);
457	}
458
459	return rc;
460	}
461
462
463	/**
464	* @copydoc INTNETTRUNKIFPORT::pfnWaitForIdle
465	*/
466	static DECLCALLBACK(int) vboxNetFltPortWaitForIdle(PINTNETTRUNKIFPORT pIfPort, uint32_t cMillies)
467	{
468	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
469	int rc;
470
471	/*
472	* Input validation.
473	*/
474	AssertPtr(pThis);
475	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
476	AssertReturn(vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Connected, VERR_INVALID_STATE);
477	AssertReturn(pThis->enmTrunkState == INTNETTRUNKIFSTATE_DISCONNECTING, VERR_INVALID_STATE);
478
479	/*
480	* Go to sleep on the semaphore after checking the busy count.
481	*/
482	vboxNetFltRetain(pThis, false /* fBusy */);
483
484	rc = VINF_SUCCESS;
485	while (pThis->cBusy && RT_SUCCESS(rc))
486	rc = RTSemEventWait(pThis->hEventIdle, cMillies); /** @todo make interruptible? */
487
488	vboxNetFltRelease(pThis, false /* fBusy */);
489
490	return rc;
491	}
492
493
494	/**
495	* @copydoc INTNETTRUNKIFPORT::pfnSetState
496	*/
497	static DECLCALLBACK(INTNETTRUNKIFSTATE) vboxNetFltPortSetState(PINTNETTRUNKIFPORT pIfPort, INTNETTRUNKIFSTATE enmState)
498	{
499	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
500	INTNETTRUNKIFSTATE enmOldTrunkState;
501
502	/*
503	* Input validation.
504	*/
505	AssertPtr(pThis);
506	AssertPtr(pThis->pGlobals);
507	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
508	AssertReturn(vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Connected, INTNETTRUNKIFSTATE_INVALID);
509	AssertReturn(enmState > INTNETTRUNKIFSTATE_INVALID && enmState < INTNETTRUNKIFSTATE_END,
510	INTNETTRUNKIFSTATE_INVALID);
511
512	/*
513	* Take the lock and change the state.
514	*/
515	RTSpinlockAcquire(pThis->hSpinlock);
516	enmOldTrunkState = pThis->enmTrunkState;
517	if (enmOldTrunkState != enmState)
518	ASMAtomicWriteU32((uint32_t volatile *)&pThis->enmTrunkState, enmState);
519	RTSpinlockReleaseNoInts(pThis->hSpinlock);
520
521	/*
522	* If the state change indicates that the trunk has become active or
523	* inactive, call the OS specific part so they can work the promiscuous
524	* settings and such.
525	* Note! The caller makes sure there are no concurrent pfnSetState calls.
526	*/
527	if ((enmOldTrunkState == INTNETTRUNKIFSTATE_ACTIVE) != (enmState == INTNETTRUNKIFSTATE_ACTIVE))
528	vboxNetFltPortOsSetActive(pThis, (enmState == INTNETTRUNKIFSTATE_ACTIVE));
529
530	return enmOldTrunkState;
531	}
532
533
534	/**
535	* @copydoc INTNETTRUNKIFPORT::pfnNotifyMacAddress
536	*/
537	static DECLCALLBACK(void) vboxNetFltPortNotifyMacAddress(PINTNETTRUNKIFPORT pIfPort, void *pvIfData, PCRTMAC pMac)
538	{
539	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
540
541	/*
542	* Input validation.
543	*/
544	AssertPtr(pThis);
545	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
546
547	vboxNetFltRetain(pThis, false /* fBusy */);
548	vboxNetFltPortOsNotifyMacAddress(pThis, pvIfData, pMac);
549	vboxNetFltRelease(pThis, false /* fBusy */);
550	}
551
552
553	/**
554	* @copydoc INTNETTRUNKIFPORT::pfnConnectInterface
555	*/
556	static DECLCALLBACK(int) vboxNetFltPortConnectInterface(PINTNETTRUNKIFPORT pIfPort, void pvIf, void *ppvIfData)
557	{
558	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
559	int rc;
560
561	/*
562	* Input validation.
563	*/
564	AssertPtr(pThis);
565	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
566
567	vboxNetFltRetain(pThis, false /* fBusy */);
568	rc = vboxNetFltPortOsConnectInterface(pThis, pvIf, ppvIfData);
569	vboxNetFltRelease(pThis, false /* fBusy */);
570
571	return rc;
572	}
573
574
575	/**
576	* @copydoc INTNETTRUNKIFPORT::pfnDisconnectInterface
577	*/
578	static DECLCALLBACK(void) vboxNetFltPortDisconnectInterface(PINTNETTRUNKIFPORT pIfPort, void *pvIfData)
579	{
580	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
581	int rc;
582
583	/*
584	* Input validation.
585	*/
586	AssertPtr(pThis);
587	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
588
589	vboxNetFltRetain(pThis, false /* fBusy */);
590	rc = vboxNetFltPortOsDisconnectInterface(pThis, pvIfData);
591	vboxNetFltRelease(pThis, false /* fBusy */);
592	AssertRC(rc); /** @todo fix vboxNetFltPortOsDisconnectInterface. */
593	}
594
595
596	/**
597	* @copydoc INTNETTRUNKIFPORT::pfnDisconnectAndRelease
598	*/
599	static DECLCALLBACK(void) vboxNetFltPortDisconnectAndRelease(PINTNETTRUNKIFPORT pIfPort)
600	{
601	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
602
603	/*
604	* Serious paranoia.
605	*/
606	AssertPtr(pThis);
607	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
608	Assert(pThis->MyPort.u32VersionEnd == INTNETTRUNKIFPORT_VERSION);
609	AssertPtr(pThis->pGlobals);
610	Assert(pThis->hEventIdle != NIL_RTSEMEVENT);
611	Assert(pThis->hSpinlock != NIL_RTSPINLOCK);
612	Assert(pThis->szName[0]);
613
614	Assert(vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Connected);
615	Assert(pThis->enmTrunkState == INTNETTRUNKIFSTATE_DISCONNECTING);
616	Assert(!pThis->fRediscoveryPending);
617	Assert(!pThis->cBusy);
618
619	/*
620	* Disconnect and release it.
621	*/
622	RTSpinlockAcquire(pThis->hSpinlock);
623	vboxNetFltSetState(pThis, kVBoxNetFltInsState_Disconnecting);
624	RTSpinlockReleaseNoInts(pThis->hSpinlock);
625
626	vboxNetFltOsDisconnectIt(pThis);
627	pThis->pSwitchPort = NULL;
628
629	#ifdef VBOXNETFLT_STATIC_CONFIG
630	RTSpinlockAcquire(pThis->hSpinlock);
631	vboxNetFltSetState(pThis, kVBoxNetFltInsState_Unconnected);
632	RTSpinlockReleaseNoInts(pThis->hSpinlock);
633	#endif
634
635	vboxNetFltRelease(pThis, false /* fBusy */);
636	}
637
638
639	/**
640	* Destroy a device that has been disconnected from the switch.
641	*
642	* @returns true if the instance is destroyed, false otherwise.
643	* @param pThis The instance to be destroyed. This is
644	* no longer valid when this function returns.
645	*/
646	static bool vboxNetFltDestroyInstance(PVBOXNETFLTINS pThis)
647	{
648	PVBOXNETFLTGLOBALS pGlobals = pThis->pGlobals;
649	uint32_t cRefs = ASMAtomicUoReadU32((uint32_t volatile *)&pThis->cRefs);
650	int rc;
651	LogFlow(("vboxNetFltDestroyInstance: pThis=%p (%s)\n", pThis, pThis->szName));
652
653	/*
654	* Validate the state.
655	*/
656	#ifdef VBOXNETFLT_STATIC_CONFIG
657	Assert( vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Disconnecting
658	\|\| vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Unconnected);
659	#else
660	Assert(vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Disconnecting);
661	#endif
662	Assert(pThis->enmTrunkState == INTNETTRUNKIFSTATE_DISCONNECTING);
663	Assert(!pThis->fRediscoveryPending);
664	Assert(!pThis->cRefs);
665	Assert(!pThis->cBusy);
666	Assert(!pThis->pSwitchPort);
667
668	/*
669	* Make sure the state is 'disconnecting' / 'destroying' and let the OS
670	* specific code do its part of the cleanup outside the mutex.
671	*/
672	rc = RTSemFastMutexRequest(pGlobals->hFastMtx); AssertRC(rc);
673	vboxNetFltSetState(pThis, kVBoxNetFltInsState_Disconnecting);
674	RTSemFastMutexRelease(pGlobals->hFastMtx);
675
676	vboxNetFltOsDeleteInstance(pThis);
677
678	/*
679	* Unlink the instance and free up its resources.
680	*/
681	rc = RTSemFastMutexRequest(pGlobals->hFastMtx); AssertRC(rc);
682	vboxNetFltSetState(pThis, kVBoxNetFltInsState_Destroyed);
683	vboxNetFltUnlinkLocked(pGlobals, pThis);
684	RTSemFastMutexRelease(pGlobals->hFastMtx);
685
686	RTSemEventDestroy(pThis->hEventIdle);
687	pThis->hEventIdle = NIL_RTSEMEVENT;
688	RTSpinlockDestroy(pThis->hSpinlock);
689	pThis->hSpinlock = NIL_RTSPINLOCK;
690	RTMemFree(pThis);
691
692	NOREF(cRefs);
693
694	return true;
695	}
696
697
698	/**
699	* Releases a reference to the specified instance.
700	*
701	* This method will destroy the instance when the count reaches 0.
702	* It will also take care of decrementing the counter and idle wakeup.
703	*
704	* @param pThis The instance.
705	* @param fBusy Whether the busy counter should be decremented too.
706	*/
707	DECLHIDDEN(void) vboxNetFltRelease(PVBOXNETFLTINS pThis, bool fBusy)
708	{
709	uint32_t cRefs;
710
711	/*
712	* Paranoid Android.
713	*/
714	AssertPtr(pThis);
715	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
716	Assert(pThis->MyPort.u32VersionEnd == INTNETTRUNKIFPORT_VERSION);
717	Assert( vboxNetFltGetState(pThis) > kVBoxNetFltInsState_Invalid
718	&& vboxNetFltGetState(pThis) < kVBoxNetFltInsState_Destroyed);
719	AssertPtr(pThis->pGlobals);
720	Assert(pThis->hEventIdle != NIL_RTSEMEVENT);
721	Assert(pThis->hSpinlock != NIL_RTSPINLOCK);
722	Assert(pThis->szName[0]);
723
724	/*
725	* Work the busy counter.
726	*/
727	if (fBusy)
728	{
729	cRefs = ASMAtomicDecU32(&pThis->cBusy);
730	if (!cRefs)
731	{
732	int rc = RTSemEventSignal(pThis->hEventIdle);
733	AssertRC(rc);
734	}
735	else
736	Assert(cRefs < UINT32_MAX / 2);
737	}
738
739	/*
740	* The object reference counting.
741	*/
742	cRefs = ASMAtomicDecU32(&pThis->cRefs);
743	if (!cRefs)
744	vboxNetFltDestroyInstance(pThis);
745	else
746	Assert(cRefs < UINT32_MAX / 2);
747	}
748
749
750	/**
751	* @copydoc INTNETTRUNKIFPORT::pfnRetain
752	*/
753	static DECLCALLBACK(void) vboxNetFltPortRelease(PINTNETTRUNKIFPORT pIfPort)
754	{
755	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
756	vboxNetFltRelease(pThis, false /* fBusy */);
757	}
758
759
760	/**
761	* Retains a reference to the specified instance and a busy reference too.
762	*
763	* @param pThis The instance.
764	* @param fBusy Whether the busy counter should be incremented as well.
765	*/
766	DECLHIDDEN(void) vboxNetFltRetain(PVBOXNETFLTINS pThis, bool fBusy)
767	{
768	uint32_t cRefs;
769
770	/*
771	* Paranoid Android.
772	*/
773	AssertPtr(pThis);
774	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
775	Assert(pThis->MyPort.u32VersionEnd == INTNETTRUNKIFPORT_VERSION);
776	Assert( vboxNetFltGetState(pThis) > kVBoxNetFltInsState_Invalid
777	&& vboxNetFltGetState(pThis) < kVBoxNetFltInsState_Destroyed);
778	AssertPtr(pThis->pGlobals);
779	Assert(pThis->hEventIdle != NIL_RTSEMEVENT);
780	Assert(pThis->hSpinlock != NIL_RTSPINLOCK);
781	Assert(pThis->szName[0]);
782
783	/*
784	* Retain the object.
785	*/
786	cRefs = ASMAtomicIncU32(&pThis->cRefs);
787	Assert(cRefs > 1 && cRefs < UINT32_MAX / 2);
788
789	/*
790	* Work the busy counter.
791	*/
792	if (fBusy)
793	{
794	cRefs = ASMAtomicIncU32(&pThis->cBusy);
795	Assert(cRefs > 0 && cRefs < UINT32_MAX / 2);
796	}
797
798	NOREF(cRefs);
799	}
800
801
802	/**
803	* Tries to retain the device as busy if the trunk is active.
804	*
805	* This is used before calling pfnRecv or pfnPreRecv.
806	*
807	* @returns true if we succeeded in retaining a busy reference to the active
808	* device. false if we failed.
809	* @param pThis The instance.
810	*/
811	DECLHIDDEN(bool) vboxNetFltTryRetainBusyActive(PVBOXNETFLTINS pThis)
812	{
813	uint32_t cRefs;
814	bool fRc;
815
816	/*
817	* Paranoid Android.
818	*/
819	AssertPtr(pThis);
820	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
821	Assert(pThis->MyPort.u32VersionEnd == INTNETTRUNKIFPORT_VERSION);
822	Assert( vboxNetFltGetState(pThis) > kVBoxNetFltInsState_Invalid
823	&& vboxNetFltGetState(pThis) < kVBoxNetFltInsState_Destroyed);
824	AssertPtr(pThis->pGlobals);
825	Assert(pThis->hEventIdle != NIL_RTSEMEVENT);
826	Assert(pThis->hSpinlock != NIL_RTSPINLOCK);
827	Assert(pThis->szName[0]);
828
829	/*
830	* Do the retaining and checking behind the spinlock.
831	*/
832	RTSpinlockAcquire(pThis->hSpinlock);
833	fRc = pThis->enmTrunkState == INTNETTRUNKIFSTATE_ACTIVE;
834	if (fRc)
835	{
836	cRefs = ASMAtomicIncU32(&pThis->cRefs);
837	AssertMsg(cRefs > 1 && cRefs < UINT32_MAX / 2, ("%d\n", cRefs)); NOREF(cRefs);
838
839	cRefs = ASMAtomicIncU32(&pThis->cBusy);
840	AssertMsg(cRefs >= 1 && cRefs < UINT32_MAX / 2, ("%d\n", cRefs)); NOREF(cRefs);
841	}
842	RTSpinlockReleaseNoInts(pThis->hSpinlock);
843
844	return fRc;
845	}
846
847
848	/**
849	* Tries to retain the device as busy if the trunk is not disconnecting.
850	*
851	* This is used before reporting stuff to the internal network.
852	*
853	* @returns true if we succeeded in retaining a busy reference to the active
854	* device. false if we failed.
855	* @param pThis The instance.
856	*/
857	DECLHIDDEN(bool) vboxNetFltTryRetainBusyNotDisconnected(PVBOXNETFLTINS pThis)
858	{
859	uint32_t cRefs;
860	bool fRc;
861
862	/*
863	* Paranoid Android.
864	*/
865	AssertPtr(pThis);
866	Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
867	Assert(pThis->MyPort.u32VersionEnd == INTNETTRUNKIFPORT_VERSION);
868	Assert( vboxNetFltGetState(pThis) > kVBoxNetFltInsState_Invalid
869	&& vboxNetFltGetState(pThis) < kVBoxNetFltInsState_Destroyed);
870	AssertPtr(pThis->pGlobals);
871	Assert(pThis->hEventIdle != NIL_RTSEMEVENT);
872	Assert(pThis->hSpinlock != NIL_RTSPINLOCK);
873	Assert(pThis->szName[0]);
874
875	/*
876	* Do the retaining and checking behind the spinlock.
877	*/
878	RTSpinlockAcquire(pThis->hSpinlock);
879	fRc = pThis->enmTrunkState == INTNETTRUNKIFSTATE_ACTIVE
880	\|\| pThis->enmTrunkState == INTNETTRUNKIFSTATE_INACTIVE;
881	if (fRc)
882	{
883	cRefs = ASMAtomicIncU32(&pThis->cRefs);
884	AssertMsg(cRefs > 1 && cRefs < UINT32_MAX / 2, ("%d\n", cRefs)); NOREF(cRefs);
885
886	cRefs = ASMAtomicIncU32(&pThis->cBusy);
887	AssertMsg(cRefs >= 1 && cRefs < UINT32_MAX / 2, ("%d\n", cRefs)); NOREF(cRefs);
888	}
889	RTSpinlockReleaseNoInts(pThis->hSpinlock);
890
891	return fRc;
892	}
893
894
895	/**
896	* @copydoc INTNETTRUNKIFPORT::pfnRetain
897	*/
898	static DECLCALLBACK(void) vboxNetFltPortRetain(PINTNETTRUNKIFPORT pIfPort)
899	{
900	PVBOXNETFLTINS pThis = IFPORT_2_VBOXNETFLTINS(pIfPort);
901	vboxNetFltRetain(pThis, false /* fBusy */);
902	}
903
904
905	/**
906	* Connects the instance to the specified switch port.
907	*
908	* Called while owning the lock. We're ASSUMING that the internal
909	* networking code is already owning an recursive mutex, so, there
910	* will be no deadlocks when vboxNetFltOsConnectIt calls back into
911	* it for setting preferences.
912	*
913	* @returns VBox status code.
914	* @param pThis The instance.
915	* @param pSwitchPort The port on the internal network 'switch'.
916	* @param ppIfPort Where to return our port interface.
917	*/
918	static int vboxNetFltConnectIt(PVBOXNETFLTINS pThis, PINTNETTRUNKSWPORT pSwitchPort, PINTNETTRUNKIFPORT *ppIfPort)
919	{
920	int rc;
921
922	/*
923	* Validate state.
924	*/
925	Assert(!pThis->fRediscoveryPending);
926	Assert(!pThis->cBusy);
927	#ifdef VBOXNETFLT_STATIC_CONFIG
928	Assert(vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Unconnected);
929	#else
930	Assert(vboxNetFltGetState(pThis) == kVBoxNetFltInsState_Initializing);
931	#endif
932	Assert(pThis->enmTrunkState == INTNETTRUNKIFSTATE_INACTIVE);
933
934	/*
935	* Do the job.
936	* Note that we're calling the os stuff while owning the semaphore here.
937	*/
938	pThis->pSwitchPort = pSwitchPort;
939	rc = vboxNetFltOsConnectIt(pThis);
940	if (RT_SUCCESS(rc))
941	{
942	vboxNetFltSetState(pThis, kVBoxNetFltInsState_Connected);
943	*ppIfPort = &pThis->MyPort;
944	}
945	else
946	pThis->pSwitchPort = NULL;
947
948	Assert(pThis->enmTrunkState == INTNETTRUNKIFSTATE_INACTIVE);
949	return rc;
950	}
951
952
953	/**
954	* Creates a new instance.
955	*
956	* The new instance will be in the suspended state in a dynamic config and in
957	* the inactive in a static one.
958	*
959	* Called without owning the lock, but will request is several times.
960	*
961	* @returns VBox status code.
962	* @param pGlobals The globals.
963	* @param pszName The instance name.
964	* @param pSwitchPort The port on the switch that we're connected with (dynamic only).
965	* @param fNoPromisc Do not attempt going into promiscuous mode.
966	* @param pvContext Context argument for vboxNetFltOsInitInstance.
967	* @param ppIfPort Where to store the pointer to our port interface (dynamic only).
968	*/
969	static int vboxNetFltNewInstance(PVBOXNETFLTGLOBALS pGlobals, const char *pszName, PINTNETTRUNKSWPORT pSwitchPort,
970	bool fNoPromisc, void pvContext, PINTNETTRUNKIFPORT ppIfPort)
971	{
972	/*
973	* Allocate and initialize a new instance before requesting the mutex.
974	* Note! That in a static config we'll initialize the trunk state to
975	* disconnecting and flip it in vboxNetFltFactoryCreateAndConnect
976	* later on. This better reflext the state and it works better with
977	* assertions in the destruction path.
978	*/
979	int rc;
980	size_t const cchName = strlen(pszName);
981	PVBOXNETFLTINS pNew = (PVBOXNETFLTINS)RTMemAllocZ(RT_OFFSETOF(VBOXNETFLTINS, szName[cchName + 1]));
982	if (!pNew)
983	return VERR_INTNET_FLT_IF_FAILED;
984	pNew->pNext = NULL;
985	pNew->MyPort.u32Version = INTNETTRUNKIFPORT_VERSION;
986	pNew->MyPort.pfnRetain = vboxNetFltPortRetain;
987	pNew->MyPort.pfnRelease = vboxNetFltPortRelease;
988	pNew->MyPort.pfnDisconnectAndRelease= vboxNetFltPortDisconnectAndRelease;
989	pNew->MyPort.pfnSetState = vboxNetFltPortSetState;
990	pNew->MyPort.pfnWaitForIdle = vboxNetFltPortWaitForIdle;
991	pNew->MyPort.pfnXmit = vboxNetFltPortXmit;
992	pNew->MyPort.pfnNotifyMacAddress = vboxNetFltPortNotifyMacAddress;
993	pNew->MyPort.pfnConnectInterface = vboxNetFltPortConnectInterface;
994	pNew->MyPort.pfnDisconnectInterface = vboxNetFltPortDisconnectInterface;
995	pNew->MyPort.u32VersionEnd = INTNETTRUNKIFPORT_VERSION;
996	pNew->pSwitchPort = pSwitchPort;
997	pNew->pGlobals = pGlobals;
998	pNew->hSpinlock = NIL_RTSPINLOCK;
999	pNew->enmState = kVBoxNetFltInsState_Initializing;
1000	#ifdef VBOXNETFLT_STATIC_CONFIG
1001	pNew->enmTrunkState = INTNETTRUNKIFSTATE_DISCONNECTING;
1002	#else
1003	pNew->enmTrunkState = INTNETTRUNKIFSTATE_INACTIVE;
1004	#endif
1005	pNew->fDisconnectedFromHost = false;
1006	pNew->fRediscoveryPending = false;
1007	pNew->fDisablePromiscuous = fNoPromisc;
1008	pNew->NanoTSLastRediscovery = INT64_MAX;
1009	pNew->cRefs = 1;
1010	pNew->cBusy = 0;
1011	pNew->hEventIdle = NIL_RTSEMEVENT;
1012	memcpy(pNew->szName, pszName, cchName + 1);
1013
1014	rc = RTSpinlockCreate(&pNew->hSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxNetFltNewInstance");
1015	if (RT_SUCCESS(rc))
1016	{
1017	rc = RTSemEventCreate(&pNew->hEventIdle);
1018	if (RT_SUCCESS(rc))
1019	{
1020	rc = vboxNetFltOsPreInitInstance(pNew);
1021	if (RT_SUCCESS(rc))
1022	{
1023	/*
1024	* Insert the instance into the chain, checking for
1025	* duplicates first of course (race).
1026	*/
1027	rc = RTSemFastMutexRequest(pGlobals->hFastMtx);
1028	if (RT_SUCCESS(rc))
1029	{
1030	if (!vboxNetFltFindInstanceLocked(pGlobals, pszName))
1031	{
1032	pNew->pNext = pGlobals->pInstanceHead;
1033	pGlobals->pInstanceHead = pNew;
1034	RTSemFastMutexRelease(pGlobals->hFastMtx);
1035
1036	/*
1037	* Call the OS specific initialization code.
1038	*/
1039	rc = vboxNetFltOsInitInstance(pNew, pvContext);
1040	RTSemFastMutexRequest(pGlobals->hFastMtx);
1041	if (RT_SUCCESS(rc))
1042	{
1043	#ifdef VBOXNETFLT_STATIC_CONFIG
1044	/*
1045	* Static instances are unconnected at birth.
1046	*/
1047	Assert(!pSwitchPort);
1048	pNew->enmState = kVBoxNetFltInsState_Unconnected;
1049	RTSemFastMutexRelease(pGlobals->hFastMtx);
1050	*ppIfPort = &pNew->MyPort;
1051	return rc;
1052
1053	#else /* !VBOXNETFLT_STATIC_CONFIG */
1054	/*
1055	* Connect it as well, the OS specific bits has to be done outside
1056	* the lock as they may call back to into intnet.
1057	*/
1058	rc = vboxNetFltConnectIt(pNew, pSwitchPort, ppIfPort);
1059	if (RT_SUCCESS(rc))
1060	{
1061	RTSemFastMutexRelease(pGlobals->hFastMtx);
1062	Assert(*ppIfPort == &pNew->MyPort);
1063	return rc;
1064	}
1065
1066	/* Bail out (failed). */
1067	vboxNetFltOsDeleteInstance(pNew);
1068	#endif /* !VBOXNETFLT_STATIC_CONFIG */
1069	}
1070	vboxNetFltUnlinkLocked(pGlobals, pNew);
1071	}
1072	else
1073	rc = VERR_INTNET_FLT_IF_BUSY;
1074	RTSemFastMutexRelease(pGlobals->hFastMtx);
1075	}
1076	}
1077	RTSemEventDestroy(pNew->hEventIdle);
1078	}
1079	RTSpinlockDestroy(pNew->hSpinlock);
1080	}
1081
1082	RTMemFree(pNew);
1083	return rc;
1084	}
1085
1086
1087	#ifdef VBOXNETFLT_STATIC_CONFIG
1088	/**
1089	* Searches for the NetFlt instance by its name and creates the new one if not found.
1090	*
1091	* @returns VBox status code.
1092	* @retval VINF_SUCCESS and *ppInstance if a new instance was created.
1093	* @retval VINF_ALREADY_INITIALIZED and *ppInstance if an instance already exists.
1094	*
1095	* @param pGlobal Pointer to the globals.
1096	* @param pszName The instance name.
1097	* @param ppInstance Where to return the instance pointer on success.
1098	* @param pvContext Context which needs to be passed along to vboxNetFltOsInitInstance.
1099	*/
1100	DECLHIDDEN(int) vboxNetFltSearchCreateInstance(PVBOXNETFLTGLOBALS pGlobals, const char pszName, PVBOXNETFLTINS ppInstance, void *pvContext)
1101	{
1102	PINTNETTRUNKIFPORT pIfPort;
1103	PVBOXNETFLTINS pCur;
1104	VBOXNETFTLINSSTATE enmState;
1105	int rc;
1106
1107	*ppInstance = NULL;
1108	rc = RTSemFastMutexRequest(pGlobals->hFastMtx);
1109	AssertRCReturn(rc, rc);
1110
1111	/*
1112	* Look for an existing instance in the list.
1113	*
1114	* There might be an existing one in the list if the driver was unbound
1115	* while it was connected to an internal network. We're running into
1116	* a destruction race that is a bit similar to the one in
1117	* vboxNetFltFactoryCreateAndConnect, only the roles are reversed
1118	* and we're not in a position to back down. Instead of backing down
1119	* we'll delay a bit giving the other thread time to complete the
1120	* destructor.
1121	*/
1122	pCur = vboxNetFltFindInstanceLocked(pGlobals, pszName);
1123	while (pCur)
1124	{
1125	uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs);
1126	if (cRefs > 1)
1127	{
1128	enmState = vboxNetFltGetState(pCur);
1129	switch (enmState)
1130	{
1131	case kVBoxNetFltInsState_Unconnected:
1132	case kVBoxNetFltInsState_Connected:
1133	case kVBoxNetFltInsState_Disconnecting:
1134	if (pCur->fDisconnectedFromHost)
1135	{
1136	/* Wait for it to exit the transitional disconnecting
1137	state. It might otherwise be running the risk of
1138	upsetting the OS specific code... */
1139	/** @todo This reconnect stuff should be serialized correctly for static
1140	* devices. Shouldn't it? In the dynamic case we're using the INTNET
1141	* outbound thunk lock, but that doesn't quite cut it here, or does
1142	* it? We could either transition to initializing or make a callback
1143	* while owning the mutex here... */
1144	if (enmState == kVBoxNetFltInsState_Disconnecting)
1145	{
1146	do
1147	{
1148	RTSemFastMutexRelease(pGlobals->hFastMtx);
1149	RTThreadSleep(2); /* (2ms) */
1150	RTSemFastMutexRequest(pGlobals->hFastMtx);
1151	enmState = vboxNetFltGetState(pCur);
1152	}
1153	while (enmState == kVBoxNetFltInsState_Disconnecting);
1154	AssertMsg(enmState == kVBoxNetFltInsState_Unconnected, ("%d\n", enmState));
1155	Assert(pCur->fDisconnectedFromHost);
1156	}
1157
1158	RTSemFastMutexRelease(pGlobals->hFastMtx);
1159	*ppInstance = pCur;
1160	return VINF_ALREADY_INITIALIZED;
1161	}
1162	/* fall thru */
1163
1164	default:
1165	{
1166	bool fDfH = pCur->fDisconnectedFromHost;
1167	RTSemFastMutexRelease(pGlobals->hFastMtx);
1168	vboxNetFltRelease(pCur, false /* fBusy */);
1169	LogRel(("VBoxNetFlt: Huh? An instance of '%s' already exists! [pCur=%p cRefs=%d fDfH=%RTbool enmState=%d]\n",
1170	pszName, pCur, cRefs - 1, fDfH, enmState));
1171	*ppInstance = NULL;
1172	return VERR_INTNET_FLT_IF_BUSY;
1173	}
1174	}
1175	}
1176
1177	/* Zero references, it's being destroyed. Delay a bit so the destructor
1178	can finish its work and try again. (vboxNetFltNewInstance will fail
1179	with duplicate name if we don't.) */
1180	# ifdef RT_STRICT
1181	Assert(cRefs == 1);
1182	enmState = vboxNetFltGetState(pCur);
1183	AssertMsg( enmState == kVBoxNetFltInsState_Unconnected
1184	\|\| enmState == kVBoxNetFltInsState_Disconnecting
1185	\|\| enmState == kVBoxNetFltInsState_Destroyed, ("%d\n", enmState));
1186	# endif
1187	ASMAtomicDecU32(&pCur->cRefs);
1188	RTSemFastMutexRelease(pGlobals->hFastMtx);
1189	RTThreadSleep(2); /* (2ms) */
1190	rc = RTSemFastMutexRequest(pGlobals->hFastMtx);
1191	AssertRCReturn(rc, rc);
1192
1193	/* try again */
1194	pCur = vboxNetFltFindInstanceLocked(pGlobals, pszName);
1195	}
1196
1197	RTSemFastMutexRelease(pGlobals->hFastMtx);
1198
1199	/*
1200	* Try create a new instance.
1201	* (fNoPromisc is overridden in the vboxNetFltFactoryCreateAndConnect path, so pass true here.)
1202	*/
1203	rc = vboxNetFltNewInstance(pGlobals, pszName, NULL, true /* fNoPromisc */, pvContext, &pIfPort);
1204	if (RT_SUCCESS(rc))
1205	*ppInstance = IFPORT_2_VBOXNETFLTINS(pIfPort);
1206	else
1207	*ppInstance = NULL;
1208
1209	return rc;
1210	}
1211	#endif /* VBOXNETFLT_STATIC_CONFIG */
1212
1213
1214	/**
1215	* @copydoc INTNETTRUNKFACTORY::pfnCreateAndConnect
1216	*/
1217	static DECLCALLBACK(int) vboxNetFltFactoryCreateAndConnect(PINTNETTRUNKFACTORY pIfFactory, const char *pszName,
1218	PINTNETTRUNKSWPORT pSwitchPort, uint32_t fFlags,
1219	PINTNETTRUNKIFPORT *ppIfPort)
1220	{
1221	PVBOXNETFLTGLOBALS pGlobals = (PVBOXNETFLTGLOBALS)((uint8_t *)pIfFactory - RT_OFFSETOF(VBOXNETFLTGLOBALS, TrunkFactory));
1222	PVBOXNETFLTINS pCur;
1223	int rc;
1224
1225	LogFlow(("vboxNetFltFactoryCreateAndConnect: pszName=%p:{%s} fFlags=%#x\n", pszName, pszName, fFlags));
1226	Assert(pGlobals->cFactoryRefs > 0);
1227	AssertMsgReturn(!(fFlags & ~(INTNETTRUNKFACTORY_FLAG_NO_PROMISC)),
1228	("%#x\n", fFlags), VERR_INVALID_PARAMETER);
1229
1230	/*
1231	* Static: Find instance, check if busy, connect if not.
1232	* Dynamic: Check for duplicate / busy interface instance.
1233	*/
1234	rc = RTSemFastMutexRequest(pGlobals->hFastMtx);
1235	AssertRCReturn(rc, rc);
1236
1237	//#if defined(VBOXNETADP) && defined(RT_OS_WINDOWS)
1238	// /* temporary hack to pick up the first adapter */
1239	// pCur = pGlobals->pInstanceHead; /** @todo Don't for get to remove this temporary hack... :-) */
1240	//#else
1241	pCur = vboxNetFltFindInstanceLocked(pGlobals, pszName);
1242	//#endif
1243	if (pCur)
1244	{
1245	#ifdef VBOXNETFLT_STATIC_CONFIG
1246	/* Try grab a reference. If the count had already reached zero we're racing the
1247	destructor code and must back down. */
1248	uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs);
1249	if (cRefs > 1)
1250	{
1251	if (vboxNetFltGetState(pCur) == kVBoxNetFltInsState_Unconnected)
1252	{
1253	pCur->enmTrunkState = INTNETTRUNKIFSTATE_INACTIVE; /** @todo protect me? */
1254	pCur->fDisablePromiscuous = !!(fFlags & INTNETTRUNKFACTORY_FLAG_NO_PROMISC);
1255	rc = vboxNetFltConnectIt(pCur, pSwitchPort, ppIfPort);
1256	if (RT_SUCCESS(rc))
1257	pCur = NULL; /* Don't release it, reference given to the caller. */
1258	else
1259	pCur->enmTrunkState = INTNETTRUNKIFSTATE_DISCONNECTING;
1260	}
1261	else
1262	rc = VERR_INTNET_FLT_IF_BUSY;
1263	}
1264	else
1265	{
1266	Assert(cRefs == 1);
1267	ASMAtomicDecU32(&pCur->cRefs);
1268	pCur = NULL; /* nothing to release */
1269	rc = VERR_INTNET_FLT_IF_NOT_FOUND;
1270	}
1271
1272	RTSemFastMutexRelease(pGlobals->hFastMtx);
1273	if (pCur)
1274	vboxNetFltRelease(pCur, false /* fBusy */);
1275	#else
1276	rc = VERR_INTNET_FLT_IF_BUSY;
1277	RTSemFastMutexRelease(pGlobals->hFastMtx);
1278	#endif
1279	LogFlow(("vboxNetFltFactoryCreateAndConnect: returns %Rrc\n", rc));
1280	return rc;
1281	}
1282
1283	RTSemFastMutexRelease(pGlobals->hFastMtx);
1284
1285	#ifdef VBOXNETFLT_STATIC_CONFIG
1286	rc = VERR_INTNET_FLT_IF_NOT_FOUND;
1287	#else
1288	/*
1289	* Dynamically create a new instance.
1290	*/
1291	rc = vboxNetFltNewInstance(pGlobals,
1292	pszName,
1293	pSwitchPort,
1294	!!(fFlags & INTNETTRUNKFACTORY_FLAG_NO_PROMISC),
1295	NULL,
1296	ppIfPort);
1297	#endif
1298	LogFlow(("vboxNetFltFactoryCreateAndConnect: returns %Rrc\n", rc));
1299	return rc;
1300	}
1301
1302
1303	/**
1304	* @copydoc INTNETTRUNKFACTORY::pfnRelease
1305	*/
1306	static DECLCALLBACK(void) vboxNetFltFactoryRelease(PINTNETTRUNKFACTORY pIfFactory)
1307	{
1308	PVBOXNETFLTGLOBALS pGlobals = (PVBOXNETFLTGLOBALS)((uint8_t *)pIfFactory - RT_OFFSETOF(VBOXNETFLTGLOBALS, TrunkFactory));
1309
1310	int32_t cRefs = ASMAtomicDecS32(&pGlobals->cFactoryRefs);
1311	Assert(cRefs >= 0); NOREF(cRefs);
1312	LogFlow(("vboxNetFltFactoryRelease: cRefs=%d (new)\n", cRefs));
1313	}
1314
1315
1316	/**
1317	* Implements the SUPDRV component factor interface query method.
1318	*
1319	* @returns Pointer to an interface. NULL if not supported.
1320	*
1321	* @param pSupDrvFactory Pointer to the component factory registration structure.
1322	* @param pSession The session - unused.
1323	* @param pszInterfaceUuid The factory interface id.
1324	*/
1325	static DECLCALLBACK(void ) vboxNetFltQueryFactoryInterface(PCSUPDRVFACTORY pSupDrvFactory, PSUPDRVSESSION pSession, const char pszInterfaceUuid)
1326	{
1327	PVBOXNETFLTGLOBALS pGlobals = (PVBOXNETFLTGLOBALS)((uint8_t *)pSupDrvFactory - RT_OFFSETOF(VBOXNETFLTGLOBALS, SupDrvFactory));
1328
1329	/*
1330	* Convert the UUID strings and compare them.
1331	*/
1332	RTUUID UuidReq;
1333	int rc = RTUuidFromStr(&UuidReq, pszInterfaceUuid);
1334	if (RT_SUCCESS(rc))
1335	{
1336	if (!RTUuidCompareStr(&UuidReq, INTNETTRUNKFACTORY_UUID_STR))
1337	{
1338	ASMAtomicIncS32(&pGlobals->cFactoryRefs);
1339	return &pGlobals->TrunkFactory;
1340	}
1341	#ifdef LOG_ENABLED
1342	/* log legacy queries */
1343	/* else if (!RTUuidCompareStr(&UuidReq, INTNETTRUNKFACTORY_V1_UUID_STR))
1344	Log(("VBoxNetFlt: V1 factory query\n"));
1345	*/
1346	else
1347	Log(("VBoxNetFlt: unknown factory interface query (%s)\n", pszInterfaceUuid));
1348	#endif
1349	}
1350	else
1351	Log(("VBoxNetFlt: rc=%Rrc, uuid=%s\n", rc, pszInterfaceUuid));
1352
1353	return NULL;
1354	}
1355
1356
1357	/**
1358	* Checks whether the VBoxNetFlt wossname can be unloaded.
1359	*
1360	* This will return false if someone is currently using the module.
1361	*
1362	* @returns true if it's relatively safe to unload it, otherwise false.
1363	* @param pGlobals Pointer to the globals.
1364	*/
1365	DECLHIDDEN(bool) vboxNetFltCanUnload(PVBOXNETFLTGLOBALS pGlobals)
1366	{
1367	int rc = RTSemFastMutexRequest(pGlobals->hFastMtx);
1368	bool fRc = !pGlobals->pInstanceHead
1369	&& pGlobals->cFactoryRefs <= 0;
1370	RTSemFastMutexRelease(pGlobals->hFastMtx);
1371	AssertRC(rc);
1372	return fRc;
1373	}
1374
1375
1376	/**
1377	* Try to close the IDC connection to SUPDRV if established.
1378	*
1379	* @returns VBox status code.
1380	* @retval VINF_SUCCESS on success.
1381	* @retval VERR_WRONG_ORDER if we're busy.
1382	*
1383	* @param pGlobals Pointer to the globals.
1384	*
1385	* @sa vboxNetFltTryDeleteIdcAndGlobals()
1386	*/
1387	DECLHIDDEN(int) vboxNetFltTryDeleteIdc(PVBOXNETFLTGLOBALS pGlobals)
1388	{
1389	int rc;
1390
1391	Assert(pGlobals->hFastMtx != NIL_RTSEMFASTMUTEX);
1392
1393	/*
1394	* Check before trying to deregister the factory.
1395	*/
1396	if (!vboxNetFltCanUnload(pGlobals))
1397	return VERR_WRONG_ORDER;
1398
1399	if (!pGlobals->fIDCOpen)
1400	rc = VINF_SUCCESS;
1401	else
1402	{
1403	/*
1404	* Disconnect from SUPDRV and check that nobody raced us,
1405	* reconnect if that should happen.
1406	*/
1407	rc = SUPR0IdcComponentDeregisterFactory(&pGlobals->SupDrvIDC, &pGlobals->SupDrvFactory);
1408	AssertRC(rc);
1409	if (!vboxNetFltCanUnload(pGlobals))
1410	{
1411	rc = SUPR0IdcComponentRegisterFactory(&pGlobals->SupDrvIDC, &pGlobals->SupDrvFactory);
1412	AssertRC(rc);
1413	return VERR_WRONG_ORDER;
1414	}
1415
1416	SUPR0IdcClose(&pGlobals->SupDrvIDC);
1417	pGlobals->fIDCOpen = false;
1418	}
1419
1420	return rc;
1421	}
1422
1423
1424	/**
1425	* Establishes the IDC connection to SUPDRV and registers our component factory.
1426	*
1427	* @returns VBox status code.
1428	* @param pGlobals Pointer to the globals.
1429	* @sa vboxNetFltInitGlobalsAndIdc().
1430	*/
1431	DECLHIDDEN(int) vboxNetFltInitIdc(PVBOXNETFLTGLOBALS pGlobals)
1432	{
1433	int rc;
1434	Assert(!pGlobals->fIDCOpen);
1435
1436	/*
1437	* Establish a connection to SUPDRV and register our component factory.
1438	*/
1439	rc = SUPR0IdcOpen(&pGlobals->SupDrvIDC, 0 /* iReqVersion = default /, 0 / iMinVersion = default */, NULL, NULL, NULL);
1440	if (RT_SUCCESS(rc))
1441	{
1442	rc = SUPR0IdcComponentRegisterFactory(&pGlobals->SupDrvIDC, &pGlobals->SupDrvFactory);
1443	if (RT_SUCCESS(rc))
1444	{
1445	pGlobals->fIDCOpen = true;
1446	Log(("VBoxNetFlt: pSession=%p\n", SUPR0IdcGetSession(&pGlobals->SupDrvIDC)));
1447	return rc;
1448	}
1449
1450	/* bail out. */
1451	LogRel(("VBoxNetFlt: Failed to register component factory, rc=%Rrc\n", rc));
1452	SUPR0IdcClose(&pGlobals->SupDrvIDC);
1453	}
1454
1455	return rc;
1456	}
1457
1458
1459	/**
1460	* Deletes the globals.
1461	*
1462	* This must be called after the IDC connection has been closed,
1463	* see vboxNetFltTryDeleteIdc().
1464	*
1465	* @param pGlobals Pointer to the globals.
1466	* @sa vboxNetFltTryDeleteIdcAndGlobals()
1467	*/
1468	DECLHIDDEN(void) vboxNetFltDeleteGlobals(PVBOXNETFLTGLOBALS pGlobals)
1469	{
1470	Assert(!pGlobals->fIDCOpen);
1471
1472	/*
1473	* Release resources.
1474	*/
1475	RTSemFastMutexDestroy(pGlobals->hFastMtx);
1476	pGlobals->hFastMtx = NIL_RTSEMFASTMUTEX;
1477	}
1478
1479
1480	/**
1481	* Initializes the globals.
1482	*
1483	* @returns VBox status code.
1484	* @param pGlobals Pointer to the globals.
1485	* @sa vboxNetFltInitGlobalsAndIdc().
1486	*/
1487	DECLHIDDEN(int) vboxNetFltInitGlobals(PVBOXNETFLTGLOBALS pGlobals)
1488	{
1489	/*
1490	* Initialize the common portions of the structure.
1491	*/
1492	int rc = RTSemFastMutexCreate(&pGlobals->hFastMtx);
1493	if (RT_SUCCESS(rc))
1494	{
1495	pGlobals->pInstanceHead = NULL;
1496
1497	pGlobals->TrunkFactory.pfnRelease = vboxNetFltFactoryRelease;
1498	pGlobals->TrunkFactory.pfnCreateAndConnect = vboxNetFltFactoryCreateAndConnect;
1499	#if defined(RT_OS_WINDOWS) && defined(VBOXNETADP)
1500	memcpy(pGlobals->SupDrvFactory.szName, "VBoxNetAdp", sizeof("VBoxNetAdp"));
1501	#else
1502	memcpy(pGlobals->SupDrvFactory.szName, "VBoxNetFlt", sizeof("VBoxNetFlt"));
1503	#endif
1504	pGlobals->SupDrvFactory.pfnQueryFactoryInterface = vboxNetFltQueryFactoryInterface;
1505	pGlobals->fIDCOpen = false;
1506
1507	return rc;
1508	}
1509
1510	return rc;
1511	}
1512
1513
1514	/**
1515	* Called by the native part when the OS wants the driver to unload.
1516	*
1517	* @returns VINF_SUCCESS on success, VERR_WRONG_ORDER if we're busy.
1518	*
1519	* @param pGlobals Pointer to the globals.
1520	*/
1521	DECLHIDDEN(int) vboxNetFltTryDeleteIdcAndGlobals(PVBOXNETFLTGLOBALS pGlobals)
1522	{
1523	int rc = vboxNetFltTryDeleteIdc(pGlobals);
1524	if (RT_SUCCESS(rc))
1525	vboxNetFltDeleteGlobals(pGlobals);
1526	return rc;
1527	}
1528
1529
1530	/**
1531	* Called by the native driver/kext module initialization routine.
1532	*
1533	* It will initialize the common parts of the globals, assuming the caller
1534	* has already taken care of the OS specific bits, and establish the IDC
1535	* connection to SUPDRV.
1536	*
1537	* @returns VBox status code.
1538	* @param pGlobals Pointer to the globals.
1539	*/
1540	DECLHIDDEN(int) vboxNetFltInitGlobalsAndIdc(PVBOXNETFLTGLOBALS pGlobals)
1541	{
1542	/*
1543	* Initialize the common portions of the structure.
1544	*/
1545	int rc = vboxNetFltInitGlobals(pGlobals);
1546	if (RT_SUCCESS(rc))
1547	{
1548	rc = vboxNetFltInitIdc(pGlobals);
1549	if (RT_SUCCESS(rc))
1550	return rc;
1551
1552	/* bail out. */
1553	vboxNetFltDeleteGlobals(pGlobals);
1554	}
1555
1556	return rc;
1557	}
1558

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

source: vbox/trunk/src/VBox/HostDrivers/VBoxNetFlt/VBoxNetFlt.c@ 43417

Download in other formats: