VirtualBox

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

Last change on this file was 98103, checked in by vboxsync, 16 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use