VirtualBox

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

Last change on this file since 15505 was 13840, checked in by vboxsync, 16 years ago

Hex format types (Vhx[sd] -> Rhx[sd]).
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.5 KB
Line 
1/** $Id: DrvTAPOs2.cpp 13840 2008-11-05 03:31:46Z 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 "%.*Rhxd\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[16384];
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 /*
256 * Wait for the device to have some room. A return code != VINF_SUCCESS
257 * means that we were woken up during a VM state transition. Drop the
258 * current packet and wait for the next one.
259 */
260 rc = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
261 if (RT_FAILURE(rc))
262 continue;
263
264 /*
265 * Pass the data up.
266 */
267#ifdef LOG_ENABLED
268 uint64_t u64Now = RTTimeProgramNanoTS();
269 LogFlow(("%s: ReceiveThread: %-4d bytes at %RU64 ns deltas: recv=%RU64 xmit=%RU64\n", pThis->szName,
270 cbRead, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
271 pThis->u64LastReceiveTS = u64Now;
272#endif
273 Log2(("%s: ReceiveThread: cbRead=%#x\n"
274 "%.*Rhxd\n",
275 pThis->szName, cbRead, cbRead, abBuf));
276 STAM_COUNTER_INC(&pThis->StatPktRecv);
277 STAM_COUNTER_ADD(&pThis->StatPktRecvBytes, cbRead);
278 rc = pThis->pPort->pfnReceive(pThis->pPort, abBuf, cbRead);
279 AssertRC(rc);
280 }
281 /* we'll be returning ~1 per second with no data; rc=0 Parm[0] = 1, Parm[1] = 0. */
282 else if (rc)
283 {
284 LogFlow(("%s: ReceiveThread: DoDevIOCtl -> %s Parm={%ld, %ld}\n",
285 pThis->szName, rc, Parm[0], Parm[1]));
286 rc = RTErrConvertFromOS2(rc);
287 if (rc == VERR_INVALID_HANDLE)
288 return rc;
289 RTThreadYield();
290 }
291 }
292
293 /* The thread is being suspended or terminated. */
294 return VINF_SUCCESS;
295}
296
297
298/**
299 * Unblock the send thread so it can respond to a state change.
300 *
301 * @returns VBox status code.
302 * @param pDrvIns The pcnet device instance.
303 * @param pThread The send thread.
304 */
305static DECLCALLBACK(int) drvTAPOs2WakeupReceiveThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
306{
307 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
308 LogFlow(("%s: WakeupReceiveThread\n", pThis->szName));
309
310 /* cancel any pending reads */
311 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
312 ULONG cbParm = sizeof(Parm);
313 ULONG Data = pThis->iLan; /* right? */
314 ULONG cbData = sizeof(Data);
315 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_CANCEL_READ,
316 &Parm[0], cbParm, &cbParm,
317 &Data, cbData, &cbData);
318 AssertMsg(orc == 0, ("%d\n", orc)); NOREF(orc);
319
320 return VINF_SUCCESS;
321}
322
323
324/**
325 * Queries an interface to the driver.
326 *
327 * @returns Pointer to interface.
328 * @returns NULL if the interface was not supported by the driver.
329 * @param pInterface Pointer to this interface structure.
330 * @param enmInterface The requested interface identification.
331 * @thread Any thread.
332 */
333static DECLCALLBACK(void *) drvTAPOs2QueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
334{
335 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
336 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
337 switch (enmInterface)
338 {
339 case PDMINTERFACE_BASE:
340 return &pDrvIns->IBase;
341 case PDMINTERFACE_NETWORK_CONNECTOR:
342 return &pThis->INetworkConnector;
343 default:
344 return NULL;
345 }
346}
347
348
349/**
350 * Destruct a driver instance.
351 *
352 * Most VM resources are freed by the VM. This callback is provided so that any non-VM
353 * resources can be freed correctly.
354 *
355 * @param pDrvIns The driver instance data.
356 */
357static DECLCALLBACK(void) drvTAPOs2Destruct(PPDMDRVINS pDrvIns)
358{
359 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
360 LogFlow(("%s: Destruct\n", pThis->szName));
361
362 /* PDM will destroy the thread for us, it's suspended right now. */
363
364 /*
365 * Disconnect from the lan if we made a connection and close it.
366 */
367 if (pThis->iConnectedTo != -1)
368 {
369 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
370 ULONG cbParm = sizeof(Parm);
371 ULONG Data = pThis->iConnectedTo;
372 ULONG cbData = sizeof(Data);
373 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_DISCONNECT_NIC,
374 &Parm, cbParm, &cbParm,
375 &Data, cbData, &cbData);
376 if ( orc
377 || Parm[0])
378 LogRel(("%s: Failed to disconnect %d from %d! orc=%d Parm={%ld,%ld}\n",
379 pThis->szName, pThis->iLan, pThis->iConnectedTo, orc, Parm[0], Parm[1]));
380 pThis->iConnectedTo = -1;
381 }
382
383 if (pThis->hDevice != NIL_RTFILE)
384 {
385 int rc = RTFileClose(pThis->hDevice);
386 AssertRC(rc);
387 pThis->hDevice = NIL_RTFILE;
388 }
389}
390
391
392/**
393 * Construct a TAP network transport driver instance.
394 *
395 * @returns VBox status.
396 * @param pDrvIns The driver instance data.
397 * If the registration structure is needed, pDrvIns->pDrvReg points to it.
398 * @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
399 * of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
400 * iInstance it's expected to be used a bit in this function.
401 */
402static DECLCALLBACK(int) drvTAPOs2Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
403{
404 PDRVTAPOS2 pThis = PDMINS_2_DATA(pDrvIns, PDRVTAPOS2);
405
406 /*
407 * Init the static parts.
408 */
409 pThis->pDrvIns = pDrvIns;
410 pThis->hDevice = NIL_RTFILE;
411 pThis->iLan = -1;
412 pThis->iConnectedTo = -1;
413 pThis->pThread = NULL;
414 RTStrPrintf(pThis->szName, sizeof(pThis->szName), "TAP%d", pDrvIns->iInstance);
415 /* IBase */
416 pDrvIns->IBase.pfnQueryInterface = drvTAPOs2QueryInterface;
417 /* INetwork */
418 pThis->INetworkConnector.pfnSend = drvTAPOs2Send;
419 pThis->INetworkConnector.pfnSetPromiscuousMode = drvTAPOs2SetPromiscuousMode;
420 pThis->INetworkConnector.pfnNotifyLinkChanged = drvTAPOs2NotifyLinkChanged;
421
422 /*
423 * Validate the config.
424 */
425 if (!CFGMR3AreValuesValid(pCfgHandle, "Device\0ConnectTo\0"))
426 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, "");
427
428 /*
429 * Check that no-one is attached to us.
430 */
431 int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, NULL);
432 if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
433 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_NO_ATTACH,
434 N_("Configuration error: Cannot attach drivers to the TAP driver"));
435
436 /*
437 * Query the network port interface.
438 */
439 pThis->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
440 if (!pThis->pPort)
441 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
442 N_("Configuration error: The above device/driver didn't export the network port interface"));
443
444 /*
445 * Read the configuration.
446 */
447 rc = CFGMR3QueryString(pCfgHandle, "Device", &pThis->szDevice[0], sizeof(pThis->szDevice));
448 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
449 strcpy(pThis->szDevice, "\\DEV\\TAP$");
450 else if (RT_FAILURE(rc))
451 return PDMDRV_SET_ERROR(pDrvIns, rc,
452 N_("Configuration error: Query for \"Device\" failed"));
453
454 int32_t iConnectTo;
455 rc = CFGMR3QueryS32(pCfgHandle, "ConnectTo", &iConnectTo);
456 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
457 iConnectTo = -1;
458 else if (RT_FAILURE(rc))
459 return PDMDRV_SET_ERROR(pDrvIns, rc,
460 N_("Configuration error: Query for \"ConnectTo\" failed"));
461
462 /*
463 * Open the device.
464 * Keep in mind that the destructor is always called!
465 */
466 rc = RTFileOpen(&pThis->hDevice, pThis->szDevice, RTFILE_O_DENY_NONE | RTFILE_O_READ);
467 if (RT_FAILURE(rc))
468 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
469 N_("Failed to open tap device '%s'"), pThis->szDevice);
470
471 ULONG Parm[2] = { ~0UL, ~0UL }; /* mysterious output */
472 ULONG cbParm = sizeof(Parm);
473 ULONG Data = ~0UL;
474 ULONG cbData = sizeof(Data);
475 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_GET_LAN_NUMBER,
476 &Parm, cbParm, &cbParm,
477 &Data, cbData, &cbData);
478 if (orc)
479 rc = RTErrConvertFromOS2(orc);
480 else if (Parm[0])
481 rc = VERR_GENERAL_FAILURE;
482 if (RT_FAILURE(rc))
483 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
484 N_("Failed to query LanNumber! orc=%d Parm={%ld,%ld}"),
485 orc, Parm[0], Parm[1]);
486 pThis->iLan = (int32_t)Data;
487 Log(("%s: iLan=%d Parm[1]=%ld\n", pThis->szName, pThis->iLan, Parm[1]));
488
489 /*
490 * Connect it requested.
491 */
492 if (iConnectTo != -1)
493 {
494 if (iConnectTo == pThis->iLan)
495 return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
496 N_("Cannot connect to ourself (%d)"), iConnectTo);
497
498 Parm[0] = Parm[1] = ~0UL; /* mysterious output */
499 cbParm = sizeof(Parm);
500 Data = iConnectTo;
501 cbData = sizeof(Data);
502 int orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_CONNECT_NIC,
503 &Parm, cbParm, &cbParm,
504 &Data, cbData, &cbData);
505 if (orc)
506 rc = RTErrConvertFromOS2(orc);
507 else if (Parm[0])
508 rc = VERR_GENERAL_FAILURE;
509 if (RT_FAILURE(rc))
510 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
511 N_("Failed to connect %d to %d! orc=%d Parm={%ld,%ld}"),
512 pThis->iLan, iConnectTo, orc, Parm[0], Parm[1]);
513 Log(("%s: Connected to %d\n", pThis->szName, iConnectTo));
514 pThis->iConnectedTo = iConnectTo;
515 }
516
517 /*
518 * Log the config.
519 */
520 Parm[0] = Parm[1] = ~0UL; /* mysterious output */
521 RTMAC Mac;
522 cbParm = sizeof(Parm);
523 cbData = sizeof(Mac);
524 orc = DosDevIOCtl(pThis->hDevice, PROT_CATEGORY, TAP_READ_MAC_ADDRESS,
525 &Parm[0], cbParm, &cbParm,
526 &Mac, cbData, &cbData);
527 if ( !orc
528 && !Parm[0]
529 /*&& !Parm[1]?*/)
530 LogRel(("%s: iLan=%d iConnectedTo=%d Mac=%02x:%02x:%02x:%02x:%02x:%02x\n",
531 pThis->szName, pThis->iLan, pThis->iConnectedTo,
532 Mac.au8[0], Mac.au8[1], Mac.au8[2], Mac.au8[3], Mac.au8[4], Mac.au8[5]));
533 else
534 LogRel(("%s: iLan=%d iConnectedTo Mac=failed - orc=%d Parm={%ld,%ld}\n",
535 pThis->szName, pThis->iLan, pThis->iConnectedTo, Parm[0], Parm[1]));
536
537 rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pThread, pThis, drvTAPOs2ReceiveThread, drvTAPOs2WakeupReceiveThread,
538 0, RTTHREADTYPE_IO, pThis->szName);
539 AssertRCReturn(rc, rc);
540
541#ifdef VBOX_WITH_STATISTICS
542 /*
543 * Statistics.
544 */
545 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of sent packets.", "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
546 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of sent bytes.", "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
547 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of received packets.", "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
548 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of received bytes.", "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
549 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
550 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.", "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
551#endif /* VBOX_WITH_STATISTICS */
552
553 return rc;
554}
555
556
557/**
558 * TAP network transport driver registration record.
559 */
560const PDMDRVREG g_DrvHostInterface =
561{
562 /* u32Version */
563 PDM_DRVREG_VERSION,
564 /* szDriverName */
565 "HostInterface",
566 /* pszDescription */
567 "TAP Network Transport Driver",
568 /* fFlags */
569 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
570 /* fClass. */
571 PDM_DRVREG_CLASS_NETWORK,
572 /* cMaxInstances */
573 ~0,
574 /* cbInstance */
575 sizeof(DRVTAPOS2),
576 /* pfnConstruct */
577 drvTAPOs2Construct,
578 /* pfnDestruct */
579 drvTAPOs2Destruct,
580 /* pfnIOCtl */
581 NULL,
582 /* pfnPowerOn */
583 NULL,
584 /* pfnReset */
585 NULL,
586 /* pfnSuspend */
587 NULL,
588 /* pfnResume */
589 NULL,
590 /* pfnDetach */
591 NULL,
592 /* pfnPowerOff */
593 NULL
594};
595
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