DrvDedicatedNic.cpp

Last change on this file was 106061, checked in by vboxsync, 7 weeks 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.4 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: