VirtualBox

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

Last change on this file since 3481 was 2981, checked in by vboxsync, 17 years ago

InnoTek -> innotek: all the headers and comments.
  • 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-2007 innotek 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*******************************************************************************/
60typedef enum ASYNCSTATE
61{
62 //ASYNCSTATE_SUSPENDED = 1,
63 ASYNCSTATE_RUNNING,
64 ASYNCSTATE_TERMINATE
65} ASYNCSTATE;
66
67/**
68 * Block driver instance data.
69 */
70typedef 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 */
135static 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 */
170static 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 */
184static 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 */
199static 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 */
218static 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 */
356static 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 */
418static 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 */
442static 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 */
494static 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 */
612const 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.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette