DrvTAP.cpp@ 20708

Last change on this file since 20708 was 20708, checked in by vboxsync, 15 years ago
DrvIntNet,DrvTAP: Deregister statistics during destruction. (untested)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 39.4 KB

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

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

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

Download in other formats: