DrvTAP.cpp@ 61

Last change on this file since 61 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.0 KB

Line
1	/** @file
2	*
3	* VBox network devices:
4	* Linux TAP network transport driver
5	*/
6
7	/*
8	*
9	* Copyright (C) 2006 InnoTek Systemberatung GmbH
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License as published by the Free Software Foundation,
15	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
16	* distribution. VirtualBox OSE is distributed in the hope that it will
17	* be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* If you received this file as part of a commercial VirtualBox
20	* distribution, then only the terms of your commercial VirtualBox
21	* license agreement apply instead of the previous paragraph.
22	*
23	*/
24
25	#define ASYNC_NET
26
27	/*******************************************************************************
28	* Header Files *
29	*******************************************************************************/
30	#define LOG_GROUP LOG_GROUP_DRV_TUN
31	#include <VBox/cfgm.h>
32	#include <VBox/err.h>
33	#include <VBox/log.h>
34	#include <VBox/mm.h>
35	#include <VBox/pdm.h>
36
37	#include <iprt/assert.h>
38	#include <iprt/file.h>
39	#include <iprt/string.h>
40	#ifdef ASYNC_NET
41	#include <iprt/thread.h>
42	#include <iprt/asm.h>
43	#include <iprt/semaphore.h>
44	#endif
45
46	#include <sys/ioctl.h>
47	#include <sys/poll.h>
48	#include <sys/fcntl.h>
49	#include <errno.h>
50	#ifdef ASYNC_NET
51	#include <unistd.h>
52	#endif
53
54	#include "Builtins.h"
55
56
57	/*******************************************************************************
58	* Structures and Typedefs *
59	*******************************************************************************/
60	typedef enum ASYNCSTATE
61	{
62	//ASYNCSTATE_SUSPENDED = 1,
63	ASYNCSTATE_RUNNING,
64	ASYNCSTATE_TERMINATE
65	} ASYNCSTATE;
66
67	/**
68	* Block driver instance data.
69	*/
70	typedef struct DRVTAP
71	{
72	/** The network interface. */
73	PDMINETWORKCONNECTOR INetworkConnector;
74	/** The network interface. */
75	PPDMINETWORKPORT pPort;
76	/** Pointer to the driver instance. */
77	PPDMDRVINS pDrvIns;
78	/** TAP device file handle. */
79	RTFILE FileDevice;
80	#ifdef ASYNC_NET
81	/** The write end of the control pipe. */
82	RTFILE PipeWrite;
83	/** The read end of the control pipe. */
84	RTFILE PipeRead;
85	/** The thread state. */
86	ASYNCSTATE volatile enmState;
87	/** Reader thread. */
88	RTTHREAD Thread;
89	/** We are waiting for more receive buffers. */
90	uint32_t volatile fOutOfSpace;
91	/** Event semaphore for blocking on receive. */
92	RTSEMEVENT EventOutOfSpace;
93	#endif
94
95	#ifdef VBOX_WITH_STATISTICS
96	/** Number of sent packets. */
97	STAMCOUNTER StatPktSent;
98	/** Number of sent bytes. */
99	STAMCOUNTER StatPktSentBytes;
100	/** Number of received packets. */
101	STAMCOUNTER StatPktRecv;
102	/** Number of received bytes. */
103	STAMCOUNTER StatPktRecvBytes;
104	/** Profiling packet transmit runs. */
105	STAMPROFILE StatTransmit;
106	/** Profiling packet receive runs. */
107	STAMPROFILEADV StatReceive;
108	#ifdef ASYNC_NET
109	STAMPROFILE StatRecvOverflows;
110	#endif
111	#endif /* VBOX_WITH_STATISTICS */
112
113	#ifdef LOG_ENABLED
114	/** The nano ts of the last transfer. */
115	uint64_t u64LastTransferTS;
116	/** The nano ts of the last receive. */
117	uint64_t u64LastReceiveTS;
118	#endif
119	} DRVTAP, *PDRVTAP;
120
121
122	/** Converts a pointer to TAP::INetworkConnector to a PRDVTAP. */
123	#define PDMINETWORKCONNECTOR_2_DRVTAP(pInterface) ( (PDRVTAP)((uintptr_t)pInterface - RT_OFFSETOF(DRVTAP, INetworkConnector)) )
124
125
126	/**
127	* Send data to the network.
128	*
129	* @returns VBox status code.
130	* @param pInterface Pointer to the interface structure containing the called function pointer.
131	* @param pvBuf Data to send.
132	* @param cb Number of bytes to send.
133	* @thread EMT
134	*/
135	static DECLCALLBACK(int) drvTAPSend(PPDMINETWORKCONNECTOR pInterface, const void *pvBuf, size_t cb)
136	{
137	PDRVTAP pData = PDMINETWORKCONNECTOR_2_DRVTAP(pInterface);
138	STAM_COUNTER_INC(&pData->StatPktSent);
139	STAM_COUNTER_ADD(&pData->StatPktSentBytes, cb);
140	STAM_PROFILE_START(&pData->StatTransmit, a);
141
142	#ifdef LOG_ENABLED
143	uint64_t u64Now = RTTimeProgramNanoTS();
144	LogFlow(("drvTAPSend: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
145	cb, u64Now, u64Now - pData->u64LastReceiveTS, u64Now - pData->u64LastTransferTS));
146	pData->u64LastTransferTS = u64Now;
147	#endif
148	Log2(("drvTAPSend: pvBuf=%p cb=%#x\n"
149	"%.*Vhxd\n",
150	pvBuf, cb, cb, pvBuf));
151
152	int rc = RTFileWrite(pData->FileDevice, pvBuf, cb, NULL);
153
154	STAM_PROFILE_STOP(&pData->StatTransmit, a);
155	AssertRC(rc);
156	return rc;
157	}
158
159
160	/**
161	* Set promiscuous mode.
162	*
163	* This is called when the promiscuous mode is set. This means that there doesn't have
164	* to be a mode change when it's called.
165	*
166	* @param pInterface Pointer to the interface structure containing the called function pointer.
167	* @param fPromiscuous Set if the adaptor is now in promiscuous mode. Clear if it is not.
168	* @thread EMT
169	*/
170	static DECLCALLBACK(void) drvTAPSetPromiscuousMode(PPDMINETWORKCONNECTOR pInterface, bool fPromiscuous)
171	{
172	LogFlow(("drvTAPSetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
173	/* nothing to do */
174	}
175
176
177	/**
178	* Notification on link status changes.
179	*
180	* @param pInterface Pointer to the interface structure containing the called function pointer.
181	* @param enmLinkState The new link state.
182	* @thread EMT
183	*/
184	static DECLCALLBACK(void) drvTAPNotifyLinkChanged(PPDMINETWORKCONNECTOR pInterface, PDMNETWORKLINKSTATE enmLinkState)
185	{
186	LogFlow(("drvNATNotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
187	/** @todo take action on link down and up. Stop the polling and such like. */
188	}
189
190
191	/**
192	* More receive buffer has become available.
193	*
194	* This is called when the NIC frees up receive buffers.
195	*
196	* @param pInterface Pointer to the interface structure containing the called function pointer.
197	* @thread EMT
198	*/
199	static DECLCALLBACK(void) drvTAPNotifyCanReceive(PPDMINETWORKCONNECTOR pInterface)
200	{
201	PDRVTAP pData = PDMINETWORKCONNECTOR_2_DRVTAP(pInterface);
202
203	LogFlow(("drvTAPNotifyCanReceive:\n"));
204	/* ensure we wake up only once */
205	if (ASMAtomicXchgU32(&pData->fOutOfSpace, false))
206	RTSemEventSignal(pData->EventOutOfSpace);
207	}
208
209
210	#ifdef ASYNC_NET
211	/**
212	* Asynchronous I/O thread for handling receive.
213	*
214	* @returns VINF_SUCCESS (ignored).
215	* @param Thread Thread handle.
216	* @param pvUser Pointer to a DRVTAP structure.
217	*/
218	static DECLCALLBACK(int) drvTAPAsyncIoThread(RTTHREAD ThreadSelf, void *pvUser)
219	{
220	PDRVTAP pData = (PDRVTAP)pvUser;
221	LogFlow(("drvTAPAsyncIoThread: pData=%p\n", pData));
222	STAM_PROFILE_ADV_START(&pData->StatReceive, a);
223
224	int rc = RTSemEventCreate(&pData->EventOutOfSpace);
225	AssertRC(rc);
226
227	/*
228	* Polling loop.
229	*/
230	for (;;)
231	{
232	/*
233	* Wait for something to become available.
234	*/
235	struct pollfd aFDs[2];
236	aFDs[0].fd = pData->FileDevice;
237	aFDs[0].events = POLLIN \| POLLPRI;
238	aFDs[0].revents = 0;
239	aFDs[1].fd = pData->PipeRead;
240	aFDs[1].events = POLLIN \| POLLPRI \| POLLERR \| POLLHUP;
241	aFDs[1].revents = 0;
242	STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
243	errno=0;
244	rc = poll(&aFDs[0], ELEMENTS(aFDs), -1 /* infinite */);
245	STAM_PROFILE_ADV_START(&pData->StatReceive, a);
246	if ( rc > 0
247	&& (aFDs[0].revents & (POLLIN \| POLLPRI))
248	&& !aFDs[1].revents)
249	{
250	/*
251	* Read the frame.
252	*/
253	char achBuf[4096];
254	unsigned cbRead = 0;
255	rc = RTFileRead(pData->FileDevice, achBuf, sizeof(achBuf), &cbRead);
256	if (VBOX_SUCCESS(rc))
257	{
258	AssertMsg(cbRead <= 1536, ("cbRead=%d\n", cbRead));
259
260	/*
261	* Wait for the device to have space for this frame.
262	*/
263	size_t cbMax = pData->pPort->pfnCanReceive(pData->pPort);
264	if (cbMax < cbRead)
265	{
266	/** @todo receive overflow handling needs serious improving! */
267	STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
268	STAM_PROFILE_START(&pData->StatRecvOverflows, b);
269	while ( cbMax < cbRead
270	&& pData->enmState != ASYNCSTATE_TERMINATE)
271	{
272	LogFlow(("drvTAPAsyncIoThread: cbMax=%d cbRead=%d waiting...\n", cbMax, cbRead));
273	#if 1
274	/* We get signalled by the network driver. 50ms is just for sanity */
275	ASMAtomicXchgU32(&pData->fOutOfSpace, true);
276	RTSemEventWait(pData->EventOutOfSpace, 50);
277	#else
278	RTThreadSleep(1);
279	#endif
280	cbMax = pData->pPort->pfnCanReceive(pData->pPort);
281	}
282	ASMAtomicXchgU32(&pData->fOutOfSpace, false);
283	STAM_PROFILE_STOP(&pData->StatRecvOverflows, b);
284	STAM_PROFILE_ADV_START(&pData->StatReceive, a);
285	if (pData->enmState == ASYNCSTATE_TERMINATE)
286	break;
287	}
288
289	/*
290	* Pass the data up.
291	*/
292	#ifdef LOG_ENABLED
293	uint64_t u64Now = RTTimeProgramNanoTS();
294	LogFlow(("drvTAPAsyncIoThread: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
295	cbRead, u64Now, u64Now - pData->u64LastReceiveTS, u64Now - pData->u64LastTransferTS));
296	pData->u64LastReceiveTS = u64Now;
297	#endif
298	Log2(("drvTAPAsyncIoThread: cbRead=%#x\n"
299	"%.*Vhxd\n",
300	cbRead, cbRead, achBuf));
301	STAM_COUNTER_INC(&pData->StatPktRecv);
302	STAM_COUNTER_ADD(&pData->StatPktRecvBytes, cbRead);
303	rc = pData->pPort->pfnReceive(pData->pPort, achBuf, cbRead);
304	AssertRC(rc);
305	}
306	else
307	{
308	LogFlow(("drvTAPAsyncIoThread: RTFileRead -> %Vrc\n", rc));
309	if (rc == VERR_INVALID_HANDLE)
310	break;
311	RTThreadYield();
312	}
313	}
314	else if ( rc > 0
315	&& aFDs[1].revents)
316	{
317	LogFlow(("drvTAPAsyncIoThread: Control message: enmState=%d revents=%#x\n", pData->enmState, aFDs[1].revents));
318	if (pData->enmState == ASYNCSTATE_TERMINATE)
319	break;
320	if (aFDs[1].revents & (POLLHUP \| POLLERR \| POLLNVAL))
321	break;
322
323	/* drain the pipe */
324	char ch;
325	unsigned cbRead;
326	RTFileRead(pData->PipeRead, &ch, 1, &cbRead);
327	}
328	else
329	{
330	/*
331	* poll() failed for some reason. Yield to avoid eating too much CPU.
332	*
333	* EINTR errors have been seen frequently. They should be harmless, even
334	* if they are not supposed to occur in our setup.
335	*/
336	if (errno == EINTR)
337	Log(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
338	else
339	AssertMsgFailed(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
340	RTThreadYield();
341	}
342	}
343
344	rc = RTSemEventDestroy(pData->EventOutOfSpace);
345	AssertRC(rc);
346
347	LogFlow(("drvTAPAsyncIoThread: returns %Vrc\n", VINF_SUCCESS));
348	STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
349	return VINF_SUCCESS;
350	}
351
352	#else
353	/**
354	* Poller callback.
355	*/
356	static DECLCALLBACK(void) drvTAPPoller(PPDMDRVINS pDrvIns)
357	{
358	/* check how much the device/driver can receive now. */
359	PDRVTAP pData = PDMINS2DATA(pDrvIns, PDRVTAP);
360	STAM_PROFILE_ADV_START(&pData->StatReceive, a);
361
362	size_t cbMax = pData->pPort->pfnCanReceive(pData->pPort);
363	while (cbMax > 0)
364	{
365	/* check for data to read */
366	struct pollfd aFDs[1];
367	aFDs[0].fd = pData->FileDevice;
368	aFDs[0].events = POLLIN \| POLLPRI;
369	aFDs[0].revents = 0;
370	if (poll(&aFDs[0], 1, 0) > 0)
371	{
372	if (aFDs[0].revents & (POLLIN \| POLLPRI))
373	{
374	/* data waiting, read it. */
375	char achBuf[4096];
376	unsigned cbRead = 0;
377	int rc = RTFileRead(pData->FileDevice, achBuf, RT_MIN(sizeof(achBuf), cbMax), &cbRead);
378	if (VBOX_SUCCESS(rc))
379	{
380	STAM_COUNTER_INC(&pData->StatPktRecv);
381	STAM_COUNTER_ADD(&pData->StatPktRecvBytes, cbRead);
382
383	/* push it up to guy over us. */
384	Log2(("drvTAPPoller: cbRead=%#x\n"
385	"%.*Vhxd\n",
386	cbRead, cbRead, achBuf));
387	rc = pData->pPort->pfnReceive(pData->pPort, achBuf, cbRead);
388	AssertRC(rc);
389	}
390	else
391	AssertRC(rc);
392	if (VBOX_FAILURE(rc) \|\| !cbRead)
393	break;
394	}
395	else
396	break;
397	}
398	else
399	break;
400
401	cbMax = pData->pPort->pfnCanReceive(pData->pPort);
402	}
403
404	STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
405	}
406	#endif
407
408
409	/**
410	* Queries an interface to the driver.
411	*
412	* @returns Pointer to interface.
413	* @returns NULL if the interface was not supported by the driver.
414	* @param pInterface Pointer to this interface structure.
415	* @param enmInterface The requested interface identification.
416	* @thread Any thread.
417	*/
418	static DECLCALLBACK(void *) drvTAPQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
419	{
420	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
421	PDRVTAP pData = PDMINS2DATA(pDrvIns, PDRVTAP);
422	switch (enmInterface)
423	{
424	case PDMINTERFACE_BASE:
425	return &pDrvIns->IBase;
426	case PDMINTERFACE_NETWORK_CONNECTOR:
427	return &pData->INetworkConnector;
428	default:
429	return NULL;
430	}
431	}
432
433
434	/**
435	* Destruct a driver instance.
436	*
437	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
438	* resources can be freed correctly.
439	*
440	* @param pDrvIns The driver instance data.
441	*/
442	static DECLCALLBACK(void) drvTAPDestruct(PPDMDRVINS pDrvIns)
443	{
444	LogFlow(("drvTAPDestruct\n"));
445	#ifdef ASYNC_NET
446	PDRVTAP pData = PDMINS2DATA(pDrvIns, PDRVTAP);
447
448	/*
449	* Terminate the Async I/O Thread.
450	*/
451	ASMAtomicXchgSize(&pData->enmState, ASYNCSTATE_TERMINATE);
452	if (pData->Thread != NIL_RTTHREAD)
453	{
454	/* Ensure that it does not spin in the CanReceive loop */
455	if (ASMAtomicXchgU32(&pData->fOutOfSpace, false))
456	RTSemEventSignal(pData->EventOutOfSpace);
457
458	int rc = RTFileWrite(pData->PipeWrite, "", 1, NULL);
459	AssertRC(rc);
460	rc = RTThreadWait(pData->Thread, 5000, NULL);
461	AssertRC(rc);
462	pData->Thread = NIL_RTTHREAD;
463	}
464
465	/*
466	* Terminate the control pipe.
467	*/
468	if (pData->PipeWrite != NIL_RTFILE)
469	{
470	int rc = RTFileClose(pData->PipeWrite);
471	AssertRC(rc);
472	pData->PipeWrite = NIL_RTFILE;
473	}
474	if (pData->PipeRead != NIL_RTFILE)
475	{
476	int rc = RTFileClose(pData->PipeRead);
477	AssertRC(rc);
478	pData->PipeRead = NIL_RTFILE;
479	}
480	#endif
481	}
482
483
484	/**
485	* Construct a TAP network transport driver instance.
486	*
487	* @returns VBox status.
488	* @param pDrvIns The driver instance data.
489	* If the registration structure is needed, pDrvIns->pDrvReg points to it.
490	* @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
491	* of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
492	* iInstance it's expected to be used a bit in this function.
493	*/
494	static DECLCALLBACK(int) drvTAPConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
495	{
496	PDRVTAP pData = PDMINS2DATA(pDrvIns, PDRVTAP);
497
498	/*
499	* Init the static parts.
500	*/
501	pData->pDrvIns = pDrvIns;
502	pData->FileDevice = NIL_RTFILE;
503	#ifdef ASYNC_NET
504	pData->Thread = NIL_RTTHREAD;
505	pData->enmState = ASYNCSTATE_RUNNING;
506	#endif
507	/* IBase */
508	pDrvIns->IBase.pfnQueryInterface = drvTAPQueryInterface;
509	/* INetwork */
510	pData->INetworkConnector.pfnSend = drvTAPSend;
511	pData->INetworkConnector.pfnSetPromiscuousMode = drvTAPSetPromiscuousMode;
512	pData->INetworkConnector.pfnNotifyLinkChanged = drvTAPNotifyLinkChanged;
513	pData->INetworkConnector.pfnNotifyCanReceive = drvTAPNotifyCanReceive;
514
515	/*
516	* Validate the config.
517	*/
518	if (!CFGMR3AreValuesValid(pCfgHandle, "Device\0InitProg\0TermProg\0FileHandle\0"))
519	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, "");
520
521	/*
522	* Check that no-one is attached to us.
523	*/
524	int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, NULL);
525	if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
526	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_NO_ATTACH,
527	N_("Configuration error: Cannot attach drivers to the TAP driver!"));
528
529	/*
530	* Query the network port interface.
531	*/
532	pData->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
533	if (!pData->pPort)
534	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
535	N_("Configuration error: The above device/driver didn't export the network port interface!"));
536
537	/*
538	* Read the configuration.
539	*/
540	int32_t iFile;
541	rc = CFGMR3QueryS32(pCfgHandle, "FileHandle", &iFile);
542	if (VBOX_FAILURE(rc))
543	return PDMDRV_SET_ERROR(pDrvIns, rc,
544	N_("Configuration error: Query for \"FileHandle\" 32-bit signed integer failed!"));
545	pData->FileDevice = (RTFILE)iFile;
546	if (!RTFileIsValid(pData->FileDevice))
547	return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_HANDLE, RT_SRC_POS,
548	N_("The TAP file handle %RTfile is not valid!"), pData->FileDevice);
549
550	/*
551	* Make sure the descriptor is non-blocking and valid.
552	*
553	* We should actually query if it's a TAP device, but I haven't
554	* found any way to do that.
555	*/
556	if (fcntl(pData->FileDevice, F_SETFL, O_NONBLOCK) == -1)
557	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
558	N_("Configuration error: Failed to configure /dev/net/tun. errno=%d"), errno);
559	/** @todo determine device name. This can be done by reading the link /proc/<pid>/fd/<fd> */
560	Log(("drvTAPContruct: %d (from fd)\n", pData->FileDevice));
561	rc = VINF_SUCCESS;
562
563	#ifdef ASYNC_NET
564	/*
565	* Create the control pipe.
566	*/
567	int fds[2];
568	if (pipe(&fds[0]) != 0) /** @todo RTPipeCreate() or something... */
569	{
570	int rc = RTErrConvertFromErrno(errno);
571	AssertRC(rc);
572	return rc;
573	}
574	pData->PipeRead = fds[0];
575	pData->PipeWrite = fds[1];
576
577	/*
578	* Create the async I/O thread.
579	*/
580	rc = RTThreadCreate(&pData->Thread, drvTAPAsyncIoThread, pData, 128*_1K, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "TAP");
581	AssertRCReturn(rc, rc);
582	#else
583	/*
584	* Register poller
585	*/
586	rc = pDrvIns->pDrvHlp->pfnPDMPollerRegister(pDrvIns, drvTAPPoller);
587	AssertRCReturn(rc, rc);
588	#endif
589
590	#ifdef VBOX_WITH_STATISTICS
591	/*
592	* Statistics.
593	*/
594	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktSent, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of sent packets.", "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
595	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of sent bytes.", "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
596	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktRecv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of received packets.", "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
597	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of received bytes.", "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
598	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
599	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.", "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
600	# ifdef ASYNC_NET
601	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatRecvOverflows, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling packet receive overflows.", "/Drivers/TAP%d/RecvOverflows", pDrvIns->iInstance);
602	# endif
603	#endif /* VBOX_WITH_STATISTICS */
604
605	return rc;
606	}
607
608
609	/**
610	* TAP network transport driver registration record.
611	*/
612	const PDMDRVREG g_DrvHostInterface =
613	{
614	/* u32Version */
615	PDM_DRVREG_VERSION,
616	/* szDriverName */
617	"HostInterface",
618	/* pszDescription */
619	"TAP Network Transport Driver",
620	/* fFlags */
621	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
622	/* fClass. */
623	PDM_DRVREG_CLASS_NETWORK,
624	/* cMaxInstances */
625	~0,
626	/* cbInstance */
627	sizeof(DRVTAP),
628	/* pfnConstruct */
629	drvTAPConstruct,
630	/* pfnDestruct */
631	drvTAPDestruct,
632	/* pfnIOCtl */
633	NULL,
634	/* pfnPowerOn */
635	NULL,
636	/* pfnReset */
637	NULL,
638	/* pfnSuspend */
639	NULL, /** @todo Do power on, suspend and resume handlers! */
640	/* pfnResume */
641	NULL,
642	/* pfnDetach */
643	NULL,
644	/* pfnPowerOff */
645	NULL
646	};

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

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

Download in other formats: