VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/DrvNetShaper.cpp@ 40754

Last change on this file since 40754 was 40706, checked in by vboxsync, 12 years ago

NetShaper: TX thread implementation (#5582)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.8 KB
Line 
1/* $Id: DrvNetShaper.cpp 40706 2012-03-29 12:16:40Z vboxsync $ */
2/** @file
3 * NetShaperFilter - Network shaper filter driver.
4 */
5
6/*
7 * Copyright (C) 2006-2012 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_NET_SHAPER
23
24#include <VBox/vmm/pdmdrv.h>
25#include <VBox/vmm/pdmnetifs.h>
26#include <VBox/vmm/pdmnetshaper.h>
27
28#include <VBox/log.h>
29#include <iprt/assert.h>
30#include <iprt/critsect.h>
31#include <iprt/string.h>
32#include <iprt/uuid.h>
33
34#include "VBoxDD.h"
35
36/*******************************************************************************
37* Structures and Typedefs *
38*******************************************************************************/
39/**
40 * Block driver instance data.
41 *
42 * @implements PDMINETWORKUP
43 * @implements PDMINETWORKDOWN
44 * @implements PDMINETWORKCONFIG
45 */
46typedef struct DRVNETSHAPER
47{
48 /** The network interface. */
49 PDMINETWORKUP INetworkUp;
50 /** The network interface. */
51 PDMINETWORKDOWN INetworkDown;
52 /** The network config interface.
53 * @todo this is a main interface and shouldn't be here... */
54 PDMINETWORKCONFIG INetworkConfig;
55 /** The port we're attached to. */
56 PPDMINETWORKDOWN pIAboveNet;
57 /** The config port interface we're attached to. */
58 PPDMINETWORKCONFIG pIAboveConfig;
59 /** The connector that's attached to us. */
60 PPDMINETWORKUP pIBelowNet;
61 /** The name of bandwidth group we are attached to. */
62 char * pszBwGroup;
63 /** The filter that represents us at bandwidth group. */
64 PDMNSFILTER Filter;
65 /** Pointer to the driver instance. */
66 PPDMDRVINS pDrvIns;
67 /** For when we're the leaf driver. */
68 RTCRITSECT XmitLock;
69
70 /** TX: Total number of bytes to allocate. */
71 STAMCOUNTER StatXmitBytesRequested;
72 /** TX: Number of bytes delayed. */
73 STAMCOUNTER StatXmitBytesDenied;
74 /** TX: Number of bytes allowed to pass. */
75 STAMCOUNTER StatXmitBytesGranted;
76 /** TX: Total number of packets being sent. */
77 STAMCOUNTER StatXmitPktsRequested;
78 /** TX: Number of packets delayed. */
79 STAMCOUNTER StatXmitPktsDenied;
80 /** TX: Number of packets allowed to pass. */
81 STAMCOUNTER StatXmitPktsGranted;
82 /** TX: Number of calls to pfnXmitPending. */
83 STAMCOUNTER StatXmitPendingCalled;
84} DRVNETSHAPER, *PDRVNETSHAPER;
85
86
87/**
88 * @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
89 */
90static DECLCALLBACK(int) drvNetShaperUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
91{
92 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkUp);
93 if (RT_UNLIKELY(!pThis->pIBelowNet))
94 {
95 int rc = RTCritSectTryEnter(&pThis->XmitLock);
96 if (RT_UNLIKELY(rc == VERR_SEM_BUSY))
97 rc = VERR_TRY_AGAIN;
98 return rc;
99 }
100 return pThis->pIBelowNet->pfnBeginXmit(pThis->pIBelowNet, fOnWorkerThread);
101}
102
103
104/**
105 * @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
106 */
107static DECLCALLBACK(int) drvNetShaperUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
108 PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
109{
110 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkUp);
111 if (RT_UNLIKELY(!pThis->pIBelowNet))
112 return VERR_NET_DOWN;
113 //LogFlow(("drvNetShaperUp_AllocBuf: cb=%d\n", cbMin));
114 STAM_REL_COUNTER_ADD(&pThis->StatXmitBytesRequested, cbMin);
115 STAM_REL_COUNTER_INC(&pThis->StatXmitPktsRequested);
116 if (!PDMR3NsAllocateBandwidth(&pThis->Filter, cbMin))
117 {
118 STAM_REL_COUNTER_ADD(&pThis->StatXmitBytesDenied, cbMin);
119 STAM_REL_COUNTER_INC(&pThis->StatXmitPktsDenied);
120 return VERR_TRY_AGAIN;
121 }
122 STAM_REL_COUNTER_ADD(&pThis->StatXmitBytesGranted, cbMin);
123 STAM_REL_COUNTER_INC(&pThis->StatXmitPktsGranted);
124 //LogFlow(("drvNetShaperUp_AllocBuf: got cb=%d\n", cbMin));
125 return pThis->pIBelowNet->pfnAllocBuf(pThis->pIBelowNet, cbMin, pGso, ppSgBuf);
126}
127
128
129/**
130 * @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
131 */
132static DECLCALLBACK(int) drvNetShaperUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
133{
134 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkUp);
135 if (RT_UNLIKELY(!pThis->pIBelowNet))
136 return VERR_NET_DOWN;
137 return pThis->pIBelowNet->pfnFreeBuf(pThis->pIBelowNet, pSgBuf);
138}
139
140
141/**
142 * @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
143 */
144static DECLCALLBACK(int) drvNetShaperUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
145{
146 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkUp);
147 if (RT_UNLIKELY(!pThis->pIBelowNet))
148 return VERR_NET_DOWN;
149
150 return pThis->pIBelowNet->pfnSendBuf(pThis->pIBelowNet, pSgBuf, fOnWorkerThread);
151}
152
153
154/**
155 * @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
156 */
157static DECLCALLBACK(void) drvNetShaperUp_EndXmit(PPDMINETWORKUP pInterface)
158{
159 //LogFlow(("drvNetShaperUp_EndXmit:\n"));
160 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkUp);
161 if (RT_LIKELY(pThis->pIBelowNet))
162 pThis->pIBelowNet->pfnEndXmit(pThis->pIBelowNet);
163 else
164 RTCritSectLeave(&pThis->XmitLock);
165}
166
167
168/**
169 * @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
170 */
171static DECLCALLBACK(void) drvNetShaperUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
172{
173 LogFlow(("drvNetShaperUp_SetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
174 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkUp);
175 if (pThis->pIBelowNet)
176 pThis->pIBelowNet->pfnSetPromiscuousMode(pThis->pIBelowNet, fPromiscuous);
177}
178
179
180/**
181 * @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
182 */
183static DECLCALLBACK(void) drvNetShaperUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
184{
185 LogFlow(("drvNetShaperUp_NotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
186 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkUp);
187 if (pThis->pIBelowNet)
188 pThis->pIBelowNet->pfnNotifyLinkChanged(pThis->pIBelowNet, enmLinkState);
189}
190
191
192/**
193 * @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
194 */
195static DECLCALLBACK(int) drvNetShaperDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
196{
197 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkDown);
198 return pThis->pIAboveNet->pfnWaitReceiveAvail(pThis->pIAboveNet, cMillies);
199}
200
201
202/**
203 * @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
204 */
205static DECLCALLBACK(int) drvNetShaperDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
206{
207 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkDown);
208 return pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, pvBuf, cb);
209}
210
211
212/**
213 * @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
214 */
215static DECLCALLBACK(void) drvNetShaperDown_XmitPending(PPDMINETWORKDOWN pInterface)
216{
217 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkDown);
218 STAM_REL_COUNTER_INC(&pThis->StatXmitPendingCalled);
219 pThis->pIAboveNet->pfnXmitPending(pThis->pIAboveNet);
220}
221
222
223/**
224 * Gets the current Media Access Control (MAC) address.
225 *
226 * @returns VBox status code.
227 * @param pInterface Pointer to the interface structure containing the called function pointer.
228 * @param pMac Where to store the MAC address.
229 * @thread EMT
230 */
231static DECLCALLBACK(int) drvNetShaperDownCfg_GetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
232{
233 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkConfig);
234 return pThis->pIAboveConfig->pfnGetMac(pThis->pIAboveConfig, pMac);
235}
236
237/**
238 * Gets the new link state.
239 *
240 * @returns The current link state.
241 * @param pInterface Pointer to the interface structure containing the called function pointer.
242 * @thread EMT
243 */
244static DECLCALLBACK(PDMNETWORKLINKSTATE) drvNetShaperDownCfg_GetLinkState(PPDMINETWORKCONFIG pInterface)
245{
246 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkConfig);
247 return pThis->pIAboveConfig->pfnGetLinkState(pThis->pIAboveConfig);
248}
249
250/**
251 * Sets the new link state.
252 *
253 * @returns VBox status code.
254 * @param pInterface Pointer to the interface structure containing the called function pointer.
255 * @param enmState The new link state
256 * @thread EMT
257 */
258static DECLCALLBACK(int) drvNetShaperDownCfg_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
259{
260 PDRVNETSHAPER pThis = RT_FROM_MEMBER(pInterface, DRVNETSHAPER, INetworkConfig);
261 return pThis->pIAboveConfig->pfnSetLinkState(pThis->pIAboveConfig, enmState);
262}
263
264
265/**
266 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
267 */
268static DECLCALLBACK(void *) drvNetShaperQueryInterface(PPDMIBASE pInterface, const char *pszIID)
269{
270 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
271 PDRVNETSHAPER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSHAPER);
272 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
273 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUp);
274 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
275 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
276 return NULL;
277}
278
279
280/**
281 * @interface_method_impl{PDMDRVREG,pfnDetach}
282 */
283static DECLCALLBACK(void) drvNetShaperDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
284{
285 PDRVNETSHAPER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSHAPER);
286
287 LogFlow(("drvNetShaperDetach: pDrvIns: %p, fFlags: %u\n", pDrvIns, fFlags));
288 RTCritSectEnter(&pThis->XmitLock);
289 pThis->pIBelowNet = NULL;
290 RTCritSectLeave(&pThis->XmitLock);
291}
292
293
294/**
295 * @interface_method_impl{PDMDRVREG,pfnAttach}
296 */
297static DECLCALLBACK(int) drvNetShaperAttach(PPDMDRVINS pDrvIns, uint32_t fFlags)
298{
299 PDRVNETSHAPER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSHAPER);
300 LogFlow(("drvNetShaperAttach/#%#x: fFlags=%#x\n", pDrvIns->iInstance, fFlags));
301 RTCritSectEnter(&pThis->XmitLock);
302
303 /*
304 * Query the network connector interface.
305 */
306 PPDMIBASE pBaseDown;
307 int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
308 if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
309 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
310 {
311 pThis->pIBelowNet = NULL;
312 rc = VINF_SUCCESS;
313 }
314 else if (RT_SUCCESS(rc))
315 {
316 pThis->pIBelowNet = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
317 if (pThis->pIBelowNet)
318 rc = VINF_SUCCESS;
319 else
320 {
321 AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
322 rc = VERR_PDM_MISSING_INTERFACE_BELOW;
323 }
324 }
325 else
326 AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
327
328 RTCritSectLeave(&pThis->XmitLock);
329 return VINF_SUCCESS;
330}
331
332
333/**
334 * @interface_method_impl{PDMDRVREG,pfnDestruct}
335 */
336static DECLCALLBACK(void) drvNetShaperDestruct(PPDMDRVINS pDrvIns)
337{
338 PDRVNETSHAPER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSHAPER);
339 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
340
341 PDMDrvHlpNetShaperDetach(pDrvIns, &pThis->Filter);
342
343 if (RTCritSectIsInitialized(&pThis->XmitLock))
344 RTCritSectDelete(&pThis->XmitLock);
345}
346
347
348/**
349 * @interface_method_impl{Construct a NAT network transport driver instance,
350 * PDMDRVREG,pfnDestruct}
351 */
352static DECLCALLBACK(int) drvNetShaperConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
353{
354 PDRVNETSHAPER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSHAPER);
355 LogFlow(("drvNetShaperConstruct:\n"));
356 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
357
358 /*
359 * Init the static parts.
360 */
361 /* IBase */
362 pDrvIns->IBase.pfnQueryInterface = drvNetShaperQueryInterface;
363 /* INetworkUp */
364 pThis->INetworkUp.pfnBeginXmit = drvNetShaperUp_BeginXmit;
365 pThis->INetworkUp.pfnAllocBuf = drvNetShaperUp_AllocBuf;
366 pThis->INetworkUp.pfnFreeBuf = drvNetShaperUp_FreeBuf;
367 pThis->INetworkUp.pfnSendBuf = drvNetShaperUp_SendBuf;
368 pThis->INetworkUp.pfnEndXmit = drvNetShaperUp_EndXmit;
369 pThis->INetworkUp.pfnSetPromiscuousMode = drvNetShaperUp_SetPromiscuousMode;
370 pThis->INetworkUp.pfnNotifyLinkChanged = drvNetShaperUp_NotifyLinkChanged;
371 /* INetworkDown */
372 pThis->INetworkDown.pfnWaitReceiveAvail = drvNetShaperDown_WaitReceiveAvail;
373 pThis->INetworkDown.pfnReceive = drvNetShaperDown_Receive;
374 pThis->INetworkDown.pfnXmitPending = drvNetShaperDown_XmitPending;
375 /* INetworkConfig */
376 pThis->INetworkConfig.pfnGetMac = drvNetShaperDownCfg_GetMac;
377 pThis->INetworkConfig.pfnGetLinkState = drvNetShaperDownCfg_GetLinkState;
378 pThis->INetworkConfig.pfnSetLinkState = drvNetShaperDownCfg_SetLinkState;
379
380 /*
381 * Create the locks.
382 */
383 int rc = RTCritSectInit(&pThis->XmitLock);
384 AssertRCReturn(rc, rc);
385
386 /*
387 * Validate the config.
388 */
389 if (!CFGMR3AreValuesValid(pCfg, "BwGroup\0"))
390 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
391
392 /*
393 * Find the bandwidth group we have to attach to.
394 */
395 rc = CFGMR3QueryStringAlloc(pCfg, "BwGroup", &pThis->pszBwGroup);
396 if (RT_FAILURE(rc) && rc != VERR_CFGM_VALUE_NOT_FOUND)
397 {
398 rc = PDMDRV_SET_ERROR(pDrvIns, rc,
399 N_("DrvNetShaper: Configuration error: Querying \"BwGroup\" as string failed"));
400 return rc;
401 }
402 else
403 rc = VINF_SUCCESS;
404
405 pThis->Filter.pIDrvNet = &pThis->INetworkDown;
406 rc = PDMDrvHlpNetShaperAttach(pDrvIns, pThis->pszBwGroup, &pThis->Filter);
407 if (RT_FAILURE(rc))
408 {
409 rc = PDMDRV_SET_ERROR(pDrvIns, rc,
410 N_("DrvNetShaper: Configuration error: Failed to attach to bandwidth group"));
411 return rc;
412 }
413
414 /*
415 * Query the network port interface.
416 */
417 pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
418 if (!pThis->pIAboveNet)
419 {
420 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
421 return VERR_PDM_MISSING_INTERFACE_ABOVE;
422 }
423
424 /*
425 * Query the network config interface.
426 */
427 pThis->pIAboveConfig = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
428 if (!pThis->pIAboveConfig)
429 {
430 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
431 return VERR_PDM_MISSING_INTERFACE_ABOVE;
432 }
433
434 /*
435 * Query the network connector interface.
436 */
437 PPDMIBASE pBaseDown;
438 rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
439 if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
440 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
441 pThis->pIBelowNet = NULL;
442 else if (RT_SUCCESS(rc))
443 {
444 pThis->pIBelowNet = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
445 if (!pThis->pIBelowNet)
446 {
447 AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
448 return VERR_PDM_MISSING_INTERFACE_BELOW;
449 }
450 }
451 else
452 {
453 AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
454 return rc;
455 }
456
457 /*
458 * Register statistics.
459 */
460 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->StatXmitBytesRequested, "Bytes/Tx/Requested", STAMUNIT_BYTES, "Number of requested TX bytes.");
461 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->StatXmitBytesDenied, "Bytes/Tx/Denied", STAMUNIT_BYTES, "Number of denied TX bytes.");
462 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->StatXmitBytesGranted, "Bytes/Tx/Granted", STAMUNIT_BYTES, "Number of granted TX bytes.");
463
464 PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPktsRequested, "Packets/Tx/Requested", "Number of requested TX packets.");
465 PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPktsDenied, "Packets/Tx/Denied", "Number of denied TX packets.");
466 PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPktsGranted, "Packets/Tx/Granted", "Number of granted TX packets.");
467 PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPendingCalled, "Tx/WakeUp", "Number of wakeup TX calls.");
468
469 return VINF_SUCCESS;
470}
471
472
473
474/**
475 * Network sniffer filter driver registration record.
476 */
477const PDMDRVREG g_DrvNetShaper =
478{
479 /* u32Version */
480 PDM_DRVREG_VERSION,
481 /* szName */
482 "NetShaper",
483 /* szRCMod */
484 "",
485 /* szR0Mod */
486 "",
487 /* pszDescription */
488 "Network Shaper Filter Driver",
489 /* fFlags */
490 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
491 /* fClass. */
492 PDM_DRVREG_CLASS_NETWORK,
493 /* cMaxInstances */
494 UINT32_MAX,
495 /* cbInstance */
496 sizeof(DRVNETSHAPER),
497 /* pfnConstruct */
498 drvNetShaperConstruct,
499 /* pfnDestruct */
500 drvNetShaperDestruct,
501 /* pfnRelocate */
502 NULL,
503 /* pfnIOCtl */
504 NULL,
505 /* pfnPowerOn */
506 NULL,
507 /* pfnReset */
508 NULL,
509 /* pfnSuspend */
510 NULL,
511 /* pfnResume */
512 NULL,
513 /* pfnAttach */
514 drvNetShaperAttach,
515 /* pfnDetach */
516 drvNetShaperDetach,
517 /* pfnPowerOff */
518 NULL,
519 /* pfnSoftReset */
520 NULL,
521 /* u32EndVersion */
522 PDM_DRVREG_VERSION
523};
524
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use