VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/DrvTAPOs2.cpp@ 11311

Last change on this file since 11311 was 11267, checked in by vboxsync, 16 years ago

Devices: PDMINS2DATA -> PDMINS_2_DATA.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.6 KB
Line 
1/** $Id: DrvTAPOs2.cpp 11267 2008-08-08 16:15:43Z vboxsync $ */
2/** @file
3 * VBox network devices: OS/2 TAP network transport driver.
4 */
5
6/*
7 *
8 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 *
18 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19 * Clara, CA 95054 USA or visit http://www.sun.com if you need
20 * additional information or have any questions.
21 */
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#define LOG_GROUP LOG_GROUP_DRV_TUN
27#include <VBox/pdmdrv.h>
28
29#include <iprt/assert.h>
30#include <iprt/file.h>
31#include <iprt/string.h>
32#include <iprt/thread.h>
33#include <iprt/alloca.h>
34#include <iprt/asm.h>
35#include <iprt/semaphore.h>
36
37#include "Builtins.h"
38
39#define INCL_BASE
40#include <os2.h>
41#include "DrvTAPOs2.h"
42
43
44
45/*******************************************************************************
46* Structures and Typedefs *
47*******************************************************************************/
48
49/**
50 * Block driver instance data.
51 */
52typedef struct DRVTAPOS2
53{
54 /** The network interface. */
55 PDMINETWORKCONNECTOR INetworkConnector;
56 /** The network interface. */
57 PPDMINETWORKPORT pPort;
58 /** Pointer to the driver instance. */
59 PPDMDRVINS pDrvIns;
60 /** TAP device file handle. */
61 RTFILE hDevice;
62 /** Out LAN number. */
63 int32_t iLan;
64 /** The LAN number we're connected to. -1 if not connected. */
65 int32_t iConnectedTo;
66 /** Receiver thread. */
67 PPDMTHREAD pThread;
68 /** Set if the link is down.
69 * When the link is down all incoming packets will be dropped. */
70 bool volatile fLinkDown;
71 /** The log and thread name. */
72 char szName[16];
73 /** The \DEV\TAP$ device name. */
74 char szDevice[32];
75
76#ifdef VBOX_WITH_STATISTICS
77 /** Number of sent packets. */
78 STAMCOUNTER StatPktSent;
79 /** Number of sent bytes. */
80 STAMCOUNTER StatPktSentBytes;
81 /** Number of received packets. */
82 STAMCOUNTER StatPktRecv;
83 /** Number of received bytes. */
84 STAMCOUNTER StatPktRecvBytes;
85 /** Profiling packet transmit runs. */
86 STAMPROFILE StatTransmit;
87 /** Profiling packet receive runs. */
88 STAMPROFILEADV StatReceive;
89#endif /* VBOX_WITH_STATISTICS */
90
91#ifdef LOG_ENABLED
92 /** The nano ts of the last transfer. */
93 uint64_t u64LastTransferTS;
94 /** The nano ts of the last receive. */
95 uint64_t u64LastReceiveTS;
96#endif
97} DRVTAPOS2, *PDRVTAPOS2;
98
99
100/** Converts a pointer to TAP::INetworkConnector to a PRDVTAP. */
101#define PDMINETWORKCONNECTOR_2_DRVTAPOS2(pInterface) ( (PDRVTAPOS2)((uintptr_t)pInterface - RT_OFFSETOF(DRVTAPOS2, INetworkConnector)) )
102
103
104/**
105 * Send data to the network.
106 *
107 * @returns VBox status code.
108 * @param pInterface Pointer to the interface structure containing the called function pointer.
109 * @param pvBuf Data to send.
110 * @param cb Number of bytes to send.
111 * @thread EMT
112 */
113static DECLCALLBACK(int) drvTAPOs2Send(PPDMINETWORKCONNECTOR pInterface, const void *pvBuf, size_t cb)
114{
115 PDRVTAPOS2 pThis = PDMINETWORKCONNECTOR_2_DRVTAPOS2(pInterface);
116 STAM_COUNTER_INC(&pThis->StatPktSent);
117 STAM_COUNTER_ADD(&pThis->StatPktSentBytes, cb);
118 STAM_PROFILE_START(&pThis->StatTransmit, a);
119
120 /*
121 * If the pvBuf is a high address, we'll have to copy it onto a
122 * stack buffer of the tap driver will trap.
123 */
124 if ((uintptr_t)pvBuf >= _1M*512)
125 {
126 void *pvBufCopy = alloca(cb);
127 memcpy(pvBufCopy, pvBuf, cb);
128 pvBuf = pvBufCopy;
129 }
130
131#ifdef LOG_ENABLED
132 uint64_t u64Now = RTTimeProgramNanoTS();
133 LogFlow(("%s: Send: %-4d bytes at %RU64 ns deltas: recv=%RU64 xmit=%RU64\n", pThis->szName,
134 cb, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
135 pThis->u64LastTransferTS = u64Now;
136 Log2(("%s Send: pvBuf=%p cb=%#zx\n"
137 "%.*Vhxd\n",
138 pThis->szName, pvBuf, cb, cb, pvBuf));
139#endif
140
141 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
142 ULONG cbParm = sizeof(Parm);
143 ULONG cbData = cb;
144 int rc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_WRITE_PACKET,
145 &Parm[0], cbParm, &cbParm,
146 (void *)pvBuf, cbData, &cbData);
147 if (RT_UNLIKELY(rc || Parm[0]))
148 {
149 static unsigned cComplaints = 0;
150 if (cComplaints++ < 256)
151 LogRel(("%s: send failed. rc=%d Parm={%ld,%ld} cb=%d\n",
152 pThis->szName, rc, Parm[0], Parm[1], cb));
153 if (rc)
154 rc = RTErrConvertFromOS2(rc);
155 else
156 rc = VERR_IO_GEN_FAILURE;
157 }
158 Log3(("%s: Send completed %d ns\n", pThis->szName, RTTimeProgramNanoTS() - pThis->u64LastTransferTS));
159
160 STAM_PROFILE_STOP(&pThis->StatTransmit, a);
161 AssertRC(rc);
162 return rc;
163}
164
165
166/**
167 * Set promiscuous mode.
168 *
169 * This is called when the promiscuous mode is set. This means that there doesn't have
170 * to be a mode change when it's called.
171 *
172 * @param pInterface Pointer to the interface structure containing the called function pointer.
173 * @param fPromiscuous Set if the adaptor is now in promiscuous mode. Clear if it is not.
174 * @thread EMT
175 */
176static DECLCALLBACK(void) drvTAPOs2SetPromiscuousMode(PPDMINETWORKCONNECTOR pInterface, bool fPromiscuous)
177{
178 PDRVTAPOS2 pThis = PDMINETWORKCONNECTOR_2_DRVTAPOS2(pInterface);
179 LogFlow(("%s: SetPromiscuousMode: fPromiscuous=%d\n", pThis->szName, fPromiscuous));
180 NOREF(pThis);
181 /** @todo is it always in promiscuous mode? */
182}
183
184
185/**
186 * Notification on link status changes.
187 *
188 * @param pInterface Pointer to the interface structure containing the called function pointer.
189 * @param enmLinkState The new link state.
190 * @thread EMT
191 */
192static DECLCALLBACK(void) drvTAPOs2NotifyLinkChanged(PPDMINETWORKCONNECTOR pInterface, PDMNETWORKLINKSTATE enmLinkState)
193{
194 PDRVTAPOS2 pThis = PDMINETWORKCONNECTOR_2_DRVTAPOS2(pInterface);
195 bool fLinkDown;
196 switch (enmLinkState)
197 {
198 case PDMNETWORKLINKSTATE_DOWN:
199 case PDMNETWORKLINKSTATE_DOWN_RESUME:
200 fLinkDown = true;
201 break;
202 default:
203 AssertMsgFailed(("enmLinkState=%d\n", enmLinkState));
204 case PDMNETWORKLINKSTATE_UP:
205 fLinkDown = false;
206 break;
207 }
208 LogFlow(("%s: NotifyLinkChanged: enmLinkState=%d %d->%d\n", pThis->szName, pThis->fLinkDown, fLinkDown));
209 ASMAtomicXchgBool(&pThis->fLinkDown, fLinkDown);
210}
211
212
213/**
214 * Receiver thread.
215 *
216 * @returns VBox status code. Returning failure will naturally terminate the thread.
217 * @param pDrvIns The pcnet device instance.
218 * @param pThread The thread.
219 */
220static DECLCALLBACK(int) drvTAPOs2ReceiveThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
221{
222 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
223
224 /*
225 * No initialization work to do, just return immediately.
226 */
227 if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
228 return VINF_SUCCESS;
229 Assert(pThread->enmState == PDMTHREADSTATE_RUNNING);
230
231 /*
232 * Loop while the thread is running, quit immediately when
233 * we're supposed to suspend or terminate.
234 */
235 while (pThread->enmState == PDMTHREADSTATE_RUNNING)
236 {
237 /*
238 * Read a frame, this will block for a while if nothing to read.
239 */
240 char abBuf[4096];
241 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
242 ULONG cbParm = sizeof(Parm); /* this one is actually ignored... */
243 ULONG cbBuf = sizeof(abBuf);
244
245 int rc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_READ_PACKET,
246 &Parm[0], cbParm, &cbParm,
247 &abBuf[0], cbBuf, &cbBuf);
248 if (pThread->enmState != PDMTHREADSTATE_RUNNING)
249 break;
250 const size_t cbRead = Parm[1];
251 if ( !rc
252 && !Parm[0]
253 && cbRead > 0 /* cbRead */)
254 {
255 AssertMsg(cbRead <= 1536, ("cbRead=%d\n", cbRead));
256
257 /*
258 * Wait for the device to have some room. A return code != VINF_SUCCESS
259 * means that we were woken up during a VM state transition. Drop the
260 * current packet and wait for the next one.
261 */
262 rc = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
263 if (RT_FAILURE(rc))
264 continue;
265
266 /*
267 * Pass the data up.
268 */
269#ifdef LOG_ENABLED
270 uint64_t u64Now = RTTimeProgramNanoTS();
271 LogFlow(("%s: ReceiveThread: %-4d bytes at %RU64 ns deltas: recv=%RU64 xmit=%RU64\n", pThis->szName,
272 cbRead, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
273 pThis->u64LastReceiveTS = u64Now;
274#endif
275 Log2(("%s: ReceiveThread: cbRead=%#x\n"
276 "%.*Vhxd\n",
277 pThis->szName, cbRead, cbRead, abBuf));
278 STAM_COUNTER_INC(&pThis->StatPktRecv);
279 STAM_COUNTER_ADD(&pThis->StatPktRecvBytes, cbRead);
280 rc = pThis->pPort->pfnReceive(pThis->pPort, abBuf, cbRead);
281 AssertRC(rc);
282 }
283 /* we'll be returning ~1 per second with no data; rc=0 Parm[0] = 1, Parm[1] = 0. */
284 else if (rc)
285 {
286 LogFlow(("%s: ReceiveThread: DoDevIOCtl -> %s Parm={%ld, %ld}\n",
287 pThis->szName, rc, Parm[0], Parm[1]));
288 rc = RTErrConvertFromOS2(rc);
289 if (rc == VERR_INVALID_HANDLE)
290 return rc;
291 RTThreadYield();
292 }
293 }
294
295 /* The thread is being suspended or terminated. */
296 return VINF_SUCCESS;
297}
298
299
300/**
301 * Unblock the send thread so it can respond to a state change.
302 *
303 * @returns VBox status code.
304 * @param pDrvIns The pcnet device instance.
305 * @param pThread The send thread.
306 */
307static DECLCALLBACK(int) drvTAPOs2WakeupReceiveThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
308{
309 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
310 LogFlow(("%s: WakeupReceiveThread\n", pThis->szName));
311
312 /* cancel any pending reads */
313 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
314 ULONG cbParm = sizeof(Parm);
315 ULONG Data = pThis->iLan; /* right? */
316 ULONG cbData = sizeof(Data);
317 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_CANCEL_READ,
318 &Parm[0], cbParm, &cbParm,
319 &Data, cbData, &cbData);
320 AssertMsg(orc == 0, ("%d\n", orc)); NOREF(orc);
321
322 return VINF_SUCCESS;
323}
324
325
326/**
327 * Queries an interface to the driver.
328 *
329 * @returns Pointer to interface.
330 * @returns NULL if the interface was not supported by the driver.
331 * @param pInterface Pointer to this interface structure.
332 * @param enmInterface The requested interface identification.
333 * @thread Any thread.
334 */
335static DECLCALLBACK(void *) drvTAPOs2QueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
336{
337 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
338 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
339 switch (enmInterface)
340 {
341 case PDMINTERFACE_BASE:
342 return &pDrvIns->IBase;
343 case PDMINTERFACE_NETWORK_CONNECTOR:
344 return &pThis->INetworkConnector;
345 default:
346 return NULL;
347 }
348}
349
350
351/**
352 * Destruct a driver instance.
353 *
354 * Most VM resources are freed by the VM. This callback is provided so that any non-VM
355 * resources can be freed correctly.
356 *
357 * @param pDrvIns The driver instance data.
358 */
359static DECLCALLBACK(void) drvTAPOs2Destruct(PPDMDRVINS pDrvIns)
360{
361 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
362 LogFlow(("%s: Destruct\n", pThis->szName));
363
364 /* PDM will destroy the thread for us, it's suspended right now. */
365
366 /*
367 * Disconnect from the lan if we made a connection and close it.
368 */
369 if (pThis->iConnectedTo != -1)
370 {
371 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
372 ULONG cbParm = sizeof(Parm);
373 ULONG Data = pThis->iConnectedTo;
374 ULONG cbData = sizeof(Data);
375 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_DISCONNECT_NIC,
376 &Parm, cbParm, &cbParm,
377 &Data, cbData, &cbData);
378 if ( orc
379 || Parm[0])
380 LogRel(("%s: Failed to disconnect %d from %d! orc=%d Parm={%ld,%ld}\n",
381 pThis->szName, pThis->iLan, pThis->iConnectedTo, orc, Parm[0], Parm[1]));
382 pThis->iConnectedTo = -1;
383 }
384
385 if (pThis->hDevice != NIL_RTFILE)
386 {
387 int rc = RTFileClose(pThis->hDevice);
388 AssertRC(rc);
389 pThis->hDevice = NIL_RTFILE;
390 }
391}
392
393
394/**
395 * Construct a TAP network transport driver instance.
396 *
397 * @returns VBox status.
398 * @param pDrvIns The driver instance data.
399 * If the registration structure is needed, pDrvIns->pDrvReg points to it.
400 * @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
401 * of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
402 * iInstance it's expected to be used a bit in this function.
403 */
404static DECLCALLBACK(int) drvTAPOs2Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
405{
406 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
407
408 /*
409 * Init the static parts.
410 */
411 pThis->pDrvIns = pDrvIns;
412 pThis->hDevice = NIL_RTFILE;
413 pThis->iLan = -1;
414 pThis->iConnectedTo = -1;
415 pThis->pThread = NULL;
416 RTStrPrintf(pThis->szName, sizeof(pThis->szName), "TAP%d", pDrvIns->iInstance);
417 /* IBase */
418 pDrvIns->IBase.pfnQueryInterface = drvTAPOs2QueryInterface;
419 /* INetwork */
420 pThis->INetworkConnector.pfnSend = drvTAPOs2Send;
421 pThis->INetworkConnector.pfnSetPromiscuousMode = drvTAPOs2SetPromiscuousMode;
422 pThis->INetworkConnector.pfnNotifyLinkChanged = drvTAPOs2NotifyLinkChanged;
423
424 /*
425 * Validate the config.
426 */
427 if (!CFGMR3AreValuesValid(pCfgHandle, "Device\0ConnectTo\0"))
428 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, "");
429
430 /*
431 * Check that no-one is attached to us.
432 */
433 int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, NULL);
434 if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
435 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_NO_ATTACH,
436 N_("Configuration error: Cannot attach drivers to the TAP driver"));
437
438 /*
439 * Query the network port interface.
440 */
441 pThis->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
442 if (!pThis->pPort)
443 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
444 N_("Configuration error: The above device/driver didn't export the network port interface"));
445
446 /*
447 * Read the configuration.
448 */
449 rc = CFGMR3QueryString(pCfgHandle, "Device", &pThis->szDevice[0], sizeof(pThis->szDevice));
450 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
451 strcpy(pThis->szDevice, "\\DEV\\TAP$");
452 else if (RT_FAILURE(rc))
453 return PDMDRV_SET_ERROR(pDrvIns, rc,
454 N_("Configuration error: Query for \"Device\" failed"));
455
456 int32_t iConnectTo;
457 rc = CFGMR3QueryS32(pCfgHandle, "ConnectTo", &iConnectTo);
458 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
459 iConnectTo = -1;
460 else if (RT_FAILURE(rc))
461 return PDMDRV_SET_ERROR(pDrvIns, rc,
462 N_("Configuration error: Query for \"ConnectTo\" failed"));
463
464 /*
465 * Open the device.
466 * Keep in mind that the destructor is always called!
467 */
468 rc = RTFileOpen(&pThis->hDevice, pThis->szDevice, RTFILE_O_DENY_NONE | RTFILE_O_READ);
469 if (RT_FAILURE(rc))
470 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
471 N_("Failed to open tap device '%s'"), pThis->szDevice);
472
473 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
474 ULONG cbParm = sizeof(Parm);
475 ULONG Data = ~0UL;
476 ULONG cbData = sizeof(Data);
477 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_GET_LAN_NUMBER,
478 &Parm, cbParm, &cbParm,
479 &Data, cbData, &cbData);
480 if (orc)
481 rc = RTErrConvertFromOS2(orc);
482 else if (Parm[0])
483 rc = VERR_GENERAL_FAILURE;
484 if (RT_FAILURE(rc))
485 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
486 N_("Failed to query LanNumber! orc=%d Parm={%ld,%ld}"),
487 orc, Parm[0], Parm[1]);
488 pThis->iLan = (int32_t)Data;
489 Log(("%s: iLan=%d Parm[1]=%ld\n", pThis->szName, pThis->iLan, Parm[1]));
490
491 /*
492 * Connect it requested.
493 */
494 if (iConnectTo != -1)
495 {
496 if (iConnectTo == pThis->iLan)
497 return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
498 N_("Cannot connect to ourself (%d)"), iConnectTo);
499
500 Parm[0] = Parm[1] = ~0UL; /* mysterious output */
501 cbParm = sizeof(Parm);
502 Data = iConnectTo;
503 cbData = sizeof(Data);
504 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_CONNECT_NIC,
505 &Parm, cbParm, &cbParm,
506 &Data, cbData, &cbData);
507 if (orc)
508 rc = RTErrConvertFromOS2(orc);
509 else if (Parm[0])
510 rc = VERR_GENERAL_FAILURE;
511 if (RT_FAILURE(rc))
512 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
513 N_("Failed to connect %d to %d! orc=%d Parm={%ld,%ld}"),
514 pThis->iLan, iConnectTo, orc, Parm[0], Parm[1]);
515 Log(("%s: Connected to %d\n", pThis->szName, iConnectTo));
516 pThis->iConnectedTo = iConnectTo;
517 }
518
519 /*
520 * Log the config.
521 */
522 Parm[0] = Parm[1] = ~0UL; /* mysterious output */
523 RTMAC Mac;
524 cbParm = sizeof(Parm);
525 cbData = sizeof(Mac);
526 orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_READ_MAC_ADDRESS,
527 &Parm[0], cbParm, &cbParm,
528 &Mac, cbData, &cbData);
529 if ( !orc
530 && !Parm[0]
531 /*&& !Parm[1]?*/)
532 LogRel(("%s: iLan=%d iConnectedTo=%d Mac=%02x:%02x:%02x:%02x:%02x:%02x\n",
533 pThis->szName, pThis->iLan, pThis->iConnectedTo,
534 Mac.au8[0], Mac.au8[1], Mac.au8[2], Mac.au8[3], Mac.au8[4], Mac.au8[5]));
535 else
536 LogRel(("%s: iLan=%d iConnectedTo Mac=failed - orc=%d Parm={%ld,%ld}\n",
537 pThis->szName, pThis->iLan, pThis->iConnectedTo, Parm[0], Parm[1]));
538
539 rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pThread, pThis, drvTAPOs2ReceiveThread, drvTAPOs2WakeupReceiveThread,
540 0, RTTHREADTYPE_IO, pThis->szName);
541 AssertRCReturn(rc, rc);
542
543#ifdef VBOX_WITH_STATISTICS
544 /*
545 * Statistics.
546 */
547 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of sent packets.", "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
548 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of sent bytes.", "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
549 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of received packets.", "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
550 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of received bytes.", "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
551 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
552 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.", "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
553#endif /* VBOX_WITH_STATISTICS */
554
555 return rc;
556}
557
558
559/**
560 * TAP network transport driver registration record.
561 */
562const PDMDRVREG g_DrvHostInterface =
563{
564 /* u32Version */
565 PDM_DRVREG_VERSION,
566 /* szDriverName */
567 "HostInterface",
568 /* pszDescription */
569 "TAP Network Transport Driver",
570 /* fFlags */
571 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
572 /* fClass. */
573 PDM_DRVREG_CLASS_NETWORK,
574 /* cMaxInstances */
575 ~0,
576 /* cbInstance */
577 sizeof(DRVTAPOS2),
578 /* pfnConstruct */
579 drvTAPOs2Construct,
580 /* pfnDestruct */
581 drvTAPOs2Destruct,
582 /* pfnIOCtl */
583 NULL,
584 /* pfnPowerOn */
585 NULL,
586 /* pfnReset */
587 NULL,
588 /* pfnSuspend */
589 NULL,
590 /* pfnResume */
591 NULL,
592 /* pfnDetach */
593 NULL,
594 /* pfnPowerOff */
595 NULL
596};
597
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