VirtualBox

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

Last change on this file since 59202 was 57358, checked in by vboxsync, 9 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use