VirtualBox

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

最後變更 在這個檔案從63211是 63211,由 vboxsync 提交於 9 年 前

Devices: warnings (gcc)
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 18.1 KB
行 
1/* $Id: DrvDedicatedNic.cpp 63211 2016-08-09 14:47:23Z 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.alldomusa.eu.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#ifdef IN_RING3
342
343/**
344 * @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
345 */
346static DECLCALLBACK(void) drvR3DedicatedNicUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
347{
348 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, CTX_SUFF(INetworkUp));
349 bool fLinkDown;
350 switch (enmLinkState)
351 {
352 case PDMNETWORKLINKSTATE_DOWN:
353 case PDMNETWORKLINKSTATE_DOWN_RESUME:
354 fLinkDown = true;
355 break;
356 default:
357 AssertMsgFailed(("enmLinkState=%d\n", enmLinkState));
358 case PDMNETWORKLINKSTATE_UP:
359 fLinkDown = false;
360 break;
361 }
362 LogFlow(("drvR3DedicatedNicUp_NotifyLinkChanged: enmLinkState=%d %d->%d\n", enmLinkState, pThis->fLinkDown, fLinkDown));
363 ASMAtomicWriteBool(&pThis->fLinkDown, fLinkDown);
364}
365
366
367/* -=-=-=-=- PDMIBASER0 -=-=-=-=- */
368
369/**
370 * @interface_method_impl{PDMIBASER0,pfnQueryInterface}
371 */
372static DECLCALLBACK(RTR0PTR) drvR3DedicatedNicIBaseR0_QueryInterface(PPDMIBASER0 pInterface, const char *pszIID)
373{
374 PDRVDEDICATEDNIC pThis = RT_FROM_MEMBER(pInterface, DRVDEDICATEDNIC, IBaseR0);
375 PDMIBASER0_RETURN_INTERFACE(pThis->pDrvInsR3, pszIID, PDMINETWORKUP, &pThis->INetworkUpR0);
376 return NIL_RTR0PTR;
377}
378
379
380/* -=-=-=-=- PDMIBASE -=-=-=-=- */
381
382/**
383 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
384 */
385static DECLCALLBACK(void *) drvR3DedicatedNicIBase_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
386{
387 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
388 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
389
390 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
391 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASER0, &pThis->IBaseR0);
392 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUpR3);
393 return NULL;
394}
395
396#endif /* Currently unused */
397
398
399/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
400
401/**
402 * @interface_method_impl{PDMDRVREG,pfnPowerOff}
403 */
404static DECLCALLBACK(void) drvR3DedicatedNicPowerOff(PPDMDRVINS pDrvIns)
405{
406 LogFlow(("drvR3DedicatedNicPowerOff\n"));
407 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_SUSPEND, 0);
408 AssertRC(rc);
409}
410
411
412/**
413 * @interface_method_impl{PDMDRVREG,pfnResume}
414 */
415static DECLCALLBACK(void) drvR3DedicatedNicResume(PPDMDRVINS pDrvIns)
416{
417 LogFlow(("drvR3DedicatedNicPowerResume\n"));
418 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_RESUME, 0);
419 AssertRC(rc);
420}
421
422
423/**
424 * @interface_method_impl{PDMDRVREG,pfnSuspend}
425 */
426static DECLCALLBACK(void) drvR3DedicatedNicSuspend(PPDMDRVINS pDrvIns)
427{
428 LogFlow(("drvR3DedicatedNicPowerSuspend\n"));
429 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_SUSPEND, 0);
430 AssertRC(rc);
431}
432
433
434/**
435 * @interface_method_impl{PDMDRVREG,pfnPowerOn}
436 */
437static DECLCALLBACK(void) drvR3DedicatedNicPowerOn(PPDMDRVINS pDrvIns)
438{
439 LogFlow(("drvR3DedicatedNicPowerOn\n"));
440 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_RESUME, 0);
441 AssertRC(rc);
442}
443
444
445/**
446 * @interface_method_impl{PDMDRVREG,pfnDestruct}
447 */
448static DECLCALLBACK(void) drvR3DedicatedNicDestruct(PPDMDRVINS pDrvIns)
449{
450 LogFlow(("drvR3DedicatedNicDestruct\n"));
451 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
452 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
453
454 if (pThis->pIfPortR0)
455 {
456 int rc = PDMDrvHlpCallR0(pDrvIns, DRVDEDICATEDNICR0OP_TERM, 0);
457 AssertRC(rc);;
458 }
459}
460
461
462/**
463 * @interface_method_impl{PDMDRVREG,pfnConstruct}
464 */
465static DECLCALLBACK(int) drvR3DedicatedNicConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
466{
467 RT_NOREF(pCfg, fFlags);
468 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
469 PDRVDEDICATEDNIC pThis = PDMINS_2_DATA(pDrvIns, PDRVDEDICATEDNIC);
470
471 /*
472 * Init the static parts.
473 */
474 pThis->pDrvInsR3 = pDrvIns;
475 pThis->pDrvInsR0 = PDMDRVINS_2_R0PTR(pDrvIns);
476#if 0
477 pThis->hRecvThread = NIL_RTTHREAD;
478 pThis->hRecvEvt = NIL_RTSEMEVENT;
479 pThis->pXmitThread = NULL;
480 pThis->hXmitEvt = NIL_SUPSEMEVENT;
481 pThis->pSupDrvSession = PDMDrvHlpGetSupDrvSession(pDrvIns);
482 pThis->hSgCache = NIL_RTMEMCACHE;
483 pThis->enmRecvState = RECVSTATE_SUSPENDED;
484 pThis->fActivateEarlyDeactivateLate = false;
485 /* IBase* */
486 pDrvIns->IBase.pfnQueryInterface = drvR3DedicatedNicIBase_QueryInterface;
487 pThis->IBaseR0.pfnQueryInterface = drvR3DedicatedNicIBaseR0_QueryInterface;
488 pThis->IBaseRC.pfnQueryInterface = drvR3DedicatedNicIBaseRC_QueryInterface;
489 /* INetworkUp */
490 pThis->INetworkUpR3.pfnBeginXmit = drvDedicatedNic_BeginXmit;
491 pThis->INetworkUpR3.pfnAllocBuf = drvDedicatedNic_AllocBuf;
492 pThis->INetworkUpR3.pfnFreeBuf = drvDedicatedNic_FreeBuf;
493 pThis->INetworkUpR3.pfnSendBuf = drvDedicatedNic_SendBuf;
494 pThis->INetworkUpR3.pfnEndXmit = drvDedicatedNic_EndXmit;
495 pThis->INetworkUpR3.pfnSetPromiscuousMode = drvDedicatedNic_SetPromiscuousMode;
496 pThis->INetworkUpR3.pfnNotifyLinkChanged = drvR3DedicatedNicUp_NotifyLinkChanged;
497#endif
498
499 /** @todo
500 * Need to create a generic way of calling into the ring-0 side of the driver so
501 * we can initialize the thing as well as send and receive. Hmm ... the
502 * sending could be done more efficiently from a ring-0 kernel thread actually
503 * (saves context switching and 1-2 copy operations). Ditto for receive, except
504 * we need to tie the thread to the process or we cannot access the guest ram so
505 * easily.
506 */
507
508 return VERR_NOT_IMPLEMENTED;
509}
510
511
512
513/**
514 * Internal networking transport driver registration record.
515 */
516const PDMDRVREG g_DrvDedicatedNic =
517{
518 /* u32Version */
519 PDM_DRVREG_VERSION,
520 /* szName */
521 "DedicatedNic",
522 /* szRCMod */
523 "",
524 /* szR0Mod */
525 "VBoxDDR0.r0",
526 /* pszDescription */
527 "Dedicated (V)NIC Driver",
528 /* fFlags */
529 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT | PDM_DRVREG_FLAGS_R0,
530 /* fClass. */
531 PDM_DRVREG_CLASS_NETWORK,
532 /* cMaxInstances */
533 ~0U,
534 /* cbInstance */
535 sizeof(DRVDEDICATEDNIC),
536 /* pfnConstruct */
537 drvR3DedicatedNicConstruct,
538 /* pfnDestruct */
539 drvR3DedicatedNicDestruct,
540 /* pfnRelocate */
541 NULL,
542 /* pfnIOCtl */
543 NULL,
544 /* pfnPowerOn */
545 drvR3DedicatedNicPowerOn,
546 /* pfnReset */
547 NULL,
548 /* pfnSuspend */
549 drvR3DedicatedNicSuspend,
550 /* pfnResume */
551 drvR3DedicatedNicResume,
552 /* pfnAttach */
553 NULL,
554 /* pfnDetach */
555 NULL,
556 /* pfnPowerOff */
557 drvR3DedicatedNicPowerOff,
558 /* pfnSoftReset */
559 NULL,
560 /* u32EndVersion */
561 PDM_DRVREG_VERSION
562};
563
564#endif /* IN_RING3 */
565
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette