VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/DrvTAP.cpp@ 69498

Last change on this file since 69498 was 69498, checked in by vboxsync, 7 years ago

backed out r118835 as it incorrectly updated the 'This file is based on' file headers.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 37.2 KB
Line 
1/* $Id: DrvTAP.cpp 69498 2017-10-28 15:07:25Z vboxsync $ */
2/** @file
3 * DrvTAP - Universal TAP network transport driver.
4 */
5
6/*
7 * Copyright (C) 2006-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_DRV_TUN
23#include <VBox/log.h>
24#include <VBox/vmm/pdmdrv.h>
25#include <VBox/vmm/pdmnetifs.h>
26#include <VBox/vmm/pdmnetinline.h>
27
28#include <iprt/asm.h>
29#include <iprt/assert.h>
30#include <iprt/ctype.h>
31#include <iprt/file.h>
32#include <iprt/mem.h>
33#include <iprt/path.h>
34#include <iprt/pipe.h>
35#include <iprt/semaphore.h>
36#include <iprt/string.h>
37#include <iprt/thread.h>
38#include <iprt/uuid.h>
39#ifdef RT_OS_SOLARIS
40# include <iprt/process.h>
41# include <iprt/env.h>
42#endif
43
44#include <sys/ioctl.h>
45#include <sys/poll.h>
46#ifdef RT_OS_SOLARIS
47# include <sys/stat.h>
48# include <sys/ethernet.h>
49# include <sys/sockio.h>
50# include <netinet/in.h>
51# include <netinet/in_systm.h>
52# include <netinet/ip.h>
53# include <netinet/ip_icmp.h>
54# include <netinet/udp.h>
55# include <netinet/tcp.h>
56# include <net/if.h>
57# include <stropts.h>
58# include <fcntl.h>
59# include <stdlib.h>
60# include <stdio.h>
61#else
62# include <sys/fcntl.h>
63#endif
64#include <errno.h>
65#include <unistd.h>
66
67#include "VBoxDD.h"
68
69
70/*********************************************************************************************************************************
71* Structures and Typedefs *
72*********************************************************************************************************************************/
73/**
74 * TAP driver instance data.
75 *
76 * @implements PDMINETWORKUP
77 */
78typedef struct DRVTAP
79{
80 /** The network interface. */
81 PDMINETWORKUP INetworkUp;
82 /** The network interface. */
83 PPDMINETWORKDOWN pIAboveNet;
84 /** Pointer to the driver instance. */
85 PPDMDRVINS pDrvIns;
86 /** TAP device file handle. */
87 RTFILE hFileDevice;
88 /** The configured TAP device name. */
89 char *pszDeviceName;
90#ifdef RT_OS_SOLARIS
91 /** IP device file handle (/dev/udp). */
92 int iIPFileDes;
93 /** Whether device name is obtained from setup application. */
94 bool fStatic;
95#endif
96 /** TAP setup application. */
97 char *pszSetupApplication;
98 /** TAP terminate application. */
99 char *pszTerminateApplication;
100 /** The write end of the control pipe. */
101 RTPIPE hPipeWrite;
102 /** The read end of the control pipe. */
103 RTPIPE hPipeRead;
104 /** Reader thread. */
105 PPDMTHREAD pThread;
106
107 /** @todo The transmit thread. */
108 /** Transmit lock used by drvTAPNetworkUp_BeginXmit. */
109 RTCRITSECT XmitLock;
110
111#ifdef VBOX_WITH_STATISTICS
112 /** Number of sent packets. */
113 STAMCOUNTER StatPktSent;
114 /** Number of sent bytes. */
115 STAMCOUNTER StatPktSentBytes;
116 /** Number of received packets. */
117 STAMCOUNTER StatPktRecv;
118 /** Number of received bytes. */
119 STAMCOUNTER StatPktRecvBytes;
120 /** Profiling packet transmit runs. */
121 STAMPROFILE StatTransmit;
122 /** Profiling packet receive runs. */
123 STAMPROFILEADV StatReceive;
124#endif /* VBOX_WITH_STATISTICS */
125
126#ifdef LOG_ENABLED
127 /** The nano ts of the last transfer. */
128 uint64_t u64LastTransferTS;
129 /** The nano ts of the last receive. */
130 uint64_t u64LastReceiveTS;
131#endif
132} DRVTAP, *PDRVTAP;
133
134
135/** Converts a pointer to TAP::INetworkUp to a PRDVTAP. */
136#define PDMINETWORKUP_2_DRVTAP(pInterface) ( (PDRVTAP)((uintptr_t)pInterface - RT_OFFSETOF(DRVTAP, INetworkUp)) )
137
138
139/*********************************************************************************************************************************
140* Internal Functions *
141*********************************************************************************************************************************/
142#ifdef RT_OS_SOLARIS
143static int SolarisTAPAttach(PDRVTAP pThis);
144#endif
145
146
147
148/**
149 * @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
150 */
151static DECLCALLBACK(int) drvTAPNetworkUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
152{
153 RT_NOREF(fOnWorkerThread);
154 PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
155 int rc = RTCritSectTryEnter(&pThis->XmitLock);
156 if (RT_FAILURE(rc))
157 {
158 /** @todo XMIT thread */
159 rc = VERR_TRY_AGAIN;
160 }
161 return rc;
162}
163
164
165/**
166 * @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
167 */
168static DECLCALLBACK(int) drvTAPNetworkUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
169 PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
170{
171 RT_NOREF(pInterface);
172#ifdef VBOX_STRICT
173 PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
174 Assert(RTCritSectIsOwner(&pThis->XmitLock));
175#endif
176
177 /*
178 * Allocate a scatter / gather buffer descriptor that is immediately
179 * followed by the buffer space of its single segment. The GSO context
180 * comes after that again.
181 */
182 PPDMSCATTERGATHER pSgBuf = (PPDMSCATTERGATHER)RTMemAlloc( RT_ALIGN_Z(sizeof(*pSgBuf), 16)
183 + RT_ALIGN_Z(cbMin, 16)
184 + (pGso ? RT_ALIGN_Z(sizeof(*pGso), 16) : 0));
185 if (!pSgBuf)
186 return VERR_NO_MEMORY;
187
188 /*
189 * Initialize the S/G buffer and return.
190 */
191 pSgBuf->fFlags = PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1;
192 pSgBuf->cbUsed = 0;
193 pSgBuf->cbAvailable = RT_ALIGN_Z(cbMin, 16);
194 pSgBuf->pvAllocator = NULL;
195 if (!pGso)
196 pSgBuf->pvUser = NULL;
197 else
198 {
199 pSgBuf->pvUser = (uint8_t *)(pSgBuf + 1) + pSgBuf->cbAvailable;
200 *(PPDMNETWORKGSO)pSgBuf->pvUser = *pGso;
201 }
202 pSgBuf->cSegs = 1;
203 pSgBuf->aSegs[0].cbSeg = pSgBuf->cbAvailable;
204 pSgBuf->aSegs[0].pvSeg = pSgBuf + 1;
205
206#if 0 /* poison */
207 memset(pSgBuf->aSegs[0].pvSeg, 'F', pSgBuf->aSegs[0].cbSeg);
208#endif
209 *ppSgBuf = pSgBuf;
210 return VINF_SUCCESS;
211}
212
213
214/**
215 * @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
216 */
217static DECLCALLBACK(int) drvTAPNetworkUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
218{
219 RT_NOREF(pInterface);
220#ifdef VBOX_STRICT
221 PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
222 Assert(RTCritSectIsOwner(&pThis->XmitLock));
223#endif
224
225 if (pSgBuf)
226 {
227 Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
228 pSgBuf->fFlags = 0;
229 RTMemFree(pSgBuf);
230 }
231 return VINF_SUCCESS;
232}
233
234
235/**
236 * @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
237 */
238static DECLCALLBACK(int) drvTAPNetworkUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
239{
240 RT_NOREF(fOnWorkerThread);
241 PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
242 STAM_COUNTER_INC(&pThis->StatPktSent);
243 STAM_COUNTER_ADD(&pThis->StatPktSentBytes, pSgBuf->cbUsed);
244 STAM_PROFILE_START(&pThis->StatTransmit, a);
245
246 AssertPtr(pSgBuf);
247 Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
248 Assert(RTCritSectIsOwner(&pThis->XmitLock));
249
250 /* Set an FTM checkpoint as this operation changes the state permanently. */
251 PDMDrvHlpFTSetCheckpoint(pThis->pDrvIns, FTMCHECKPOINTTYPE_NETWORK);
252
253 int rc;
254 if (!pSgBuf->pvUser)
255 {
256#ifdef LOG_ENABLED
257 uint64_t u64Now = RTTimeProgramNanoTS();
258 LogFlow(("drvTAPSend: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
259 pSgBuf->cbUsed, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
260 pThis->u64LastTransferTS = u64Now;
261#endif
262 Log2(("drvTAPSend: pSgBuf->aSegs[0].pvSeg=%p pSgBuf->cbUsed=%#x\n"
263 "%.*Rhxd\n",
264 pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, pSgBuf->cbUsed, pSgBuf->aSegs[0].pvSeg));
265
266 rc = RTFileWrite(pThis->hFileDevice, pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, NULL);
267 }
268 else
269 {
270 uint8_t abHdrScratch[256];
271 uint8_t const *pbFrame = (uint8_t const *)pSgBuf->aSegs[0].pvSeg;
272 PCPDMNETWORKGSO pGso = (PCPDMNETWORKGSO)pSgBuf->pvUser;
273 uint32_t const cSegs = PDMNetGsoCalcSegmentCount(pGso, pSgBuf->cbUsed); Assert(cSegs > 1);
274 rc = VINF_SUCCESS;
275 for (size_t iSeg = 0; iSeg < cSegs; iSeg++)
276 {
277 uint32_t cbSegFrame;
278 void *pvSegFrame = PDMNetGsoCarveSegmentQD(pGso, (uint8_t *)pbFrame, pSgBuf->cbUsed, abHdrScratch,
279 iSeg, cSegs, &cbSegFrame);
280 rc = RTFileWrite(pThis->hFileDevice, pvSegFrame, cbSegFrame, NULL);
281 if (RT_FAILURE(rc))
282 break;
283 }
284 }
285
286 pSgBuf->fFlags = 0;
287 RTMemFree(pSgBuf);
288
289 STAM_PROFILE_STOP(&pThis->StatTransmit, a);
290 AssertRC(rc);
291 if (RT_FAILURE(rc))
292 rc = rc == VERR_NO_MEMORY ? VERR_NET_NO_BUFFER_SPACE : VERR_NET_DOWN;
293 return rc;
294}
295
296
297/**
298 * @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
299 */
300static DECLCALLBACK(void) drvTAPNetworkUp_EndXmit(PPDMINETWORKUP pInterface)
301{
302 PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
303 RTCritSectLeave(&pThis->XmitLock);
304}
305
306
307/**
308 * @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
309 */
310static DECLCALLBACK(void) drvTAPNetworkUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
311{
312 RT_NOREF(pInterface, fPromiscuous);
313 LogFlow(("drvTAPNetworkUp_SetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
314 /* nothing to do */
315}
316
317
318/**
319 * Notification on link status changes.
320 *
321 * @param pInterface Pointer to the interface structure containing the called function pointer.
322 * @param enmLinkState The new link state.
323 * @thread EMT
324 */
325static DECLCALLBACK(void) drvTAPNetworkUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
326{
327 RT_NOREF(pInterface, enmLinkState);
328 LogFlow(("drvTAPNetworkUp_NotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
329 /** @todo take action on link down and up. Stop the polling and such like. */
330}
331
332
333/**
334 * Asynchronous I/O thread for handling receive.
335 *
336 * @returns VINF_SUCCESS (ignored).
337 * @param Thread Thread handle.
338 * @param pvUser Pointer to a DRVTAP structure.
339 */
340static DECLCALLBACK(int) drvTAPAsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
341{
342 PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
343 LogFlow(("drvTAPAsyncIoThread: pThis=%p\n", pThis));
344
345 if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
346 return VINF_SUCCESS;
347
348 STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
349
350 /*
351 * Polling loop.
352 */
353 while (pThread->enmState == PDMTHREADSTATE_RUNNING)
354 {
355 /*
356 * Wait for something to become available.
357 */
358 struct pollfd aFDs[2];
359 aFDs[0].fd = RTFileToNative(pThis->hFileDevice);
360 aFDs[0].events = POLLIN | POLLPRI;
361 aFDs[0].revents = 0;
362 aFDs[1].fd = RTPipeToNative(pThis->hPipeRead);
363 aFDs[1].events = POLLIN | POLLPRI | POLLERR | POLLHUP;
364 aFDs[1].revents = 0;
365 STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
366 errno=0;
367 int rc = poll(&aFDs[0], RT_ELEMENTS(aFDs), -1 /* infinite */);
368
369 /* this might have changed in the meantime */
370 if (pThread->enmState != PDMTHREADSTATE_RUNNING)
371 break;
372
373 STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
374 if ( rc > 0
375 && (aFDs[0].revents & (POLLIN | POLLPRI))
376 && !aFDs[1].revents)
377 {
378 /*
379 * Read the frame.
380 */
381 char achBuf[16384];
382 size_t cbRead = 0;
383 /** @note At least on Linux we will never receive more than one network packet
384 * after poll() returned successfully. I don't know why but a second
385 * RTFileRead() operation will return with VERR_TRY_AGAIN in any case. */
386 rc = RTFileRead(pThis->hFileDevice, achBuf, sizeof(achBuf), &cbRead);
387 if (RT_SUCCESS(rc))
388 {
389 /*
390 * Wait for the device to have space for this frame.
391 * Most guests use frame-sized receive buffers, hence non-zero cbMax
392 * automatically means there is enough room for entire frame. Some
393 * guests (eg. Solaris) use large chains of small receive buffers
394 * (each 128 or so bytes large). We will still start receiving as soon
395 * as cbMax is non-zero because:
396 * - it would be quite expensive for pfnCanReceive to accurately
397 * determine free receive buffer space
398 * - if we were waiting for enough free buffers, there is a risk
399 * of deadlocking because the guest could be waiting for a receive
400 * overflow error to allocate more receive buffers
401 */
402 STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
403 int rc1 = pThis->pIAboveNet->pfnWaitReceiveAvail(pThis->pIAboveNet, RT_INDEFINITE_WAIT);
404 STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
405
406 /*
407 * A return code != VINF_SUCCESS means that we were woken up during a VM
408 * state transition. Drop the packet and wait for the next one.
409 */
410 if (RT_FAILURE(rc1))
411 continue;
412
413 /*
414 * Pass the data up.
415 */
416#ifdef LOG_ENABLED
417 uint64_t u64Now = RTTimeProgramNanoTS();
418 LogFlow(("drvTAPAsyncIoThread: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
419 cbRead, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
420 pThis->u64LastReceiveTS = u64Now;
421#endif
422 Log2(("drvTAPAsyncIoThread: cbRead=%#x\n" "%.*Rhxd\n", cbRead, cbRead, achBuf));
423 STAM_COUNTER_INC(&pThis->StatPktRecv);
424 STAM_COUNTER_ADD(&pThis->StatPktRecvBytes, cbRead);
425 rc1 = pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, achBuf, cbRead);
426 AssertRC(rc1);
427 }
428 else
429 {
430 LogFlow(("drvTAPAsyncIoThread: RTFileRead -> %Rrc\n", rc));
431 if (rc == VERR_INVALID_HANDLE)
432 break;
433 RTThreadYield();
434 }
435 }
436 else if ( rc > 0
437 && aFDs[1].revents)
438 {
439 LogFlow(("drvTAPAsyncIoThread: Control message: enmState=%d revents=%#x\n", pThread->enmState, aFDs[1].revents));
440 if (aFDs[1].revents & (POLLHUP | POLLERR | POLLNVAL))
441 break;
442
443 /* drain the pipe */
444 char ch;
445 size_t cbRead;
446 RTPipeRead(pThis->hPipeRead, &ch, 1, &cbRead);
447 }
448 else
449 {
450 /*
451 * poll() failed for some reason. Yield to avoid eating too much CPU.
452 *
453 * EINTR errors have been seen frequently. They should be harmless, even
454 * if they are not supposed to occur in our setup.
455 */
456 if (errno == EINTR)
457 Log(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
458 else
459 AssertMsgFailed(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
460 RTThreadYield();
461 }
462 }
463
464
465 LogFlow(("drvTAPAsyncIoThread: returns %Rrc\n", VINF_SUCCESS));
466 STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
467 return VINF_SUCCESS;
468}
469
470
471/**
472 * Unblock the send thread so it can respond to a state change.
473 *
474 * @returns VBox status code.
475 * @param pDevIns The pcnet device instance.
476 * @param pThread The send thread.
477 */
478static DECLCALLBACK(int) drvTapAsyncIoWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
479{
480 RT_NOREF(pThread);
481 PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
482
483 size_t cbIgnored;
484 int rc = RTPipeWrite(pThis->hPipeWrite, "", 1, &cbIgnored);
485 AssertRC(rc);
486
487 return VINF_SUCCESS;
488}
489
490
491#if defined(RT_OS_SOLARIS)
492/**
493 * Calls OS-specific TAP setup application/script.
494 *
495 * @returns VBox error code.
496 * @param pThis The instance data.
497 */
498static int drvTAPSetupApplication(PDRVTAP pThis)
499{
500 char szCommand[4096];
501
502 RTStrPrintf(szCommand, sizeof(szCommand), "%s %s", pThis->pszSetupApplication,
503 pThis->fStatic ? pThis->pszDeviceName : "");
504
505 /* Pipe open the setup application. */
506 Log2(("Starting TAP setup application: %s\n", szCommand));
507 FILE* pfSetupHandle = popen(szCommand, "r");
508 if (pfSetupHandle == 0)
509 {
510 LogRel(("TAP#%d: Failed to run TAP setup application: %s\n", pThis->pDrvIns->iInstance,
511 pThis->pszSetupApplication, strerror(errno)));
512 return VERR_HOSTIF_INIT_FAILED;
513 }
514 if (!pThis->fStatic)
515 {
516 /* Obtain device name from setup application. */
517 char acBuffer[64];
518 size_t cBufSize;
519 fgets(acBuffer, sizeof(acBuffer), pfSetupHandle);
520 cBufSize = strlen(acBuffer);
521 /* The script must return the name of the interface followed by a carriage return as the
522 first line of its output. We need a null-terminated string. */
523 if ((cBufSize < 2) || (acBuffer[cBufSize - 1] != '\n'))
524 {
525 pclose(pfSetupHandle);
526 LogRel(("The TAP interface setup script did not return the name of a TAP device.\n"));
527 return VERR_HOSTIF_INIT_FAILED;
528 }
529 /* Overwrite the terminating newline character. */
530 acBuffer[cBufSize - 1] = 0;
531 RTStrAPrintf(&pThis->pszDeviceName, "%s", acBuffer);
532 }
533 int rc = pclose(pfSetupHandle);
534 if (!WIFEXITED(rc))
535 {
536 LogRel(("The TAP interface setup script terminated abnormally.\n"));
537 return VERR_HOSTIF_INIT_FAILED;
538 }
539 if (WEXITSTATUS(rc) != 0)
540 {
541 LogRel(("The TAP interface setup script returned a non-zero exit code.\n"));
542 return VERR_HOSTIF_INIT_FAILED;
543 }
544 return VINF_SUCCESS;
545}
546
547
548/**
549 * Calls OS-specific TAP terminate application/script.
550 *
551 * @returns VBox error code.
552 * @param pThis The instance data.
553 */
554static int drvTAPTerminateApplication(PDRVTAP pThis)
555{
556 char *pszArgs[3];
557 pszArgs[0] = pThis->pszTerminateApplication;
558 pszArgs[1] = pThis->pszDeviceName;
559 pszArgs[2] = NULL;
560
561 Log2(("Starting TAP terminate application: %s %s\n", pThis->pszTerminateApplication, pThis->pszDeviceName));
562 RTPROCESS pid = NIL_RTPROCESS;
563 int rc = RTProcCreate(pszArgs[0], pszArgs, RTENV_DEFAULT, 0, &pid);
564 if (RT_SUCCESS(rc))
565 {
566 RTPROCSTATUS Status;
567 rc = RTProcWait(pid, 0, &Status);
568 if (RT_SUCCESS(rc))
569 {
570 if ( Status.iStatus == 0
571 && Status.enmReason == RTPROCEXITREASON_NORMAL)
572 return VINF_SUCCESS;
573
574 LogRel(("TAP#%d: Error running TAP terminate application: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
575 }
576 else
577 LogRel(("TAP#%d: RTProcWait failed for: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
578 }
579 else
580 {
581 /* Bad. RTProcCreate() failed! */
582 LogRel(("TAP#%d: Failed to fork() process for running TAP terminate application: %s\n", pThis->pDrvIns->iInstance,
583 pThis->pszTerminateApplication, strerror(errno)));
584 }
585 return VERR_HOSTIF_TERM_FAILED;
586}
587
588#endif /* RT_OS_SOLARIS */
589
590
591#ifdef RT_OS_SOLARIS
592/** From net/if_tun.h, installed by Universal TUN/TAP driver */
593# define TUNNEWPPA (('T'<<16) | 0x0001)
594/** Whether to enable ARP for TAP. */
595# define VBOX_SOLARIS_TAP_ARP 1
596
597/**
598 * Creates/Attaches TAP device to IP.
599 *
600 * @returns VBox error code.
601 * @param pThis The instance data.
602 */
603static DECLCALLBACK(int) SolarisTAPAttach(PDRVTAP pThis)
604{
605 LogFlow(("SolarisTapAttach: pThis=%p\n", pThis));
606
607
608 int IPFileDes = open("/dev/udp", O_RDWR, 0);
609 if (IPFileDes < 0)
610 return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
611 N_("Failed to open /dev/udp. errno=%d"), errno);
612
613 int TapFileDes = open("/dev/tap", O_RDWR, 0);
614 if (TapFileDes < 0)
615 return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
616 N_("Failed to open /dev/tap for TAP. errno=%d"), errno);
617
618 /* Use the PPA from the ifname if possible (e.g "tap2", then use 2 as PPA) */
619 int iPPA = -1;
620 if (pThis->pszDeviceName)
621 {
622 size_t cch = strlen(pThis->pszDeviceName);
623 if (cch > 1 && RT_C_IS_DIGIT(pThis->pszDeviceName[cch - 1]) != 0)
624 iPPA = pThis->pszDeviceName[cch - 1] - '0';
625 }
626
627 struct strioctl ioIF;
628 ioIF.ic_cmd = TUNNEWPPA;
629 ioIF.ic_len = sizeof(iPPA);
630 ioIF.ic_dp = (char *)(&iPPA);
631 ioIF.ic_timout = 0;
632 iPPA = ioctl(TapFileDes, I_STR, &ioIF);
633 if (iPPA < 0)
634 {
635 close(TapFileDes);
636 return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
637 N_("Failed to get new interface. errno=%d"), errno);
638 }
639
640 int InterfaceFD = open("/dev/tap", O_RDWR, 0);
641 if (!InterfaceFD)
642 return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
643 N_("Failed to open interface /dev/tap. errno=%d"), errno);
644
645 if (ioctl(InterfaceFD, I_PUSH, "ip") == -1)
646 {
647 close(InterfaceFD);
648 return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
649 N_("Failed to push IP. errno=%d"), errno);
650 }
651
652 struct lifreq ifReq;
653 memset(&ifReq, 0, sizeof(ifReq));
654 if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
655 LogRel(("TAP#%d: Failed to get interface flags.\n", pThis->pDrvIns->iInstance));
656
657 ifReq.lifr_ppa = iPPA;
658 RTStrCopy(ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
659
660 if (ioctl(InterfaceFD, SIOCSLIFNAME, &ifReq) == -1)
661 LogRel(("TAP#%d: Failed to set PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
662
663 if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
664 LogRel(("TAP#%d: Failed to get interface flags after setting PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
665
666# ifdef VBOX_SOLARIS_TAP_ARP
667 /* Interface */
668 if (ioctl(InterfaceFD, I_PUSH, "arp") == -1)
669 LogRel(("TAP#%d: Failed to push ARP to Interface FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
670
671 /* IP */
672 if (ioctl(IPFileDes, I_POP, NULL) == -1)
673 LogRel(("TAP#%d: Failed I_POP from IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
674
675 if (ioctl(IPFileDes, I_PUSH, "arp") == -1)
676 LogRel(("TAP#%d: Failed to push ARP to IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
677
678 /* ARP */
679 int ARPFileDes = open("/dev/tap", O_RDWR, 0);
680 if (ARPFileDes < 0)
681 LogRel(("TAP#%d: Failed to open for /dev/tap for ARP. errno=%d", pThis->pDrvIns->iInstance, errno));
682
683 if (ioctl(ARPFileDes, I_PUSH, "arp") == -1)
684 LogRel(("TAP#%d: Failed to push ARP to ARP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
685
686 ioIF.ic_cmd = SIOCSLIFNAME;
687 ioIF.ic_timout = 0;
688 ioIF.ic_len = sizeof(ifReq);
689 ioIF.ic_dp = (char *)&ifReq;
690 if (ioctl(ARPFileDes, I_STR, &ioIF) == -1)
691 LogRel(("TAP#%d: Failed to set interface name to ARP.\n", pThis->pDrvIns->iInstance));
692# endif
693
694 /* We must use I_LINK and not I_PLINK as I_PLINK makes the link persistent.
695 * Then we would not be able unlink the interface if we reuse it.
696 * Even 'unplumb' won't work after that.
697 */
698 int IPMuxID = ioctl(IPFileDes, I_LINK, InterfaceFD);
699 if (IPMuxID == -1)
700 {
701 close(InterfaceFD);
702# ifdef VBOX_SOLARIS_TAP_ARP
703 close(ARPFileDes);
704# endif
705 LogRel(("TAP#%d: Cannot link TAP device to IP.\n", pThis->pDrvIns->iInstance));
706 return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
707 N_("Failed to link TAP device to IP. Check TAP interface name. errno=%d"), errno);
708 }
709
710# ifdef VBOX_SOLARIS_TAP_ARP
711 int ARPMuxID = ioctl(IPFileDes, I_LINK, ARPFileDes);
712 if (ARPMuxID == -1)
713 LogRel(("TAP#%d: Failed to link TAP device to ARP\n", pThis->pDrvIns->iInstance));
714
715 close(ARPFileDes);
716# endif
717 close(InterfaceFD);
718
719 /* Reuse ifReq */
720 memset(&ifReq, 0, sizeof(ifReq));
721 RTStrCopy(ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
722 ifReq.lifr_ip_muxid = IPMuxID;
723# ifdef VBOX_SOLARIS_TAP_ARP
724 ifReq.lifr_arp_muxid = ARPMuxID;
725# endif
726
727 if (ioctl(IPFileDes, SIOCSLIFMUXID, &ifReq) == -1)
728 {
729# ifdef VBOX_SOLARIS_TAP_ARP
730 ioctl(IPFileDes, I_PUNLINK, ARPMuxID);
731# endif
732 ioctl(IPFileDes, I_PUNLINK, IPMuxID);
733 close(IPFileDes);
734 LogRel(("TAP#%d: Failed to set Mux ID.\n", pThis->pDrvIns->iInstance));
735 return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
736 N_("Failed to set Mux ID. Check TAP interface name. errno=%d"), errno);
737 }
738
739 int rc = RTFileFromNative(&pThis->hFileDevice, TapFileDes);
740 AssertLogRelRC(rc);
741 if (RT_FAILURE(rc))
742 {
743 close(IPFileDes);
744 close(TapFileDes);
745 }
746 pThis->iIPFileDes = IPFileDes;
747
748 return VINF_SUCCESS;
749}
750
751#endif /* RT_OS_SOLARIS */
752
753/* -=-=-=-=- PDMIBASE -=-=-=-=- */
754
755/**
756 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
757 */
758static DECLCALLBACK(void *) drvTAPQueryInterface(PPDMIBASE pInterface, const char *pszIID)
759{
760 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
761 PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
762
763 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
764 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUp);
765 return NULL;
766}
767
768/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
769
770/**
771 * Destruct a driver instance.
772 *
773 * Most VM resources are freed by the VM. This callback is provided so that any non-VM
774 * resources can be freed correctly.
775 *
776 * @param pDrvIns The driver instance data.
777 */
778static DECLCALLBACK(void) drvTAPDestruct(PPDMDRVINS pDrvIns)
779{
780 LogFlow(("drvTAPDestruct\n"));
781 PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
782 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
783
784 /*
785 * Terminate the control pipe.
786 */
787 int rc;
788 if (pThis->hPipeWrite != NIL_RTPIPE)
789 {
790 rc = RTPipeClose(pThis->hPipeWrite); AssertRC(rc);
791 pThis->hPipeWrite = NIL_RTPIPE;
792 }
793 if (pThis->hPipeRead != NIL_RTPIPE)
794 {
795 rc = RTPipeClose(pThis->hPipeRead); AssertRC(rc);
796 pThis->hPipeRead = NIL_RTPIPE;
797 }
798
799#ifdef RT_OS_SOLARIS
800 /** @todo r=bird: This *does* need checking against ConsoleImpl2.cpp if used on non-solaris systems. */
801 if (pThis->hFileDevice != NIL_RTFILE)
802 {
803 int rc = RTFileClose(pThis->hFileDevice); AssertRC(rc);
804 pThis->hFileDevice = NIL_RTFILE;
805 }
806
807 /*
808 * Call TerminateApplication after closing the device otherwise
809 * TerminateApplication would not be able to unplumb it.
810 */
811 if (pThis->pszTerminateApplication)
812 drvTAPTerminateApplication(pThis);
813
814#endif /* RT_OS_SOLARIS */
815
816#ifdef RT_OS_SOLARIS
817 if (!pThis->fStatic)
818 RTStrFree(pThis->pszDeviceName); /* allocated by drvTAPSetupApplication */
819 else
820 MMR3HeapFree(pThis->pszDeviceName);
821#else
822 MMR3HeapFree(pThis->pszDeviceName);
823#endif
824 pThis->pszDeviceName = NULL;
825 MMR3HeapFree(pThis->pszSetupApplication);
826 pThis->pszSetupApplication = NULL;
827 MMR3HeapFree(pThis->pszTerminateApplication);
828 pThis->pszTerminateApplication = NULL;
829
830 /*
831 * Kill the xmit lock.
832 */
833 if (RTCritSectIsInitialized(&pThis->XmitLock))
834 RTCritSectDelete(&pThis->XmitLock);
835
836#ifdef VBOX_WITH_STATISTICS
837 /*
838 * Deregister statistics.
839 */
840 PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSent);
841 PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSentBytes);
842 PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecv);
843 PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecvBytes);
844 PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatTransmit);
845 PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatReceive);
846#endif /* VBOX_WITH_STATISTICS */
847}
848
849
850/**
851 * Construct a TAP network transport driver instance.
852 *
853 * @copydoc FNPDMDRVCONSTRUCT
854 */
855static DECLCALLBACK(int) drvTAPConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
856{
857 RT_NOREF(fFlags);
858 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
859 PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
860
861 /*
862 * Init the static parts.
863 */
864 pThis->pDrvIns = pDrvIns;
865 pThis->hFileDevice = NIL_RTFILE;
866 pThis->hPipeWrite = NIL_RTPIPE;
867 pThis->hPipeRead = NIL_RTPIPE;
868 pThis->pszDeviceName = NULL;
869#ifdef RT_OS_SOLARIS
870 pThis->iIPFileDes = -1;
871 pThis->fStatic = true;
872#endif
873 pThis->pszSetupApplication = NULL;
874 pThis->pszTerminateApplication = NULL;
875
876 /* IBase */
877 pDrvIns->IBase.pfnQueryInterface = drvTAPQueryInterface;
878 /* INetwork */
879 pThis->INetworkUp.pfnBeginXmit = drvTAPNetworkUp_BeginXmit;
880 pThis->INetworkUp.pfnAllocBuf = drvTAPNetworkUp_AllocBuf;
881 pThis->INetworkUp.pfnFreeBuf = drvTAPNetworkUp_FreeBuf;
882 pThis->INetworkUp.pfnSendBuf = drvTAPNetworkUp_SendBuf;
883 pThis->INetworkUp.pfnEndXmit = drvTAPNetworkUp_EndXmit;
884 pThis->INetworkUp.pfnSetPromiscuousMode = drvTAPNetworkUp_SetPromiscuousMode;
885 pThis->INetworkUp.pfnNotifyLinkChanged = drvTAPNetworkUp_NotifyLinkChanged;
886
887#ifdef VBOX_WITH_STATISTICS
888 /*
889 * Statistics.
890 */
891 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of sent packets.", "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
892 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of sent bytes.", "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
893 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of received packets.", "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
894 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of received bytes.", "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
895 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
896 PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.", "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
897#endif /* VBOX_WITH_STATISTICS */
898
899 /*
900 * Validate the config.
901 */
902 if (!CFGMR3AreValuesValid(pCfg, "Device\0InitProg\0TermProg\0FileHandle\0TAPSetupApplication\0TAPTerminateApplication\0MAC"))
903 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, "");
904
905 /*
906 * Check that no-one is attached to us.
907 */
908 AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
909 ("Configuration error: Not possible to attach anything to this driver!\n"),
910 VERR_PDM_DRVINS_NO_ATTACH);
911
912 /*
913 * Query the network port interface.
914 */
915 pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
916 if (!pThis->pIAboveNet)
917 return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
918 N_("Configuration error: The above device/driver didn't export the network port interface"));
919
920 /*
921 * Read the configuration.
922 */
923 int rc;
924#if defined(RT_OS_SOLARIS) /** @todo Other platforms' TAP code should be moved here from ConsoleImpl. */
925 rc = CFGMR3QueryStringAlloc(pCfg, "TAPSetupApplication", &pThis->pszSetupApplication);
926 if (RT_SUCCESS(rc))
927 {
928 if (!RTPathExists(pThis->pszSetupApplication))
929 return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
930 N_("Invalid TAP setup program path: %s"), pThis->pszSetupApplication);
931 }
932 else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
933 return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: failed to query \"TAPTerminateApplication\""));
934
935 rc = CFGMR3QueryStringAlloc(pCfg, "TAPTerminateApplication", &pThis->pszTerminateApplication);
936 if (RT_SUCCESS(rc))
937 {
938 if (!RTPathExists(pThis->pszTerminateApplication))
939 return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
940 N_("Invalid TAP terminate program path: %s"), pThis->pszTerminateApplication);
941 }
942 else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
943 return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: failed to query \"TAPTerminateApplication\""));
944
945 rc = CFGMR3QueryStringAlloc(pCfg, "Device", &pThis->pszDeviceName);
946 if (RT_FAILURE(rc))
947 pThis->fStatic = false;
948
949 /* Obtain the device name from the setup application (if none was specified). */
950 if (pThis->pszSetupApplication)
951 {
952 rc = drvTAPSetupApplication(pThis);
953 if (RT_FAILURE(rc))
954 return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
955 N_("Error running TAP setup application. rc=%d"), rc);
956 }
957
958 /*
959 * Do the setup.
960 */
961 rc = SolarisTAPAttach(pThis);
962 if (RT_FAILURE(rc))
963 return rc;
964
965#else /* !RT_OS_SOLARIS */
966
967 uint64_t u64File;
968 rc = CFGMR3QueryU64(pCfg, "FileHandle", &u64File);
969 if (RT_FAILURE(rc))
970 return PDMDRV_SET_ERROR(pDrvIns, rc,
971 N_("Configuration error: Query for \"FileHandle\" 32-bit signed integer failed"));
972 pThis->hFileDevice = (RTFILE)(uintptr_t)u64File;
973 if (!RTFileIsValid(pThis->hFileDevice))
974 return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_HANDLE, RT_SRC_POS,
975 N_("The TAP file handle %RTfile is not valid"), pThis->hFileDevice);
976#endif /* !RT_OS_SOLARIS */
977
978 /*
979 * Create the transmit lock.
980 */
981 rc = RTCritSectInit(&pThis->XmitLock);
982 AssertRCReturn(rc, rc);
983
984 /*
985 * Make sure the descriptor is non-blocking and valid.
986 *
987 * We should actually query if it's a TAP device, but I haven't
988 * found any way to do that.
989 */
990 if (fcntl(RTFileToNative(pThis->hFileDevice), F_SETFL, O_NONBLOCK) == -1)
991 return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
992 N_("Configuration error: Failed to configure /dev/net/tun. errno=%d"), errno);
993 /** @todo determine device name. This can be done by reading the link /proc/<pid>/fd/<fd> */
994 Log(("drvTAPContruct: %d (from fd)\n", (intptr_t)pThis->hFileDevice));
995 rc = VINF_SUCCESS;
996
997 /*
998 * Create the control pipe.
999 */
1000 rc = RTPipeCreate(&pThis->hPipeRead, &pThis->hPipeWrite, 0 /*fFlags*/);
1001 AssertRCReturn(rc, rc);
1002
1003 /*
1004 * Create the async I/O thread.
1005 */
1006 rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pThread, pThis, drvTAPAsyncIoThread, drvTapAsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "TAP");
1007 AssertRCReturn(rc, rc);
1008
1009 return rc;
1010}
1011
1012
1013/**
1014 * TAP network transport driver registration record.
1015 */
1016const PDMDRVREG g_DrvHostInterface =
1017{
1018 /* u32Version */
1019 PDM_DRVREG_VERSION,
1020 /* szName */
1021 "HostInterface",
1022 /* szRCMod */
1023 "",
1024 /* szR0Mod */
1025 "",
1026 /* pszDescription */
1027 "TAP Network Transport Driver",
1028 /* fFlags */
1029 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1030 /* fClass. */
1031 PDM_DRVREG_CLASS_NETWORK,
1032 /* cMaxInstances */
1033 ~0U,
1034 /* cbInstance */
1035 sizeof(DRVTAP),
1036 /* pfnConstruct */
1037 drvTAPConstruct,
1038 /* pfnDestruct */
1039 drvTAPDestruct,
1040 /* pfnRelocate */
1041 NULL,
1042 /* pfnIOCtl */
1043 NULL,
1044 /* pfnPowerOn */
1045 NULL,
1046 /* pfnReset */
1047 NULL,
1048 /* pfnSuspend */
1049 NULL, /** @todo Do power on, suspend and resume handlers! */
1050 /* pfnResume */
1051 NULL,
1052 /* pfnAttach */
1053 NULL,
1054 /* pfnDetach */
1055 NULL,
1056 /* pfnPowerOff */
1057 NULL,
1058 /* pfnSoftReset */
1059 NULL,
1060 /* u32EndVersion */
1061 PDM_DRVREG_VERSION
1062};
1063
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