VirtualBox

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

Last change on this file since 63185 was 62906, checked in by vboxsync, 8 years ago

Devices: warnings
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.0 KB
Line 
1/* $Id: DrvDedicatedNic.cpp 62906 2016-08-03 11:20:21Z vboxsync $ */
2/** @file
3 * DrvDedicatedNic - Experimental network driver for using a dedicated (V)NIC.
4 */
5
6/*
7 * Copyright (C) 2010-2016 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/* -=-=-=-=- PDMINETWORKUP -=-=-=-=- */
177
178/**
179 * @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
180 */
181PDMBOTHCBDECL(int) drvDedicatedNicUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
182{
183 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
184 int rc = PDMCritSectTryEnter(&pThis->XmitLock);
185 if (RT_SUCCESS(rc))
186 ASMAtomicUoWriteBool(&pThis->fXmitOnXmitThread, fOnWorkerThread);
187 return rc;
188}
189
190
191/**
192 * @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
193 */
194PDMBOTHCBDECL(int) drvDedicatedNicUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
195 PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
196{
197 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
198 Assert(PDMCritSectIsOwner(&pThis->XmitLock));
199
200 /*
201 * If the net is down, we can return immediately.
202 */
203 if (pThis->fLinkDown)
204 return VERR_NET_DOWN;
205
206#ifdef IN_RING0
207 /** @todo Ask the driver for a buffer, atomically if we're called on EMT. */
208 RT_NOREF_PV(cbMin); RT_NOREF_PV(pGso); RT_NOREF_PV(ppSgBuf);
209 return VERR_TRY_AGAIN;
210
211#else /* IN_RING3 */
212 /*
213 * Are we busy or is the request too big?
214 */
215 if (RT_UNLIKELY((pThis->XmitSg.fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC))
216 return VERR_TRY_AGAIN;
217 if (cbMin > sizeof(pThis->abXmitBuf))
218 return VERR_NO_MEMORY;
219
220 /*
221 * Initialize the S/G buffer and return.
222 */
223 pThis->XmitSg.fFlags = PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1;
224 pThis->XmitSg.cbUsed = 0;
225 pThis->XmitSg.cbAvailable = sizeof(pThis->abXmitBuf);
226 pThis->XmitSg.pvAllocator = NULL;
227 if (!pGso)
228 {
229 pThis->XmitSg.pvUser = NULL;
230 pThis->XmitGso.u8Type = PDMNETWORKGSOTYPE_INVALID;
231 }
232 else
233 {
234 pThis->XmitSg.pvUser = &pThis->XmitGso;
235 pThis->XmitGso = *pGso;
236 }
237 pThis->XmitSg.cSegs = 1;
238 pThis->XmitSg.aSegs[0].cbSeg = pThis->XmitSg.cbAvailable;
239 pThis->XmitSg.aSegs[0].pvSeg = &pThis->abXmitBuf[0];
240
241# if 0 /* poison */
242 memset(pThis->XmitSg.aSegs[0].pvSeg, 'F', pThis->XmitSg.aSegs[0].cbSeg);
243# endif
244
245 *ppSgBuf = &pThis->XmitSg;
246 return VINF_SUCCESS;
247#endif /* IN_RING3 */
248}
249
250
251/**
252 * @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
253 */
254PDMBOTHCBDECL(int) drvDedicatedNicUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
255{
256#ifdef VBOX_STRICT
257 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
258 Assert(pSgBuf->fFlags == (PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1));
259 Assert(pSgBuf->cbUsed <= pSgBuf->cbAvailable);
260 Assert(PDMCritSectIsOwner(&pThis->XmitLock));
261#else
262 RT_NOREF1(pInterface);
263#endif
264
265 if (pSgBuf)
266 {
267#ifdef IN_RING0
268 // ...
269#else
270 Assert(pSgBuf == &pThis->XmitSg);
271 Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
272 pSgBuf->fFlags = 0;
273#endif
274 }
275
276 return VINF_SUCCESS;
277}
278
279
280/**
281 * @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
282 */
283PDMBOTHCBDECL(int) drvDedicatedNicUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
284{
285 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
286 STAM_PROFILE_START(&pThis->StatTransmit, a);
287
288 AssertPtr(pSgBuf);
289 Assert(pSgBuf->fFlags == (PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1));
290 Assert(pSgBuf->cbUsed <= pSgBuf->cbAvailable);
291#ifdef IN_RING0
292 Assert(pSgBuf == &pThis->XmitSg);
293#endif
294 Assert(PDMCritSectIsOwner(&pThis->XmitLock));
295
296#ifdef IN_RING0
297 /*
298 * Tell the driver to send the packet.
299 */
300 RT_NOREF_PV(pThis); RT_NOREF_PV(pSgBuf); RT_NOREF_PV(fOnWorkerThread);
301 return VERR_INTERNAL_ERROR_4;
302
303#else /* IN_RING3 */
304 NOREF(fOnWorkerThread);
305
306 /*
307 * Call ring-0 to start the transfer.
308 */
309 int rc = PDMDrvHlpCallR0(pThis->pDrvInsR3, DRVDEDICATEDNICR0OP_SEND, pSgBuf->cbUsed);
310 if (RT_FAILURE(rc) && rc != VERR_NET_DOWN)
311 rc = VERR_NET_NO_BUFFER_SPACE;
312 pSgBuf->fFlags = 0;
313 return rc;
314#endif /* IN_RING3 */
315}
316
317
318/**
319 * @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
320 */
321PDMBOTHCBDECL(void) drvDedicatedNicUp_EndXmit(PPDMINETWORKUP pInterface)
322{
323 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
324 ASMAtomicUoWriteBool(&pThis->fXmitOnXmitThread, false);
325 PDMCritSectLeave(&pThis->XmitLock);
326}
327
328
329/**
330 * @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
331 */
332PDMBOTHCBDECL(void) drvDedicatedNicUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
333{
334 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
335 /** @todo enable/disable promiscuous mode (should be easy) */
336 NOREF(pThis); RT_NOREF_PV(fPromiscuous);
337}
338
339#ifdef IN_RING3
340
341/**
342 * @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
343 */
344static DECLCALLBACK(void) drvR3DedicatedNicUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
345{
346 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
347 bool fLinkDown;
348 switch (enmLinkState)
349 {
350 case PDMNETWORKLINKSTATE_DOWN:
351 case PDMNETWORKLINKSTATE_DOWN_RESUME:
352 fLinkDown = true;
353 break;
354 default:
355 AssertMsgFailed(("enmLinkState=%d\n", enmLinkState));
356 case PDMNETWORKLINKSTATE_UP:
357 fLinkDown = false;
358 break;
359 }
360 LogFlow(("drvR3DedicatedNicUp_NotifyLinkChanged: enmLinkState=%d %d->%d\n", enmLinkState, pThis->fLinkDown, fLinkDown));
361 ASMAtomicWriteBool(&pThis->fLinkDown, fLinkDown);
362}
363
364
365/* -=-=-=-=- PDMIBASER0 -=-=-=-=- */
366
367/**
368 * @interface_method_impl{PDMIBASER0,pfnQueryInterface}
369 */
370static DECLCALLBACK(RTR0PTR) drvR3DedicatedNicIBaseR0_QueryInterface(PPDMIBASER0 pInterface, const char *pszIID)
371{
372 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, IBaseR0);
373 PDMIBASER0_RETURN_INTERFACE(pThis->pDrvInsR3, pszIID, PDMINETWORKUP, &pThis->INetworkUpR0);
374 return NIL_RTR0PTR;
375}
376
377
378/* -=-=-=-=- PDMIBASE -=-=-=-=- */
379
380/**
381 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
382 */
383static DECLCALLBACK(void *) drvR3DedicatedNicIBase_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
384{
385 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
386 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
387
388 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
389 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASER0, &pThis->IBaseR0);
390 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUpR3);
391 return NULL;
392}
393
394
395/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
396
397/**
398 * @interface_method_impl{PDMDRVREG,pfnPowerOff}
399 */
400static DECLCALLBACK(void) drvR3DedicatedNicPowerOff(PPDMDRVINS pDrvIns)
401{
402 LogFlow(("drvR3DedicatedNicPowerOff\n"));
403 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_SUSPEND, 0);
404 AssertRC(rc);
405}
406
407
408/**
409 * @interface_method_impl{PDMDRVREG,pfnResume}
410 */
411static DECLCALLBACK(void) drvR3DedicatedNicResume(PPDMDRVINS pDrvIns)
412{
413 LogFlow(("drvR3DedicatedNicPowerResume\n"));
414 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_RESUME, 0);
415 AssertRC(rc);
416}
417
418
419/**
420 * @interface_method_impl{PDMDRVREG,pfnSuspend}
421 */
422static DECLCALLBACK(void) drvR3DedicatedNicSuspend(PPDMDRVINS pDrvIns)
423{
424 LogFlow(("drvR3DedicatedNicPowerSuspend\n"));
425 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_SUSPEND, 0);
426 AssertRC(rc);
427}
428
429
430/**
431 * @interface_method_impl{PDMDRVREG,pfnPowerOn}
432 */
433static DECLCALLBACK(void) drvR3DedicatedNicPowerOn(PPDMDRVINS pDrvIns)
434{
435 LogFlow(("drvR3DedicatedNicPowerOn\n"));
436 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_RESUME, 0);
437 AssertRC(rc);
438}
439
440
441/**
442 * @interface_method_impl{PDMDRVREG,pfnDestruct}
443 */
444static DECLCALLBACK(void) drvR3DedicatedNicDestruct(PPDMDRVINS pDrvIns)
445{
446 LogFlow(("drvR3DedicatedNicDestruct\n"));
447 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
448 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
449
450 if (pThis->pIfPortR0)
451 {
452 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_TERM, 0);
453 AssertRC(rc);;
454 }
455}
456
457
458/**
459 * @interface_method_impl{PDMDRVREG,pfnConstruct}
460 */
461static DECLCALLBACK(int) drvR3DedicatedNicConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
462{
463 RT_NOREF(pCfg, fFlags);
464 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
465 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
466
467 /*
468 * Init the static parts.
469 */
470 pThis->pDrvInsR3 = pDrvIns;
471 pThis->pDrvInsR0 = PDMDRVINS_2_R0PTR(pDrvIns);
472#if 0
473 pThis->hRecvThread = NIL_RTTHREAD;
474 pThis->hRecvEvt = NIL_RTSEMEVENT;
475 pThis->pXmitThread = NULL;
476 pThis->hXmitEvt = NIL_SUPSEMEVENT;
477 pThis->pSupDrvSession = PDMDrvHlpGetSupDrvSession(pDrvIns);
478 pThis->hSgCache = NIL_RTMEMCACHE;
479 pThis->enmRecvState = RECVSTATE_SUSPENDED;
480 pThis->fActivateEarlyDeactivateLate = false;
481 /* IBase* */
482 pDrvIns->IBase.pfnQueryInterface = drvR3DedicatedNicIBase_QueryInterface;
483 pThis->IBaseR0.pfnQueryInterface = drvR3DedicatedNicIBaseR0_QueryInterface;
484 pThis->IBaseRC.pfnQueryInterface = drvR3DedicatedNicIBaseRC_QueryInterface;
485 /* INetworkUp */
486 pThis->INetworkUpR3.pfnBeginXmit = drvDedicatedNic_BeginXmit;
487 pThis->INetworkUpR3.pfnAllocBuf = drvDedicatedNic_AllocBuf;
488 pThis->INetworkUpR3.pfnFreeBuf = drvDedicatedNic_FreeBuf;
489 pThis->INetworkUpR3.pfnSendBuf = drvDedicatedNic_SendBuf;
490 pThis->INetworkUpR3.pfnEndXmit = drvDedicatedNic_EndXmit;
491 pThis->INetworkUpR3.pfnSetPromiscuousMode = drvDedicatedNic_SetPromiscuousMode;
492 pThis->INetworkUpR3.pfnNotifyLinkChanged = drvR3DedicatedNicUp_NotifyLinkChanged;
493#endif
494
495 /** @todo
496 * Need to create a generic way of calling into the ring-0 side of the driver so
497 * we can initialize the thing as well as send and receive. Hmm ... the
498 * sending could be done more efficiently from a ring-0 kernel thread actually
499 * (saves context switching and 1-2 copy operations). Ditto for receive, except
500 * we need to tie the thread to the process or we cannot access the guest ram so
501 * easily.
502 */
503
504 return VERR_NOT_IMPLEMENTED;
505}
506
507
508
509/**
510 * Internal networking transport driver registration record.
511 */
512const PDMDRVREG g_DrvDedicatedNic =
513{
514 /* u32Version */
515 PDM_DRVREG_VERSION,
516 /* szName */
517 "DedicatedNic",
518 /* szRCMod */
519 "",
520 /* szR0Mod */
521 "VBoxDDR0.r0",
522 /* pszDescription */
523 "Dedicated (V)NIC Driver",
524 /* fFlags */
525 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT | PDM_DRVREG_FLAGS_R0,
526 /* fClass. */
527 PDM_DRVREG_CLASS_NETWORK,
528 /* cMaxInstances */
529 ~0U,
530 /* cbInstance */
531 sizeof(DRVDEDICATEDNIC),
532 /* pfnConstruct */
533 drvR3DedicatedNicConstruct,
534 /* pfnDestruct */
535 drvR3DedicatedNicDestruct,
536 /* pfnRelocate */
537 NULL,
538 /* pfnIOCtl */
539 NULL,
540 /* pfnPowerOn */
541 drvR3DedicatedNicPowerOn,
542 /* pfnReset */
543 NULL,
544 /* pfnSuspend */
545 drvR3DedicatedNicSuspend,
546 /* pfnResume */
547 drvR3DedicatedNicResume,
548 /* pfnAttach */
549 NULL,
550 /* pfnDetach */
551 NULL,
552 /* pfnPowerOff */
553 drvR3DedicatedNicPowerOff,
554 /* pfnSoftReset */
555 NULL,
556 /* u32EndVersion */
557 PDM_DRVREG_VERSION
558};
559
560#endif /* IN_RING3 */
561
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