VirtualBox

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

Last change on this file since 57850 was 57358, checked in by vboxsync, 9 years ago

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