DrvTAP.cpp@ 26300

Last change on this file since 26300 was 26300, checked in by vboxsync, 15 years ago
pdmifs.h: Moved the network interfaces to a separate header called pdmnetifs.h.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 39.0 KB

Line
1	/* $Id: DrvTAP.cpp 26300 2010-02-05 16:02:55Z vboxsync $ */
2	/** @file
3	* DrvTAP - Universial TAP network transport driver.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	#define LOG_GROUP LOG_GROUP_DRV_TUN
26	#include <VBox/log.h>
27	#include <VBox/pdmdrv.h>
28	#include <VBox/pdmnetifs.h>
29
30	#include <iprt/asm.h>
31	#include <iprt/assert.h>
32	#include <iprt/ctype.h>
33	#include <iprt/file.h>
34	#include <iprt/path.h>
35	#include <iprt/semaphore.h>
36	#include <iprt/string.h>
37	#include <iprt/thread.h>
38	#include <iprt/uuid.h>
39	#ifdef RT_OS_SOLARIS
40	# include <iprt/process.h>
41	# include <iprt/env.h>
42	# ifdef VBOX_WITH_CROSSBOW
43	# include <iprt/mem.h>
44	# endif
45	#endif
46
47	#include <sys/ioctl.h>
48	#include <sys/poll.h>
49	#ifdef RT_OS_SOLARIS
50	# include <sys/stat.h>
51	# include <sys/ethernet.h>
52	# include <sys/sockio.h>
53	# include <netinet/in.h>
54	# include <netinet/in_systm.h>
55	# include <netinet/ip.h>
56	# include <netinet/ip_icmp.h>
57	# include <netinet/udp.h>
58	# include <netinet/tcp.h>
59	# include <net/if.h>
60	# include <stropts.h>
61	# include <fcntl.h>
62	# include <stdlib.h>
63	# include <stdio.h>
64	# ifdef VBOX_WITH_CROSSBOW
65	# include "solaris/vbox-libdlpi.h"
66	# endif
67	#else
68	# include <sys/fcntl.h>
69	#endif
70	#include <errno.h>
71	#include <unistd.h>
72
73	#ifdef RT_OS_L4
74	# include <l4/vboxserver/file.h>
75	#endif
76
77	#include "Builtins.h"
78
79
80	/*******************************************************************************
81	* Structures and Typedefs *
82	*******************************************************************************/
83	/**
84	* TAP driver instance data.
85	*
86	* @implements PDMINETWORKCONNECTOR
87	*/
88	typedef struct DRVTAP
89	{
90	/** The network interface. */
91	PDMINETWORKCONNECTOR INetworkConnector;
92	/** The network interface. */
93	PPDMINETWORKPORT pPort;
94	/** Pointer to the driver instance. */
95	PPDMDRVINS pDrvIns;
96	/** TAP device file handle. */
97	RTFILE FileDevice;
98	/** The configured TAP device name. */
99	char *pszDeviceName;
100	#ifdef RT_OS_SOLARIS
101	# ifdef VBOX_WITH_CROSSBOW
102	/** Crossbow: MAC address of the device. */
103	RTMAC MacAddress;
104	/** Crossbow: Handle of the NIC. */
105	dlpi_handle_t pDeviceHandle;
106	# else
107	/** IP device file handle (/dev/udp). */
108	RTFILE IPFileDevice;
109	# endif
110	/** Whether device name is obtained from setup application. */
111	bool fStatic;
112	#endif
113	/** TAP setup application. */
114	char *pszSetupApplication;
115	/** TAP terminate application. */
116	char *pszTerminateApplication;
117	/** The write end of the control pipe. */
118	RTFILE PipeWrite;
119	/** The read end of the control pipe. */
120	RTFILE PipeRead;
121	/** Reader thread. */
122	PPDMTHREAD pThread;
123
124	#ifdef VBOX_WITH_STATISTICS
125	/** Number of sent packets. */
126	STAMCOUNTER StatPktSent;
127	/** Number of sent bytes. */
128	STAMCOUNTER StatPktSentBytes;
129	/** Number of received packets. */
130	STAMCOUNTER StatPktRecv;
131	/** Number of received bytes. */
132	STAMCOUNTER StatPktRecvBytes;
133	/** Profiling packet transmit runs. */
134	STAMPROFILE StatTransmit;
135	/** Profiling packet receive runs. */
136	STAMPROFILEADV StatReceive;
137	#endif /* VBOX_WITH_STATISTICS */
138
139	#ifdef LOG_ENABLED
140	/** The nano ts of the last transfer. */
141	uint64_t u64LastTransferTS;
142	/** The nano ts of the last receive. */
143	uint64_t u64LastReceiveTS;
144	#endif
145	} DRVTAP, *PDRVTAP;
146
147
148	/** Converts a pointer to TAP::INetworkConnector to a PRDVTAP. */
149	#define PDMINETWORKCONNECTOR_2_DRVTAP(pInterface) ( (PDRVTAP)((uintptr_t)pInterface - RT_OFFSETOF(DRVTAP, INetworkConnector)) )
150
151
152	/*******************************************************************************
153	* Internal Functions *
154	*******************************************************************************/
155	#ifdef RT_OS_SOLARIS
156	# ifdef VBOX_WITH_CROSSBOW
157	static int SolarisOpenVNIC(PDRVTAP pThis);
158	static int SolarisDLPIErr2VBoxErr(int rc);
159	# else
160	static int SolarisTAPAttach(PDRVTAP pThis);
161	# endif
162	#endif
163
164
165	/**
166	* Send data to the network.
167	*
168	* @returns VBox status code.
169	* @param pInterface Pointer to the interface structure containing the called function pointer.
170	* @param pvBuf Data to send.
171	* @param cb Number of bytes to send.
172	* @thread EMT
173	*/
174	static DECLCALLBACK(int) drvTAPSend(PPDMINETWORKCONNECTOR pInterface, const void *pvBuf, size_t cb)
175	{
176	PDRVTAP pThis = PDMINETWORKCONNECTOR_2_DRVTAP(pInterface);
177	STAM_COUNTER_INC(&pThis->StatPktSent);
178	STAM_COUNTER_ADD(&pThis->StatPktSentBytes, cb);
179	STAM_PROFILE_START(&pThis->StatTransmit, a);
180
181	#ifdef LOG_ENABLED
182	uint64_t u64Now = RTTimeProgramNanoTS();
183	LogFlow(("drvTAPSend: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
184	cb, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
185	pThis->u64LastTransferTS = u64Now;
186	#endif
187	Log2(("drvTAPSend: pvBuf=%p cb=%#x\n"
188	"%.*Rhxd\n",
189	pvBuf, cb, cb, pvBuf));
190
191	int rc = RTFileWrite(pThis->FileDevice, pvBuf, cb, NULL);
192
193	STAM_PROFILE_STOP(&pThis->StatTransmit, a);
194	AssertRC(rc);
195	return rc;
196	}
197
198
199	/**
200	* Set promiscuous mode.
201	*
202	* This is called when the promiscuous mode is set. This means that there doesn't have
203	* to be a mode change when it's called.
204	*
205	* @param pInterface Pointer to the interface structure containing the called function pointer.
206	* @param fPromiscuous Set if the adaptor is now in promiscuous mode. Clear if it is not.
207	* @thread EMT
208	*/
209	static DECLCALLBACK(void) drvTAPSetPromiscuousMode(PPDMINETWORKCONNECTOR pInterface, bool fPromiscuous)
210	{
211	LogFlow(("drvTAPSetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
212	/* nothing to do */
213	}
214
215
216	/**
217	* Notification on link status changes.
218	*
219	* @param pInterface Pointer to the interface structure containing the called function pointer.
220	* @param enmLinkState The new link state.
221	* @thread EMT
222	*/
223	static DECLCALLBACK(void) drvTAPNotifyLinkChanged(PPDMINETWORKCONNECTOR pInterface, PDMNETWORKLINKSTATE enmLinkState)
224	{
225	LogFlow(("drvNATNotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
226	/** @todo take action on link down and up. Stop the polling and such like. */
227	}
228
229
230	/**
231	* Asynchronous I/O thread for handling receive.
232	*
233	* @returns VINF_SUCCESS (ignored).
234	* @param Thread Thread handle.
235	* @param pvUser Pointer to a DRVTAP structure.
236	*/
237	static DECLCALLBACK(int) drvTAPAsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
238	{
239	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
240	LogFlow(("drvTAPAsyncIoThread: pThis=%p\n", pThis));
241
242	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
243	return VINF_SUCCESS;
244
245	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
246
247	/*
248	* Polling loop.
249	*/
250	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
251	{
252	/*
253	* Wait for something to become available.
254	*/
255	struct pollfd aFDs[2];
256	aFDs[0].fd = pThis->FileDevice;
257	aFDs[0].events = POLLIN \| POLLPRI;
258	aFDs[0].revents = 0;
259	aFDs[1].fd = pThis->PipeRead;
260	aFDs[1].events = POLLIN \| POLLPRI \| POLLERR \| POLLHUP;
261	aFDs[1].revents = 0;
262	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
263	errno=0;
264	int rc = poll(&aFDs[0], RT_ELEMENTS(aFDs), -1 /* infinite */);
265
266	/* this might have changed in the meantime */
267	if (pThread->enmState != PDMTHREADSTATE_RUNNING)
268	break;
269
270	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
271	if ( rc > 0
272	&& (aFDs[0].revents & (POLLIN \| POLLPRI))
273	&& !aFDs[1].revents)
274	{
275	/*
276	* Read the frame.
277	*/
278	char achBuf[16384];
279	size_t cbRead = 0;
280	#ifdef VBOX_WITH_CROSSBOW
281	cbRead = sizeof(achBuf);
282	rc = g_pfnLibDlpiRecv(pThis->pDeviceHandle, NULL, NULL, achBuf, &cbRead, -1, NULL);
283	rc = RT_LIKELY(rc == DLPI_SUCCESS) ? VINF_SUCCESS : SolarisDLPIErr2VBoxErr(rc);
284	#else
285	/** @note At least on Linux we will never receive more than one network packet
286	* after poll() returned successfully. I don't know why but a second
287	* RTFileRead() operation will return with VERR_TRY_AGAIN in any case. */
288	rc = RTFileRead(pThis->FileDevice, achBuf, sizeof(achBuf), &cbRead);
289	#endif
290	if (RT_SUCCESS(rc))
291	{
292	/*
293	* Wait for the device to have space for this frame.
294	* Most guests use frame-sized receive buffers, hence non-zero cbMax
295	* automatically means there is enough room for entire frame. Some
296	* guests (eg. Solaris) use large chains of small receive buffers
297	* (each 128 or so bytes large). We will still start receiving as soon
298	* as cbMax is non-zero because:
299	* - it would be quite expensive for pfnCanReceive to accurately
300	* determine free receive buffer space
301	* - if we were waiting for enough free buffers, there is a risk
302	* of deadlocking because the guest could be waiting for a receive
303	* overflow error to allocate more receive buffers
304	*/
305	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
306	int rc1 = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
307	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
308
309	/*
310	* A return code != VINF_SUCCESS means that we were woken up during a VM
311	* state transistion. Drop the packet and wait for the next one.
312	*/
313	if (RT_FAILURE(rc1))
314	continue;
315
316	/*
317	* Pass the data up.
318	*/
319	#ifdef LOG_ENABLED
320	uint64_t u64Now = RTTimeProgramNanoTS();
321	LogFlow(("drvTAPAsyncIoThread: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
322	cbRead, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
323	pThis->u64LastReceiveTS = u64Now;
324	#endif
325	Log2(("drvTAPAsyncIoThread: cbRead=%#x\n" "%.*Rhxd\n", cbRead, cbRead, achBuf));
326	STAM_COUNTER_INC(&pThis->StatPktRecv);
327	STAM_COUNTER_ADD(&pThis->StatPktRecvBytes, cbRead);
328	rc1 = pThis->pPort->pfnReceive(pThis->pPort, achBuf, cbRead);
329	AssertRC(rc1);
330	}
331	else
332	{
333	LogFlow(("drvTAPAsyncIoThread: RTFileRead -> %Rrc\n", rc));
334	if (rc == VERR_INVALID_HANDLE)
335	break;
336	RTThreadYield();
337	}
338	}
339	else if ( rc > 0
340	&& aFDs[1].revents)
341	{
342	LogFlow(("drvTAPAsyncIoThread: Control message: enmState=%d revents=%#x\n", pThread->enmState, aFDs[1].revents));
343	if (aFDs[1].revents & (POLLHUP \| POLLERR \| POLLNVAL))
344	break;
345
346	/* drain the pipe */
347	char ch;
348	size_t cbRead;
349	RTFileRead(pThis->PipeRead, &ch, 1, &cbRead);
350	}
351	else
352	{
353	/*
354	* poll() failed for some reason. Yield to avoid eating too much CPU.
355	*
356	* EINTR errors have been seen frequently. They should be harmless, even
357	* if they are not supposed to occur in our setup.
358	*/
359	if (errno == EINTR)
360	Log(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
361	else
362	AssertMsgFailed(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
363	RTThreadYield();
364	}
365	}
366
367
368	LogFlow(("drvTAPAsyncIoThread: returns %Rrc\n", VINF_SUCCESS));
369	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
370	return VINF_SUCCESS;
371	}
372
373
374	/**
375	* Unblock the send thread so it can respond to a state change.
376	*
377	* @returns VBox status code.
378	* @param pDevIns The pcnet device instance.
379	* @param pThread The send thread.
380	*/
381	static DECLCALLBACK(int) drvTapAsyncIoWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
382	{
383	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
384
385	int rc = RTFileWrite(pThis->PipeWrite, "", 1, NULL);
386	AssertRC(rc);
387
388	return VINF_SUCCESS;
389	}
390
391
392	#if defined(RT_OS_SOLARIS)
393	/**
394	* Calls OS-specific TAP setup application/script.
395	*
396	* @returns VBox error code.
397	* @param pThis The instance data.
398	*/
399	static int drvTAPSetupApplication(PDRVTAP pThis)
400	{
401	char szCommand[4096];
402
403	#ifdef VBOX_WITH_CROSSBOW
404	/* Convert MAC address bytes to string (required by Solaris' dladm). */
405	char *pszHex = "0123456789abcdef";
406	uint8_t *pMacAddr8 = pThis->MacAddress.au8;
407	char szMacAddress[3 * sizeof(RTMAC)];
408	for (unsigned int i = 0; i < sizeof(RTMAC); i++)
409	{
410	szMacAddress[3 * i] = pszHex[((*pMacAddr8 >> 4) & 0x0f)];
411	szMacAddress[3 * i + 1] = pszHex[(*pMacAddr8 & 0x0f)];
412	szMacAddress[3 * i + 2] = ':';
413	*pMacAddr8++;
414	}
415	szMacAddress[sizeof(szMacAddress) - 1] = 0;
416
417	RTStrPrintf(szCommand, sizeof(szCommand), "%s %s %s", pThis->pszSetupApplication,
418	szMacAddress, pThis->fStatic ? pThis->pszDeviceName : "");
419	#else
420	RTStrPrintf(szCommand, sizeof(szCommand), "%s %s", pThis->pszSetupApplication,
421	pThis->fStatic ? pThis->pszDeviceName : "");
422	#endif
423
424	/* Pipe open the setup application. */
425	Log2(("Starting TAP setup application: %s\n", szCommand));
426	FILE* pfSetupHandle = popen(szCommand, "r");
427	if (pfSetupHandle == 0)
428	{
429	LogRel(("TAP#%d: Failed to run TAP setup application: %s\n", pThis->pDrvIns->iInstance,
430	pThis->pszSetupApplication, strerror(errno)));
431	return VERR_HOSTIF_INIT_FAILED;
432	}
433	if (!pThis->fStatic)
434	{
435	/* Obtain device name from setup application. */
436	char acBuffer[64];
437	size_t cBufSize;
438	fgets(acBuffer, sizeof(acBuffer), pfSetupHandle);
439	cBufSize = strlen(acBuffer);
440	/* The script must return the name of the interface followed by a carriage return as the
441	first line of its output. We need a null-terminated string. */
442	if ((cBufSize < 2) \|\| (acBuffer[cBufSize - 1] != '\n'))
443	{
444	pclose(pfSetupHandle);
445	LogRel(("The TAP interface setup script did not return the name of a TAP device.\n"));
446	return VERR_HOSTIF_INIT_FAILED;
447	}
448	/* Overwrite the terminating newline character. */
449	acBuffer[cBufSize - 1] = 0;
450	RTStrAPrintf(&pThis->pszDeviceName, "%s", acBuffer);
451	}
452	int rc = pclose(pfSetupHandle);
453	if (!WIFEXITED(rc))
454	{
455	LogRel(("The TAP interface setup script terminated abnormally.\n"));
456	return VERR_HOSTIF_INIT_FAILED;
457	}
458	if (WEXITSTATUS(rc) != 0)
459	{
460	LogRel(("The TAP interface setup script returned a non-zero exit code.\n"));
461	return VERR_HOSTIF_INIT_FAILED;
462	}
463	return VINF_SUCCESS;
464	}
465
466
467	/**
468	* Calls OS-specific TAP terminate application/script.
469	*
470	* @returns VBox error code.
471	* @param pThis The instance data.
472	*/
473	static int drvTAPTerminateApplication(PDRVTAP pThis)
474	{
475	char *pszArgs[3];
476	pszArgs[0] = pThis->pszTerminateApplication;
477	pszArgs[1] = pThis->pszDeviceName;
478	pszArgs[2] = NULL;
479
480	Log2(("Starting TAP terminate application: %s %s\n", pThis->pszTerminateApplication, pThis->pszDeviceName));
481	RTPROCESS pid = NIL_RTPROCESS;
482	int rc = RTProcCreate(pszArgs[0], pszArgs, RTENV_DEFAULT, 0, &pid);
483	if (RT_SUCCESS(rc))
484	{
485	RTPROCSTATUS Status;
486	rc = RTProcWait(pid, 0, &Status);
487	if (RT_SUCCESS(rc))
488	{
489	if ( Status.iStatus == 0
490	&& Status.enmReason == RTPROCEXITREASON_NORMAL)
491	return VINF_SUCCESS;
492
493	LogRel(("TAP#%d: Error running TAP terminate application: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
494	}
495	else
496	LogRel(("TAP#%d: RTProcWait failed for: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
497	}
498	else
499	{
500	/* Bad. RTProcCreate() failed! */
501	LogRel(("TAP#%d: Failed to fork() process for running TAP terminate application: %s\n", pThis->pDrvIns->iInstance,
502	pThis->pszTerminateApplication, strerror(errno)));
503	}
504	return VERR_HOSTIF_TERM_FAILED;
505	}
506
507	#endif /* RT_OS_SOLARIS */
508
509
510	#ifdef RT_OS_SOLARIS
511	# ifdef VBOX_WITH_CROSSBOW
512	/**
513	* Crossbow: Open & configure the virtual NIC.
514	*
515	* @returns VBox error code.
516	* @param pThis The instance data.
517	*/
518	static int SolarisOpenVNIC(PDRVTAP pThis)
519	{
520	/*
521	* Open & bind the NIC using the datalink provider routine.
522	*/
523	int rc = g_pfnLibDlpiOpen(pThis->pszDeviceName, &pThis->pDeviceHandle, DLPI_RAW);
524	if (rc != DLPI_SUCCESS)
525	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
526	N_("Failed to open VNIC \"%s\" in raw mode"), pThis->pszDeviceName);
527
528	dlpi_info_t vnicInfo;
529	rc = g_pfnLibDlpiInfo(pThis->pDeviceHandle, &vnicInfo, 0);
530	if (rc == DLPI_SUCCESS)
531	{
532	if (vnicInfo.di_mactype == DL_ETHER)
533	{
534	rc = g_pfnLibDlpiBind(pThis->pDeviceHandle, DLPI_ANY_SAP, NULL);
535	if (rc == DLPI_SUCCESS)
536	{
537	rc = g_pfnLibDlpiSetPhysAddr(pThis->pDeviceHandle, DL_CURR_PHYS_ADDR, &pThis->MacAddress, ETHERADDRL);
538	if (rc == DLPI_SUCCESS)
539	{
540	rc = g_pfnLibDlpiPromiscon(pThis->pDeviceHandle, DL_PROMISC_SAP);
541	if (rc == DLPI_SUCCESS)
542	{
543	/* Need to use DL_PROMIS_PHYS (not multicast) as we cannot be sure what the guest needs. */
544	rc = g_pfnLibDlpiPromiscon(pThis->pDeviceHandle, DL_PROMISC_PHYS);
545	if (rc == DLPI_SUCCESS)
546	{
547	pThis->FileDevice = g_pfnLibDlpiFd(pThis->pDeviceHandle);
548	if (pThis->FileDevice >= 0)
549	{
550	Log(("SolarisOpenVNIC: %s -> %d\n", pThis->pszDeviceName, pThis->FileDevice));
551	return VINF_SUCCESS;
552	}
553
554	rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
555	N_("Failed to obtain file descriptor for VNIC"));
556	}
557	else
558	rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
559	N_("Failed to set appropriate promiscous mode"));
560	}
561	else
562	rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
563	N_("Failed to activate promiscous mode for VNIC"));
564	}
565	else
566	rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
567	N_("Failed to set physical address for VNIC"));
568	}
569	else
570	rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
571	N_("Failed to bind VNIC"));
572	}
573	else
574	rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
575	N_("VNIC type is not ethernet"));
576	}
577	else
578	rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
579	N_("Failed to obtain VNIC info"));
580	g_pfnLibDlpiClose(pThis->pDeviceHandle);
581	return rc;
582	}
583
584
585	/**
586	* Crossbow: Converts a Solaris DLPI error code to a VBox error code.
587	*
588	* @returns corresponding VBox error code.
589	* @param rc DLPI error code (DLPI_* defines).
590	*/
591	static int SolarisDLPIErr2VBoxErr(int rc)
592	{
593	switch (rc)
594	{
595	case DLPI_SUCCESS: return VINF_SUCCESS;
596	case DLPI_EINVAL: return VERR_INVALID_PARAMETER;
597	case DLPI_ELINKNAMEINVAL: return VERR_INVALID_NAME;
598	case DLPI_EINHANDLE: return VERR_INVALID_HANDLE;
599	case DLPI_ETIMEDOUT: return VERR_TIMEOUT;
600	case DLPI_FAILURE: return VERR_GENERAL_FAILURE;
601
602	case DLPI_EVERNOTSUP:
603	case DLPI_EMODENOTSUP:
604	case DLPI_ERAWNOTSUP:
605	/* case DLPI_ENOTENOTSUP: */
606	case DLPI_EUNAVAILSAP: return VERR_NOT_SUPPORTED;
607
608	/* Define VBox error codes for these, if really needed. */
609	case DLPI_ENOLINK:
610	case DLPI_EBADLINK:
611	/* case DLPI_ENOTEIDINVAL: */
612	case DLPI_EBADMSG:
613	case DLPI_ENOTSTYLE2: return VERR_GENERAL_FAILURE;
614	}
615
616	AssertMsgFailed(("SolarisDLPIErr2VBoxErr: Unhandled error %d\n", rc));
617	return VERR_UNRESOLVED_ERROR;
618	}
619
620	# else /* VBOX_WITH_CROSSBOW */
621
622	/** From net/if_tun.h, installed by Universal TUN/TAP driver */
623	# define TUNNEWPPA (('T'<<16) \| 0x0001)
624	/** Whether to enable ARP for TAP. */
625	# define VBOX_SOLARIS_TAP_ARP 1
626
627	/**
628	* Creates/Attaches TAP device to IP.
629	*
630	* @returns VBox error code.
631	* @param pThis The instance data.
632	*/
633	static DECLCALLBACK(int) SolarisTAPAttach(PDRVTAP pThis)
634	{
635	LogFlow(("SolarisTapAttach: pThis=%p\n", pThis));
636
637
638	int IPFileDes = open("/dev/udp", O_RDWR, 0);
639	if (IPFileDes < 0)
640	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
641	N_("Failed to open /dev/udp. errno=%d"), errno);
642
643	int TapFileDes = open("/dev/tap", O_RDWR, 0);
644	if (TapFileDes < 0)
645	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
646	N_("Failed to open /dev/tap for TAP. errno=%d"), errno);
647
648	/* Use the PPA from the ifname if possible (e.g "tap2", then use 2 as PPA) */
649	int iPPA = -1;
650	if (pThis->pszDeviceName)
651	{
652	size_t cch = strlen(pThis->pszDeviceName);
653	if (cch > 1 && RT_C_IS_DIGIT(pThis->pszDeviceName[cch - 1]) != 0)
654	iPPA = pThis->pszDeviceName[cch - 1] - '0';
655	}
656
657	struct strioctl ioIF;
658	ioIF.ic_cmd = TUNNEWPPA;
659	ioIF.ic_len = sizeof(iPPA);
660	ioIF.ic_dp = (char *)(&iPPA);
661	ioIF.ic_timout = 0;
662	iPPA = ioctl(TapFileDes, I_STR, &ioIF);
663	if (iPPA < 0)
664	{
665	close(TapFileDes);
666	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
667	N_("Failed to get new interface. errno=%d"), errno);
668	}
669
670	int InterfaceFD = open("/dev/tap", O_RDWR, 0);
671	if (!InterfaceFD)
672	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
673	N_("Failed to open interface /dev/tap. errno=%d"), errno);
674
675	if (ioctl(InterfaceFD, I_PUSH, "ip") == -1)
676	{
677	close(InterfaceFD);
678	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
679	N_("Failed to push IP. errno=%d"), errno);
680	}
681
682	struct lifreq ifReq;
683	memset(&ifReq, 0, sizeof(ifReq));
684	if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
685	LogRel(("TAP#%d: Failed to get interface flags.\n", pThis->pDrvIns->iInstance));
686
687	ifReq.lifr_ppa = iPPA;
688	RTStrPrintf (ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
689
690	if (ioctl(InterfaceFD, SIOCSLIFNAME, &ifReq) == -1)
691	LogRel(("TAP#%d: Failed to set PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
692
693	if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
694	LogRel(("TAP#%d: Failed to get interface flags after setting PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
695
696	#ifdef VBOX_SOLARIS_TAP_ARP
697	/* Interface */
698	if (ioctl(InterfaceFD, I_PUSH, "arp") == -1)
699	LogRel(("TAP#%d: Failed to push ARP to Interface FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
700
701	/* IP */
702	if (ioctl(IPFileDes, I_POP, NULL) == -1)
703	LogRel(("TAP#%d: Failed I_POP from IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
704
705	if (ioctl(IPFileDes, I_PUSH, "arp") == -1)
706	LogRel(("TAP#%d: Failed to push ARP to IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
707
708	/* ARP */
709	int ARPFileDes = open("/dev/tap", O_RDWR, 0);
710	if (ARPFileDes < 0)
711	LogRel(("TAP#%d: Failed to open for /dev/tap for ARP. errno=%d", pThis->pDrvIns->iInstance, errno));
712
713	if (ioctl(ARPFileDes, I_PUSH, "arp") == -1)
714	LogRel(("TAP#%d: Failed to push ARP to ARP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
715
716	ioIF.ic_cmd = SIOCSLIFNAME;
717	ioIF.ic_timout = 0;
718	ioIF.ic_len = sizeof(ifReq);
719	ioIF.ic_dp = (char *)&ifReq;
720	if (ioctl(ARPFileDes, I_STR, &ioIF) == -1)
721	LogRel(("TAP#%d: Failed to set interface name to ARP.\n", pThis->pDrvIns->iInstance));
722	#endif
723
724	/* We must use I_LINK and not I_PLINK as I_PLINK makes the link persistent.
725	* Then we would not be able unlink the interface if we reuse it.
726	* Even 'unplumb' won't work after that.
727	*/
728	int IPMuxID = ioctl(IPFileDes, I_LINK, InterfaceFD);
729	if (IPMuxID == -1)
730	{
731	close(InterfaceFD);
732	#ifdef VBOX_SOLARIS_TAP_ARP
733	close(ARPFileDes);
734	#endif
735	LogRel(("TAP#%d: Cannot link TAP device to IP.\n", pThis->pDrvIns->iInstance));
736	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
737	N_("Failed to link TAP device to IP. Check TAP interface name. errno=%d"), errno);
738	}
739
740	#ifdef VBOX_SOLARIS_TAP_ARP
741	int ARPMuxID = ioctl(IPFileDes, I_LINK, ARPFileDes);
742	if (ARPMuxID == -1)
743	LogRel(("TAP#%d: Failed to link TAP device to ARP\n", pThis->pDrvIns->iInstance));
744
745	close(ARPFileDes);
746	#endif
747	close(InterfaceFD);
748
749	/* Reuse ifReq */
750	memset(&ifReq, 0, sizeof(ifReq));
751	RTStrPrintf (ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
752	ifReq.lifr_ip_muxid = IPMuxID;
753	#ifdef VBOX_SOLARIS_TAP_ARP
754	ifReq.lifr_arp_muxid = ARPMuxID;
755	#endif
756
757	if (ioctl(IPFileDes, SIOCSLIFMUXID, &ifReq) == -1)
758	{
759	#ifdef VBOX_SOLARIS_TAP_ARP
760	ioctl(IPFileDes, I_PUNLINK, ARPMuxID);
761	#endif
762	ioctl(IPFileDes, I_PUNLINK, IPMuxID);
763	close(IPFileDes);
764	LogRel(("TAP#%d: Failed to set Mux ID.\n", pThis->pDrvIns->iInstance));
765	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
766	N_("Failed to set Mux ID. Check TAP interface name. errno=%d"), errno);
767	}
768
769	pThis->FileDevice = (RTFILE)TapFileDes;
770	pThis->IPFileDevice = (RTFILE)IPFileDes;
771
772	return VINF_SUCCESS;
773	}
774
775	# endif /* VBOX_WITH_CROSSBOW */
776	#endif /* RT_OS_SOLARIS */
777
778	/* -=-=-=-=- PDMIBASE -=-=-=-=- */
779
780	/**
781	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
782	*/
783	static DECLCALLBACK(void ) drvTAPQueryInterface(PPDMIBASE pInterface, const char pszIID)
784	{
785	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
786	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
787
788	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
789	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONNECTOR, &pThis->INetworkConnector);
790	return NULL;
791	}
792
793	/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
794
795	/**
796	* Destruct a driver instance.
797	*
798	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
799	* resources can be freed correctly.
800	*
801	* @param pDrvIns The driver instance data.
802	*/
803	static DECLCALLBACK(void) drvTAPDestruct(PPDMDRVINS pDrvIns)
804	{
805	LogFlow(("drvTAPDestruct\n"));
806	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
807	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
808
809	/*
810	* Terminate the control pipe.
811	*/
812	if (pThis->PipeWrite != NIL_RTFILE)
813	{
814	int rc = RTFileClose(pThis->PipeWrite);
815	AssertRC(rc);
816	pThis->PipeWrite = NIL_RTFILE;
817	}
818	if (pThis->PipeRead != NIL_RTFILE)
819	{
820	int rc = RTFileClose(pThis->PipeRead);
821	AssertRC(rc);
822	pThis->PipeRead = NIL_RTFILE;
823	}
824
825	#ifdef RT_OS_SOLARIS
826	/** @todo r=bird: This does need checking against ConsoleImpl2.cpp if used on non-solaris systems. */
827	if (pThis->FileDevice != NIL_RTFILE)
828	{
829	int rc = RTFileClose(pThis->FileDevice);
830	AssertRC(rc);
831	pThis->FileDevice = NIL_RTFILE;
832	}
833
834	# ifndef VBOX_WITH_CROSSBOW
835	if (pThis->IPFileDevice != NIL_RTFILE)
836	{
837	int rc = RTFileClose(pThis->IPFileDevice);
838	AssertRC(rc);
839	pThis->IPFileDevice = NIL_RTFILE;
840	}
841	# endif
842
843	/*
844	* Call TerminateApplication after closing the device otherwise
845	* TerminateApplication would not be able to unplumb it.
846	*/
847	if (pThis->pszTerminateApplication)
848	drvTAPTerminateApplication(pThis);
849
850	#endif /* RT_OS_SOLARIS */
851
852	#ifdef RT_OS_SOLARIS
853	if (!pThis->fStatic)
854	RTStrFree(pThis->pszDeviceName); /* allocated by drvTAPSetupApplication */
855	else
856	MMR3HeapFree(pThis->pszDeviceName);
857	#else
858	MMR3HeapFree(pThis->pszDeviceName);
859	#endif
860	MMR3HeapFree(pThis->pszSetupApplication);
861	MMR3HeapFree(pThis->pszTerminateApplication);
862
863	#ifdef VBOX_WITH_STATISTICS
864	/*
865	* Deregister statistics.
866	*/
867	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSent);
868	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSentBytes);
869	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecv);
870	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecvBytes);
871	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatTransmit);
872	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatReceive);
873	#endif /* VBOX_WITH_STATISTICS */
874	}
875
876
877	/**
878	* Construct a TAP network transport driver instance.
879	*
880	* @copydoc FNPDMDRVCONSTRUCT
881	*/
882	static DECLCALLBACK(int) drvTAPConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
883	{
884	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
885	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
886
887	/*
888	* Init the static parts.
889	*/
890	pThis->pDrvIns = pDrvIns;
891	pThis->FileDevice = NIL_RTFILE;
892	pThis->pszDeviceName = NULL;
893	#ifdef RT_OS_SOLARIS
894	# ifdef VBOX_WITH_CROSSBOW
895	pThis->pDeviceHandle = NULL;
896	# else
897	pThis->IPFileDevice = NIL_RTFILE;
898	# endif
899	pThis->fStatic = true;
900	#endif
901	pThis->pszSetupApplication = NULL;
902	pThis->pszTerminateApplication = NULL;
903
904	/* IBase */
905	pDrvIns->IBase.pfnQueryInterface = drvTAPQueryInterface;
906	/* INetwork */
907	pThis->INetworkConnector.pfnSend = drvTAPSend;
908	pThis->INetworkConnector.pfnSetPromiscuousMode = drvTAPSetPromiscuousMode;
909	pThis->INetworkConnector.pfnNotifyLinkChanged = drvTAPNotifyLinkChanged;
910
911	/*
912	* Validate the config.
913	*/
914	if (!CFGMR3AreValuesValid(pCfg, "Device\0InitProg\0TermProg\0FileHandle\0TAPSetupApplication\0TAPTerminateApplication\0MAC"))
915	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, "");
916
917	/*
918	* Check that no-one is attached to us.
919	*/
920	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
921	("Configuration error: Not possible to attach anything to this driver!\n"),
922	VERR_PDM_DRVINS_NO_ATTACH);
923
924	/*
925	* Query the network port interface.
926	*/
927	pThis->pPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKPORT);
928	if (!pThis->pPort)
929	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
930	N_("Configuration error: The above device/driver didn't export the network port interface"));
931
932	/*
933	* Read the configuration.
934	*/
935	int rc;
936	#if defined(RT_OS_SOLARIS) /** @todo Other platforms' TAP code should be moved here from ConsoleImpl & VBoxBFE. */
937	rc = CFGMR3QueryStringAlloc(pCfg, "TAPSetupApplication", &pThis->pszSetupApplication);
938	if (RT_SUCCESS(rc))
939	{
940	if (!RTPathExists(pThis->pszSetupApplication))
941	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
942	N_("Invalid TAP setup program path: %s"), pThis->pszSetupApplication);
943	}
944	else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
945	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: failed to query \"TAPTerminateApplication\""));
946
947	rc = CFGMR3QueryStringAlloc(pCfg, "TAPTerminateApplication", &pThis->pszTerminateApplication);
948	if (RT_SUCCESS(rc))
949	{
950	if (!RTPathExists(pThis->pszTerminateApplication))
951	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
952	N_("Invalid TAP terminate program path: %s"), pThis->pszTerminateApplication);
953	}
954	else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
955	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: failed to query \"TAPTerminateApplication\""));
956
957	# ifdef VBOX_WITH_CROSSBOW
958	rc = CFGMR3QueryBytes(pCfg, "MAC", &pThis->MacAddress, sizeof(pThis->MacAddress));
959	if (RT_FAILURE(rc))
960	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: Failed to query \"MAC\""));
961	# endif
962
963	rc = CFGMR3QueryStringAlloc(pCfg, "Device", &pThis->pszDeviceName);
964	if (RT_FAILURE(rc))
965	pThis->fStatic = false;
966
967	/* Obtain the device name from the setup application (if none was specified). */
968	if (pThis->pszSetupApplication)
969	{
970	rc = drvTAPSetupApplication(pThis);
971	if (RT_FAILURE(rc))
972	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
973	N_("Error running TAP setup application. rc=%d"), rc);
974	}
975
976	/*
977	* Do the setup.
978	*/
979	# ifdef VBOX_WITH_CROSSBOW
980	if (!VBoxLibDlpiFound())
981	{
982	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
983	N_("Failed to load library %s required for host interface networking."), LIB_DLPI);
984	}
985	rc = SolarisOpenVNIC(pThis);
986	# else
987	rc = SolarisTAPAttach(pThis);
988	# endif
989	if (RT_FAILURE(rc))
990	return rc;
991
992	#else /* !RT_OS_SOLARIS */
993
994	int32_t iFile;
995	rc = CFGMR3QueryS32(pCfg, "FileHandle", &iFile);
996	if (RT_FAILURE(rc))
997	return PDMDRV_SET_ERROR(pDrvIns, rc,
998	N_("Configuration error: Query for \"FileHandle\" 32-bit signed integer failed"));
999	pThis->FileDevice = (RTFILE)iFile;
1000	if (!RTFileIsValid(pThis->FileDevice))
1001	return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_HANDLE, RT_SRC_POS,
1002	N_("The TAP file handle %RTfile is not valid"), pThis->FileDevice);
1003	#endif /* !RT_OS_SOLARIS */
1004
1005	/*
1006	* Make sure the descriptor is non-blocking and valid.
1007	*
1008	* We should actually query if it's a TAP device, but I haven't
1009	* found any way to do that.
1010	*/
1011	if (fcntl(pThis->FileDevice, F_SETFL, O_NONBLOCK) == -1)
1012	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
1013	N_("Configuration error: Failed to configure /dev/net/tun. errno=%d"), errno);
1014	/** @todo determine device name. This can be done by reading the link /proc/<pid>/fd/<fd> */
1015	Log(("drvTAPContruct: %d (from fd)\n", pThis->FileDevice));
1016	rc = VINF_SUCCESS;
1017
1018	/*
1019	* Create the control pipe.
1020	*/
1021	int fds[2];
1022	#ifdef RT_OS_L4
1023	/* XXX We need to tell the library which interface we are using */
1024	fds[0] = vboxrtLinuxFd2VBoxFd(VBOXRT_FT_TAP, 0);
1025	#endif
1026	if (pipe(&fds[0]) != 0) /** @todo RTPipeCreate() or something... */
1027	{
1028	rc = RTErrConvertFromErrno(errno);
1029	AssertRC(rc);
1030	return rc;
1031	}
1032	pThis->PipeRead = fds[0];
1033	pThis->PipeWrite = fds[1];
1034
1035	/*
1036	* Create the async I/O thread.
1037	*/
1038	rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pThread, pThis, drvTAPAsyncIoThread, drvTapAsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "TAP");
1039	AssertRCReturn(rc, rc);
1040
1041	#ifdef VBOX_WITH_STATISTICS
1042	/*
1043	* Statistics.
1044	*/
1045	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of sent packets.", "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
1046	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of sent bytes.", "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
1047	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of received packets.", "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
1048	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of received bytes.", "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
1049	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
1050	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.", "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
1051	#endif /* VBOX_WITH_STATISTICS */
1052
1053	return rc;
1054	}
1055
1056
1057	/**
1058	* TAP network transport driver registration record.
1059	*/
1060	const PDMDRVREG g_DrvHostInterface =
1061	{
1062	/* u32Version */
1063	PDM_DRVREG_VERSION,
1064	/* szName */
1065	"HostInterface",
1066	/* szRCMod */
1067	"",
1068	/* szR0Mod */
1069	"",
1070	/* pszDescription */
1071	"TAP Network Transport Driver",
1072	/* fFlags */
1073	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1074	/* fClass. */
1075	PDM_DRVREG_CLASS_NETWORK,
1076	/* cMaxInstances */
1077	~0,
1078	/* cbInstance */
1079	sizeof(DRVTAP),
1080	/* pfnConstruct */
1081	drvTAPConstruct,
1082	/* pfnDestruct */
1083	drvTAPDestruct,
1084	/* pfnRelocate */
1085	NULL,
1086	/* pfnIOCtl */
1087	NULL,
1088	/* pfnPowerOn */
1089	NULL,
1090	/* pfnReset */
1091	NULL,
1092	/* pfnSuspend */
1093	NULL, /** @todo Do power on, suspend and resume handlers! */
1094	/* pfnResume */
1095	NULL,
1096	/* pfnAttach */
1097	NULL,
1098	/* pfnDetach */
1099	NULL,
1100	/* pfnPowerOff */
1101	NULL,
1102	/* pfnSoftReset */
1103	NULL,
1104	/* u32EndVersion */
1105	PDM_DRVREG_VERSION
1106	};
1107

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

source: vbox/trunk/src/VBox/Devices/Network/DrvTAP.cpp@ 26300

Download in other formats: