VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/DrvDedicatedNic.cpp@ 86327

Last change on this file since 86327 was 82968, checked in by vboxsync, 5 years ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.1 KB
Line 
1/* $Id: DrvDedicatedNic.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * DrvDedicatedNic - Experimental network driver for using a dedicated (V)NIC.
4 */
5
6/*
7 * Copyright (C) 2010-2020 Oracle Corporation
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
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_DEFAULT
23#include <VBox/log.h>
24#include <VBox/vmm/pdmcritsect.h>
25#include <VBox/vmm/pdmdrv.h>
26#include <VBox/vmm/pdmnetifs.h>
27#include <VBox/vmm/pdmnetinline.h>
28#include <VBox/intnet.h>
29#include <VBox/intnetinline.h>
30
31#include <iprt/asm.h>
32#include <iprt/assert.h>
33#include <iprt/mem.h>
34#include <iprt/path.h>
35#include <iprt/string.h>
36#include <iprt/thread.h>
37#include <iprt/uuid.h>
38
39#include "VBoxDD.h"
40
41
42/*********************************************************************************************************************************
43* Structures and Typedefs *
44*********************************************************************************************************************************/
45/**
46 * Instance data for the dedicated (V)NIC driver.
47 *
48 * @implements PDMINETWORKUP
49 */
50typedef struct DRVDEDICATEDNIC
51{
52 /** The network interface. */
53 PDMINETWORKUP INetworkUpR3;
54 /** The network interface. */
55 R3PTRTYPE(PPDMINETWORKDOWN) pIAboveNet;
56 /** The network config interface.
57 * Can (in theory at least) be NULL. */
58 R3PTRTYPE(PPDMINETWORKCONFIG) pIAboveConfigR3;
59 /** Pointer to the driver instance. */
60 PPDMDRVINSR3 pDrvInsR3;
61 /** Ring-3 base interface for the ring-0 context. */
62 PDMIBASER0 IBaseR0;
63 /** Ring-3 base interface for the raw-mode context. */
64 PDMIBASERC IBaseRC;
65 RTR3PTR R3PtrAlignment;
66
67
68 /** The network interface for the ring-0 context. */
69 PDMINETWORKUPR0 INetworkUpR0;
70 /** Pointer to the driver instance. */
71 PPDMDRVINSR0 pDrvInsR0;
72 RTR0PTR R0PtrAlignment;
73
74 /** The interface we're talking to. */
75 R0PTRTYPE(PINTNETTRUNKIFPORT) pIfPortR0;
76 /** Set if the link is up, clear if its down. */
77 bool fLinkDown;
78 /** Set if the current transmit operation is done the XMIT thread. If clear,
79 * we assume its an EMT. */
80 bool fXmitOnXmitThread;
81 /** The name of the interface that we're connected to. */
82 char szIfName[128 + 8 - 2];
83
84 /** Critical section serializing transmission. */
85 PDMCRITSECT XmitLock;
86 /** The transmit scatter gather buffer (ring-3 -> ring-0). */
87 PDMSCATTERGATHER XmitSg;
88 /** The transmit GSO context (when applicable). */
89 PDMNETWORKGSO XmitGso;
90 /** The transmit buffer (ring-3 -> ring-0). */
91 uint8_t abXmitBuf[_64K];
92
93 /** The receive scatter gather buffer. */
94 PDMSCATTERGATHER RecvSg;
95 /** The receive buffer (ring-0 -> ring-3). */
96 uint8_t abRecvBuf[_64K];
97
98} DRVDEDICATEDNIC;
99/** Pointer to the instance data for the dedicated (V)NIC driver. */
100typedef DRVDEDICATEDNIC *PDRVDEDICATEDNIC;
101
102/**
103 * Ring-0 operations.
104 */
105typedef enum DRVDEDICATEDNICR0OP
106{
107 /** Invalid zero value.. */
108 DRVDEDICATEDNICR0OP_INVALID = 0,
109 /** Initialize the connection to the NIC. */
110 DRVDEDICATEDNICR0OP_INIT,
111 /** Terminate the connection to the NIC. */
112 DRVDEDICATEDNICR0OP_TERM,
113 /** Suspend the operation. */
114 DRVDEDICATEDNICR0OP_SUSPEND,
115 /** Resume the operation. */
116 DRVDEDICATEDNICR0OP_RESUME,
117 /** Wait for and do receive work.
118 * We do this in ring-0 instead of ring-3 to save 1-2 buffer copies and
119 * unnecessary context switching. */
120 DRVDEDICATEDNICR0OP_RECV,
121 /** Wait for and do transmit work.
122 * We do this in ring-0 instead of ring-3 to save 1-2 buffer copies and
123 * unnecessary context switching. */
124 DRVDEDICATEDNICR0OP_SEND,
125 /** Changes the promiscuousness of the interface (guest point of view). */
126 DRVDEDICATEDNICR0OP_PROMISC,
127 /** End of the valid operations. */
128 DRVDEDICATEDNICR0OP_END,
129 /** The usual 32-bit hack. */
130 DRVDEDICATEDNICR0OP_32BIT_HACK = 0x7fffffff
131} DRVDEDICATEDNICR0OP;
132
133
134
135#ifdef IN_RING0
136
137/**
138 * @interface_method_impl{FNPDMDRVREQHANDLERR0}
139 */
140PDMBOTHCBDECL(int) drvR0DedicatedNicReqHandler(PPDMDRVINS pDrvIns, uint32_t uOperation, uint64_t u64Arg)
141{
142 RT_NOREF_PV(pDrvIns); RT_NOREF_PV(u64Arg);
143 switch ((DRVDEDICATEDNICR0OP)uOperation)
144 {
145 case DRVDEDICATEDNICR0OP_INIT:
146 return VERR_NOT_IMPLEMENTED;//drvR0DedicatedNicReqInit(pDrvIns, u64Arg);
147
148 case DRVDEDICATEDNICR0OP_TERM:
149 return VERR_NOT_IMPLEMENTED;//drvR0DedicatedNicReqTerm(pDrvIns);
150
151 case DRVDEDICATEDNICR0OP_SUSPEND:
152 return VERR_NOT_IMPLEMENTED;//drvR0DedicatedNicReqSuspend(pDrvIns);
153
154 case DRVDEDICATEDNICR0OP_RESUME:
155 return VERR_NOT_IMPLEMENTED;//drvR0DedicatedNicReqResume(pDrvIns);
156
157 case DRVDEDICATEDNICR0OP_RECV:
158 return VERR_NOT_IMPLEMENTED;//drvR0DedicatedNicReqRecv(pDrvIns);
159
160 case DRVDEDICATEDNICR0OP_SEND:
161 return VERR_NOT_IMPLEMENTED;//drvR0DedicatedNicReqSend(pDrvIns);
162
163 case DRVDEDICATEDNICR0OP_PROMISC:
164 return VERR_NOT_IMPLEMENTED;//drvR0DedicatedNicReqPromisc(pDrvIns, !!u64Arg);
165
166 case DRVDEDICATEDNICR0OP_END:
167 default:
168 return VERR_INVALID_FUNCTION;
169 }
170}
171
172#endif /* IN_RING0 */
173
174
175
176#if 0 /* currently unused */
177
178/* -=-=-=-=- PDMINETWORKUP -=-=-=-=- */
179
180/**
181 * @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
182 */
183PDMBOTHCBDECL(int) drvDedicatedNicUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
184{
185 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
186 int rc = PDMCritSectTryEnter(&pThis->XmitLock);
187 if (RT_SUCCESS(rc))
188 ASMAtomicUoWriteBool(&pThis->fXmitOnXmitThread, fOnWorkerThread);
189 return rc;
190}
191
192
193/**
194 * @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
195 */
196PDMBOTHCBDECL(int) drvDedicatedNicUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
197 PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
198{
199 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
200 Assert(PDMCritSectIsOwner(&pThis->XmitLock));
201
202 /*
203 * If the net is down, we can return immediately.
204 */
205 if (pThis->fLinkDown)
206 return VERR_NET_DOWN;
207
208#ifdef IN_RING0
209 /** @todo Ask the driver for a buffer, atomically if we're called on EMT. */
210 RT_NOREF_PV(cbMin); RT_NOREF_PV(pGso); RT_NOREF_PV(ppSgBuf);
211 return VERR_TRY_AGAIN;
212
213#else /* IN_RING3 */
214 /*
215 * Are we busy or is the request too big?
216 */
217 if (RT_UNLIKELY((pThis->XmitSg.fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC))
218 return VERR_TRY_AGAIN;
219 if (cbMin > sizeof(pThis->abXmitBuf))
220 return VERR_NO_MEMORY;
221
222 /*
223 * Initialize the S/G buffer and return.
224 */
225 pThis->XmitSg.fFlags = PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1;
226 pThis->XmitSg.cbUsed = 0;
227 pThis->XmitSg.cbAvailable = sizeof(pThis->abXmitBuf);
228 pThis->XmitSg.pvAllocator = NULL;
229 if (!pGso)
230 {
231 pThis->XmitSg.pvUser = NULL;
232 pThis->XmitGso.u8Type = PDMNETWORKGSOTYPE_INVALID;
233 }
234 else
235 {
236 pThis->XmitSg.pvUser = &pThis->XmitGso;
237 pThis->XmitGso = *pGso;
238 }
239 pThis->XmitSg.cSegs = 1;
240 pThis->XmitSg.aSegs[0].cbSeg = pThis->XmitSg.cbAvailable;
241 pThis->XmitSg.aSegs[0].pvSeg = &pThis->abXmitBuf[0];
242
243# if 0 /* poison */
244 memset(pThis->XmitSg.aSegs[0].pvSeg, 'F', pThis->XmitSg.aSegs[0].cbSeg);
245# endif
246
247 *ppSgBuf = &pThis->XmitSg;
248 return VINF_SUCCESS;
249#endif /* IN_RING3 */
250}
251
252
253/**
254 * @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
255 */
256PDMBOTHCBDECL(int) drvDedicatedNicUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
257{
258#ifdef VBOX_STRICT
259 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
260 Assert(pSgBuf->fFlags == (PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1));
261 Assert(pSgBuf->cbUsed <= pSgBuf->cbAvailable);
262 Assert(PDMCritSectIsOwner(&pThis->XmitLock));
263#else
264 RT_NOREF1(pInterface);
265#endif
266
267 if (pSgBuf)
268 {
269#ifdef IN_RING0
270 // ...
271#else
272 Assert(pSgBuf == &pThis->XmitSg);
273 Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
274 pSgBuf->fFlags = 0;
275#endif
276 }
277
278 return VINF_SUCCESS;
279}
280
281
282/**
283 * @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
284 */
285PDMBOTHCBDECL(int) drvDedicatedNicUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
286{
287 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
288 STAM_PROFILE_START(&pThis->StatTransmit, a);
289
290 AssertPtr(pSgBuf);
291 Assert(pSgBuf->fFlags == (PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1));
292 Assert(pSgBuf->cbUsed <= pSgBuf->cbAvailable);
293#ifdef IN_RING0
294 Assert(pSgBuf == &pThis->XmitSg);
295#endif
296 Assert(PDMCritSectIsOwner(&pThis->XmitLock));
297
298#ifdef IN_RING0
299 /*
300 * Tell the driver to send the packet.
301 */
302 RT_NOREF_PV(pThis); RT_NOREF_PV(pSgBuf); RT_NOREF_PV(fOnWorkerThread);
303 return VERR_INTERNAL_ERROR_4;
304
305#else /* IN_RING3 */
306 NOREF(fOnWorkerThread);
307
308 /*
309 * Call ring-0 to start the transfer.
310 */
311 int rc = PDMDrvHlpCallR0(pThis->pDrvInsR3, DRVDEDICATEDNICR0OP_SEND, pSgBuf->cbUsed);
312 if (RT_FAILURE(rc) && rc != VERR_NET_DOWN)
313 rc = VERR_NET_NO_BUFFER_SPACE;
314 pSgBuf->fFlags = 0;
315 return rc;
316#endif /* IN_RING3 */
317}
318
319
320/**
321 * @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
322 */
323PDMBOTHCBDECL(void) drvDedicatedNicUp_EndXmit(PPDMINETWORKUP pInterface)
324{
325 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
326 ASMAtomicUoWriteBool(&pThis->fXmitOnXmitThread, false);
327 PDMCritSectLeave(&pThis->XmitLock);
328}
329
330
331/**
332 * @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
333 */
334PDMBOTHCBDECL(void) drvDedicatedNicUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
335{
336 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
337 /** @todo enable/disable promiscuous mode (should be easy) */
338 NOREF(pThis); RT_NOREF_PV(fPromiscuous);
339}
340
341#endif /* unused */
342#ifdef IN_RING3
343# if 0 /* currently unused */
344
345/**
346 * @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
347 */
348static DECLCALLBACK(void) drvR3DedicatedNicUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
349{
350 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
351 bool fLinkDown;
352 switch (enmLinkState)
353 {
354 case PDMNETWORKLINKSTATE_DOWN:
355 case PDMNETWORKLINKSTATE_DOWN_RESUME:
356 fLinkDown = true;
357 break;
358 default:
359 AssertMsgFailed(("enmLinkState=%d\n", enmLinkState));
360 case PDMNETWORKLINKSTATE_UP:
361 fLinkDown = false;
362 break;
363 }
364 LogFlow(("drvR3DedicatedNicUp_NotifyLinkChanged: enmLinkState=%d %d->%d\n", enmLinkState, pThis->fLinkDown, fLinkDown));
365 ASMAtomicWriteBool(&pThis->fLinkDown, fLinkDown);
366}
367
368
369/* -=-=-=-=- PDMIBASER0 -=-=-=-=- */
370
371/**
372 * @interface_method_impl{PDMIBASER0,pfnQueryInterface}
373 */
374static DECLCALLBACK(RTR0PTR) drvR3DedicatedNicIBaseR0_QueryInterface(PPDMIBASER0 pInterface, const char *pszIID)
375{
376 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, IBaseR0);
377 PDMIBASER0_RETURN_INTERFACE(pThis->pDrvInsR3, pszIID, PDMINETWORKUP, &pThis->INetworkUpR0);
378 return NIL_RTR0PTR;
379}
380
381
382/* -=-=-=-=- PDMIBASE -=-=-=-=- */
383
384/**
385 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
386 */
387static DECLCALLBACK(void *) drvR3DedicatedNicIBase_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
388{
389 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
390 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
391
392 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
393 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASER0, &pThis->IBaseR0);
394 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUpR3);
395 return NULL;
396}
397
398# endif /* Currently unused */
399
400
401/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
402
403/**
404 * @interface_method_impl{PDMDRVREG,pfnPowerOff}
405 */
406static DECLCALLBACK(void) drvR3DedicatedNicPowerOff(PPDMDRVINS pDrvIns)
407{
408 LogFlow(("drvR3DedicatedNicPowerOff\n"));
409 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_SUSPEND, 0);
410 AssertRC(rc);
411}
412
413
414/**
415 * @interface_method_impl{PDMDRVREG,pfnResume}
416 */
417static DECLCALLBACK(void) drvR3DedicatedNicResume(PPDMDRVINS pDrvIns)
418{
419 LogFlow(("drvR3DedicatedNicPowerResume\n"));
420 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_RESUME, 0);
421 AssertRC(rc);
422}
423
424
425/**
426 * @interface_method_impl{PDMDRVREG,pfnSuspend}
427 */
428static DECLCALLBACK(void) drvR3DedicatedNicSuspend(PPDMDRVINS pDrvIns)
429{
430 LogFlow(("drvR3DedicatedNicPowerSuspend\n"));
431 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_SUSPEND, 0);
432 AssertRC(rc);
433}
434
435
436/**
437 * @interface_method_impl{PDMDRVREG,pfnPowerOn}
438 */
439static DECLCALLBACK(void) drvR3DedicatedNicPowerOn(PPDMDRVINS pDrvIns)
440{
441 LogFlow(("drvR3DedicatedNicPowerOn\n"));
442 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_RESUME, 0);
443 AssertRC(rc);
444}
445
446
447/**
448 * @interface_method_impl{PDMDRVREG,pfnDestruct}
449 */
450static DECLCALLBACK(void) drvR3DedicatedNicDestruct(PPDMDRVINS pDrvIns)
451{
452 LogFlow(("drvR3DedicatedNicDestruct\n"));
453 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
454 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
455
456 if (pThis->pIfPortR0)
457 {
458 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_TERM, 0);
459 AssertRC(rc);;
460 }
461}
462
463
464/**
465 * @interface_method_impl{PDMDRVREG,pfnConstruct}
466 */
467static DECLCALLBACK(int) drvR3DedicatedNicConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
468{
469 RT_NOREF(pCfg, fFlags);
470 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
471 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
472
473 /*
474 * Init the static parts.
475 */
476 pThis->pDrvInsR3 = pDrvIns;
477 pThis->pDrvInsR0 = PDMDRVINS_2_R0PTR(pDrvIns);
478#if 0
479 pThis->hRecvThread = NIL_RTTHREAD;
480 pThis->hRecvEvt = NIL_RTSEMEVENT;
481 pThis->pXmitThread = NULL;
482 pThis->hXmitEvt = NIL_SUPSEMEVENT;
483 pThis->pSupDrvSession = PDMDrvHlpGetSupDrvSession(pDrvIns);
484 pThis->hSgCache = NIL_RTMEMCACHE;
485 pThis->enmRecvState = RECVSTATE_SUSPENDED;
486 pThis->fActivateEarlyDeactivateLate = false;
487 /* IBase* */
488 pDrvIns->IBase.pfnQueryInterface = drvR3DedicatedNicIBase_QueryInterface;
489 pThis->IBaseR0.pfnQueryInterface = drvR3DedicatedNicIBaseR0_QueryInterface;
490 pThis->IBaseRC.pfnQueryInterface = drvR3DedicatedNicIBaseRC_QueryInterface;
491 /* INetworkUp */
492 pThis->INetworkUpR3.pfnBeginXmit = drvDedicatedNic_BeginXmit;
493 pThis->INetworkUpR3.pfnAllocBuf = drvDedicatedNic_AllocBuf;
494 pThis->INetworkUpR3.pfnFreeBuf = drvDedicatedNic_FreeBuf;
495 pThis->INetworkUpR3.pfnSendBuf = drvDedicatedNic_SendBuf;
496 pThis->INetworkUpR3.pfnEndXmit = drvDedicatedNic_EndXmit;
497 pThis->INetworkUpR3.pfnSetPromiscuousMode = drvDedicatedNic_SetPromiscuousMode;
498 pThis->INetworkUpR3.pfnNotifyLinkChanged = drvR3DedicatedNicUp_NotifyLinkChanged;
499#endif
500
501 /** @todo
502 * Need to create a generic way of calling into the ring-0 side of the driver so
503 * we can initialize the thing as well as send and receive. Hmm ... the
504 * sending could be done more efficiently from a ring-0 kernel thread actually
505 * (saves context switching and 1-2 copy operations). Ditto for receive, except
506 * we need to tie the thread to the process or we cannot access the guest ram so
507 * easily.
508 */
509
510 return VERR_NOT_IMPLEMENTED;
511}
512
513
514
515/**
516 * Internal networking transport driver registration record.
517 */
518const PDMDRVREG g_DrvDedicatedNic =
519{
520 /* u32Version */
521 PDM_DRVREG_VERSION,
522 /* szName */
523 "DedicatedNic",
524 /* szRCMod */
525 "",
526 /* szR0Mod */
527 "VBoxDDR0.r0",
528 /* pszDescription */
529 "Dedicated (V)NIC Driver",
530 /* fFlags */
531 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT | PDM_DRVREG_FLAGS_R0,
532 /* fClass. */
533 PDM_DRVREG_CLASS_NETWORK,
534 /* cMaxInstances */
535 ~0U,
536 /* cbInstance */
537 sizeof(DRVDEDICATEDNIC),
538 /* pfnConstruct */
539 drvR3DedicatedNicConstruct,
540 /* pfnDestruct */
541 drvR3DedicatedNicDestruct,
542 /* pfnRelocate */
543 NULL,
544 /* pfnIOCtl */
545 NULL,
546 /* pfnPowerOn */
547 drvR3DedicatedNicPowerOn,
548 /* pfnReset */
549 NULL,
550 /* pfnSuspend */
551 drvR3DedicatedNicSuspend,
552 /* pfnResume */
553 drvR3DedicatedNicResume,
554 /* pfnAttach */
555 NULL,
556 /* pfnDetach */
557 NULL,
558 /* pfnPowerOff */
559 drvR3DedicatedNicPowerOff,
560 /* pfnSoftReset */
561 NULL,
562 /* u32EndVersion */
563 PDM_DRVREG_VERSION
564};
565
566#endif /* IN_RING3 */
567
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