virnetdevtap.c 17.8 KB
Newer Older
1
/*
E
Eric Blake 已提交
2
 * Copyright (C) 2007-2014 Red Hat, Inc.
3 4 5 6 7 8 9 10 11 12 13 14
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library.  If not, see
O
Osier Yang 已提交
16
 * <http://www.gnu.org/licenses/>.
17 18 19 20 21 22 23 24
 *
 * Authors:
 *     Mark McLoughlin <markmc@redhat.com>
 *     Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>

25
#include "virmacaddr.h"
26 27 28
#include "virnetdevtap.h"
#include "virnetdev.h"
#include "virnetdevbridge.h"
A
Ansis Atteka 已提交
29
#include "virnetdevopenvswitch.h"
30
#include "virerror.h"
31
#include "virfile.h"
32
#include "viralloc.h"
33
#include "virlog.h"
34
#include "virstring.h"
35

36 37
#include <dirent.h>
#include <sys/types.h>
38
#include <sys/ioctl.h>
39
#include <net/if.h>
40 41 42
#include <fcntl.h>
#ifdef __linux__
# include <linux/if_tun.h>    /* IFF_TUN, IFF_NO_PI */
43 44
#elif defined(__FreeBSD__)
# include <net/if_tap.h>
45 46 47 48
#endif

#define VIR_FROM_THIS VIR_FROM_NONE

49 50
VIR_LOG_INIT("util.netdevtap");

51 52 53 54 55 56 57 58 59 60 61
/**
 * virNetDevTapGetName:
 * @tapfd: a tun/tap file descriptor
 * @ifname: a pointer that will receive the interface name
 *
 * Retrieve the interface name given a file descriptor for a tun/tap
 * interface.
 *
 * Returns 0 if the interface name is successfully queried, -1 otherwise
 */
int
62
virNetDevTapGetName(int tapfd ATTRIBUTE_UNUSED, char **ifname ATTRIBUTE_UNUSED)
63 64 65 66 67 68 69 70 71 72
{
#ifdef TUNGETIFF
    struct ifreq ifr;

    if (ioctl(tapfd, TUNGETIFF, &ifr) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to query tap interface name"));
        return -1;
    }

73
    return VIR_STRDUP(*ifname, ifr.ifr_name) < 0 ? -1 : 0;
74 75 76 77 78
#else
    return -1;
#endif
}

79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
/**
 * virNetDevTapGetRealDeviceName:
 * @ifname: the interface name
 *
 * Lookup real interface name (i.e. name of the device entry in /dev),
 * because e.g. on FreeBSD if we rename tap device to vnetN its device
 * entry still remains unchanged (/dev/tapX), but bhyve needs a name
 * that matches /dev entry.
 *
 * Returns the proper interface name or NULL if no corresponding interface
 * found.
 */
char*
virNetDevTapGetRealDeviceName(char *ifname ATTRIBUTE_UNUSED)
{
#ifdef TAPGIFNAME
    char *ret = NULL;
    struct dirent *dp;
    char *devpath = NULL;
    int fd;

    DIR *dirp = opendir("/dev");
    if (dirp == NULL) {
        virReportSystemError(errno,
                             _("Failed to opendir path '%s'"),
                             "/dev");
        return NULL;
    }

E
Eric Blake 已提交
108
    while (virDirRead(dirp, &dp, "/dev") > 0) {
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
        if (STRPREFIX(dp->d_name, "tap")) {
            struct ifreq ifr;
            if (virAsprintf(&devpath, "/dev/%s", dp->d_name) < 0) {
                goto cleanup;
            }
            if ((fd = open(devpath, O_RDWR)) < 0) {
                if (errno == EBUSY) {
                    VIR_FREE(devpath);
                    continue;
                }

                virReportSystemError(errno, _("Unable to open '%s'"), devpath);
                goto cleanup;
            }

            if (ioctl(fd, TAPGIFNAME, (void *)&ifr) < 0) {
                virReportSystemError(errno, "%s",
                                     _("Unable to query tap interface name"));
                goto cleanup;
            }

            if (STREQ(ifname, ifr.ifr_name)) {
                /* we can ignore the return value
                 * because we still have nothing
                 * to do but return;
                 */
                ignore_value(VIR_STRDUP(ret, dp->d_name));
                goto cleanup;
            }

            VIR_FREE(devpath);
            VIR_FORCE_CLOSE(fd);
        }
    }

 cleanup:
    VIR_FREE(devpath);
    VIR_FORCE_CLOSE(fd);
    closedir(dirp);
    return ret;
#else
    return NULL;
#endif
}

154

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
/**
 * virNetDevProbeVnetHdr:
 * @tapfd: a tun/tap file descriptor
 *
 * Check whether it is safe to enable the IFF_VNET_HDR flag on the
 * tap interface.
 *
 * Setting IFF_VNET_HDR enables QEMU's virtio_net driver to allow
 * guests to pass larger (GSO) packets, with partial checksums, to
 * the host. This greatly increases the achievable throughput.
 *
 * It is only useful to enable this when we're setting up a virtio
 * interface. And it is only *safe* to enable it when we know for
 * sure that a) qemu has support for IFF_VNET_HDR and b) the running
 * kernel implements the TUNGETIFF ioctl(), which qemu needs to query
 * the supplied tapfd.
 *
 * Returns 1 if VnetHdr is supported, 0 if not supported
 */
#ifdef IFF_VNET_HDR
static int
virNetDevProbeVnetHdr(int tapfd)
{
# if defined(IFF_VNET_HDR) && defined(TUNGETFEATURES) && defined(TUNGETIFF)
    unsigned int features;
    struct ifreq dummy;

    if (ioctl(tapfd, TUNGETFEATURES, &features) != 0) {
        VIR_INFO("Not enabling IFF_VNET_HDR; "
                 "TUNGETFEATURES ioctl() not implemented");
        return 0;
    }

    if (!(features & IFF_VNET_HDR)) {
        VIR_INFO("Not enabling IFF_VNET_HDR; "
                 "TUNGETFEATURES ioctl() reports no IFF_VNET_HDR");
        return 0;
    }

    /* The kernel will always return -1 at this point.
     * If TUNGETIFF is not implemented then errno == EBADFD.
     */
    if (ioctl(tapfd, TUNGETIFF, &dummy) != -1 || errno != EBADFD) {
        VIR_INFO("Not enabling IFF_VNET_HDR; "
                 "TUNGETIFF ioctl() not implemented");
        return 0;
    }

    VIR_INFO("Enabling IFF_VNET_HDR");

    return 1;
# else
    (void) tapfd;
    VIR_INFO("Not enabling IFF_VNET_HDR; disabled at build time");
    return 0;
# endif
}
#endif


#ifdef TUNSETIFF
/**
217
 * virNetDevTapCreate:
218
 * @ifname: the interface name
219
 * @tunpath: path to the tun device (if NULL, /dev/net/tun is used)
220 221
 * @tapfds: array of file descriptors return value for the new tap device
 * @tapfdSize: number of file descriptors in @tapfd
222 223 224 225
 * @flags: OR of virNetDevTapCreateFlags. Only one flag is recognized:
 *
 *   VIR_NETDEV_TAP_CREATE_VNET_HDR
 *     - Enable IFF_VNET_HDR on the tap device
226 227
 *   VIR_NETDEV_TAP_CREATE_PERSIST
 *     - The device will persist after the file descriptor is closed
228
 *
229 230 231 232
 * Creates a tap interface. The caller must use virNetDevTapDelete to
 * remove a persistent TAP device when it is no longer needed. In case
 * @tapfdSize is greater than one, multiqueue extension is requested
 * from kernel.
233
 *
234
 * Returns 0 in case of success or -1 on failure.
235 236
 */
int virNetDevTapCreate(char **ifname,
237
                       const char *tunpath,
238
                       int *tapfd,
239
                       int tapfdSize,
240
                       unsigned int flags)
241
{
242
    size_t i;
243 244
    struct ifreq ifr;
    int ret = -1;
245
    int fd;
246

247 248 249
    if (!tunpath)
        tunpath = "/dev/net/tun";

250
    memset(&ifr, 0, sizeof(ifr));
251
    for (i = 0; i < tapfdSize; i++) {
252 253 254 255
        if ((fd = open(tunpath, O_RDWR)) < 0) {
            virReportSystemError(errno,
                                 _("Unable to open %s, is tun module loaded?"),
                                 tunpath);
256 257 258 259
            goto cleanup;
        }

        memset(&ifr, 0, sizeof(ifr));
260

261 262
        ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
        /* If tapfdSize is greater than one, request multiqueue */
263 264
        if (tapfdSize > 1) {
# ifdef IFF_MULTI_QUEUE
265
            ifr.ifr_flags |= IFF_MULTI_QUEUE;
266 267 268 269 270 271
# else
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Multiqueue devices are not supported on this system"));
            goto cleanup;
# endif
        }
272 273

# ifdef IFF_VNET_HDR
274 275 276
        if ((flags &  VIR_NETDEV_TAP_CREATE_VNET_HDR) &&
            virNetDevProbeVnetHdr(fd))
            ifr.ifr_flags |= IFF_VNET_HDR;
277 278
# endif

279 280 281 282 283
        if (virStrcpyStatic(ifr.ifr_name, *ifname) == NULL) {
            virReportSystemError(ERANGE,
                                 _("Network interface name '%s' is too long"),
                                 *ifname);
            goto cleanup;
284

285
        }
286

287 288 289 290 291 292
        if (ioctl(fd, TUNSETIFF, &ifr) < 0) {
            virReportSystemError(errno,
                                 _("Unable to create tap device %s"),
                                 NULLSTR(*ifname));
            goto cleanup;
        }
293

294 295 296 297
        if (i == 0) {
            /* In case we are looping more than once, set other
             * TAPs to have the same name */
            VIR_FREE(*ifname);
298
            if (VIR_STRDUP(*ifname, ifr.ifr_name) < 0)
299 300
                goto cleanup;
        }
301

302
        if ((flags & VIR_NETDEV_TAP_CREATE_PERSIST) &&
303
            ioctl(fd, TUNSETPERSIST, 1) < 0) {
304 305 306 307 308 309
            virReportSystemError(errno,
                                 _("Unable to set tap device %s to persistent"),
                                 NULLSTR(*ifname));
            goto cleanup;
        }
        tapfd[i] = fd;
310 311 312 313
    }

    ret = 0;

314
 cleanup:
315
    if (ret < 0) {
316
        VIR_FORCE_CLOSE(fd);
317 318 319
        while (i--)
            VIR_FORCE_CLOSE(tapfd[i]);
    }
320 321 322 323 324

    return ret;
}


325 326
int virNetDevTapDelete(const char *ifname,
                       const char *tunpath)
327 328 329 330 331
{
    struct ifreq try;
    int fd;
    int ret = -1;

332 333 334 335 336 337 338
    if (!tunpath)
        tunpath = "/dev/net/tun";

    if ((fd = open(tunpath, O_RDWR)) < 0) {
        virReportSystemError(errno,
                             _("Unable to open %s, is tun module loaded?"),
                             tunpath);
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
        return -1;
    }

    memset(&try, 0, sizeof(struct ifreq));
    try.ifr_flags = IFF_TAP|IFF_NO_PI;

    if (virStrcpyStatic(try.ifr_name, ifname) == NULL) {
        virReportSystemError(ERANGE,
                             _("Network interface name '%s' is too long"),
                             ifname);
        goto cleanup;
    }

    if (ioctl(fd, TUNSETIFF, &try) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to associate TAP device"));
        goto cleanup;
    }

    if (ioctl(fd, TUNSETPERSIST, 0) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to make TAP device non-persistent"));
        goto cleanup;
    }

    ret = 0;

366
 cleanup:
367 368 369
    VIR_FORCE_CLOSE(fd);
    return ret;
}
370
#elif defined(SIOCIFCREATE2) && defined(SIOCIFDESTROY) && defined(IF_MAXUNIT)
371
int virNetDevTapCreate(char **ifname,
372
                       const char *tunpath ATTRIBUTE_UNUSED,
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
                       int *tapfd,
                       int tapfdSize,
                       unsigned int flags ATTRIBUTE_UNUSED)
{
    int s;
    struct ifreq ifr;
    int ret = -1;
    char *newifname = NULL;

    if (tapfdSize > 1) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Multiqueue devices are not supported on this system"));
        goto cleanup;
    }

    /* As FreeBSD determines interface type by name,
     * we have to create 'tap' interface first and
     * then rename it to 'vnet'
     */
    if ((s = virNetDevSetupControl("tap", &ifr)) < 0)
        return -1;

    if (ioctl(s, SIOCIFCREATE2, &ifr) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to create tap device"));
        goto cleanup;
    }

    /* In case we were given exact interface name (e.g. 'vnetN'),
     * we just rename to it. If we have format string like
     * 'vnet%d', we need to find the first available name that
     * matches this pattern
     */
    if (strstr(*ifname, "%d") != NULL) {
407
        size_t i;
408 409
        for (i = 0; i <= IF_MAXUNIT; i++) {
            char *newname;
410
            if (virAsprintf(&newname, *ifname, i) < 0)
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
                goto cleanup;

            if (virNetDevExists(newname) == 0) {
                newifname = newname;
                break;
            }

            VIR_FREE(newname);
        }
        if (newifname) {
            VIR_FREE(*ifname);
            *ifname = newifname;
        } else {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Failed to generate new name for interface %s"),
                           ifr.ifr_name);
            goto cleanup;
        }
    }

    if (tapfd) {
        char *dev_path = NULL;
433
        if (virAsprintf(&dev_path, "/dev/%s", ifr.ifr_name) < 0)
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
            goto cleanup;

        if ((*tapfd = open(dev_path, O_RDWR)) < 0) {
            virReportSystemError(errno,
                                 _("Unable to open %s"),
                                 dev_path);
            VIR_FREE(dev_path);
            goto cleanup;
        }

        VIR_FREE(dev_path);
    }

    if (virNetDevSetName(ifr.ifr_name, *ifname) == -1) {
        goto cleanup;
    }


    ret = 0;
453
 cleanup:
454 455 456 457 458
    VIR_FORCE_CLOSE(s);

    return ret;
}

459 460
int virNetDevTapDelete(const char *ifname,
                       const char *tunpath ATTRIBUTE_UNUSED)
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
{
    int s;
    struct ifreq ifr;
    int ret = -1;

    if ((s = virNetDevSetupControl(ifname, &ifr)) < 0)
        return -1;

    if (ioctl(s, SIOCIFDESTROY, &ifr) < 0) {
        virReportSystemError(errno,
                             _("Unable to remove tap device %s"),
                             ifname);
        goto cleanup;
    }

    ret = 0;
477
 cleanup:
478 479 480 481 482
    VIR_FORCE_CLOSE(s);
    return ret;
}

#else
483
int virNetDevTapCreate(char **ifname ATTRIBUTE_UNUSED,
484
                       const char *tunpath ATTRIBUTE_UNUSED,
485
                       int *tapfd ATTRIBUTE_UNUSED,
486
                       int tapfdSize ATTRIBUTE_UNUSED,
487
                       unsigned int flags ATTRIBUTE_UNUSED)
488 489 490 491 492
{
    virReportSystemError(ENOSYS, "%s",
                         _("Unable to create TAP devices on this platform"));
    return -1;
}
493 494
int virNetDevTapDelete(const char *ifname ATTRIBUTE_UNUSED,
                       const char *tunpath ATTRIBUTE_UNUSED)
495 496 497 498 499
{
    virReportSystemError(ENOSYS, "%s",
                         _("Unable to delete TAP devices on this platform"));
    return -1;
}
500
#endif
501 502 503 504 505 506


/**
 * virNetDevTapCreateInBridgePort:
 * @brname: the bridge name
 * @ifname: the interface name (or name template)
507
 * @macaddr: desired MAC address
508
 * @tunpath: path to the tun device (if NULL, /dev/net/tun is used)
509 510
 * @tapfd: array of file descriptor return value for the new tap device
 * @tapfdSize: number of file descriptors in @tapfd
A
Ansis Atteka 已提交
511
 * @virtPortProfile: bridge/port specific configuration
512 513 514 515 516 517 518 519
 * @flags: OR of virNetDevTapCreateFlags:

 *   VIR_NETDEV_TAP_CREATE_IFUP
 *     - Bring the interface up
 *   VIR_NETDEV_TAP_CREATE_VNET_HDR
 *     - Enable IFF_VNET_HDR on the tap device
 *   VIR_NETDEV_TAP_CREATE_USE_MAC_FOR_BRIDGE
 *     - Set this interface's MAC as the bridge's MAC address
520 521
 *   VIR_NETDEV_TAP_CREATE_PERSIST
 *     - The device will persist after the file descriptor is closed
522 523 524 525
 *
 * This function creates a new tap device on a bridge. @ifname can be either
 * a fixed name or a name template with '%d' for dynamic name allocation.
 * in either case the final name for the bridge will be stored in @ifname.
526 527 528 529
 * If the @tapfd parameter is supplied, the open tap device file descriptor
 * will be returned, otherwise the TAP device will be closed. The caller must
 * use virNetDevTapDelete to remove a persistent TAP device when it is no
 * longer needed.
530 531 532 533 534
 *
 * Returns 0 in case of success or -1 on failure
 */
int virNetDevTapCreateInBridgePort(const char *brname,
                                   char **ifname,
535
                                   const virMacAddr *macaddr,
536
                                   const unsigned char *vmuuid,
537
                                   const char *tunpath,
A
Ansis Atteka 已提交
538
                                   int *tapfd,
539
                                   int tapfdSize,
540
                                   virNetDevVPortProfilePtr virtPortProfile,
541
                                   virNetDevVlanPtr virtVlan,
542
                                   unsigned int flags)
543
{
544
    virMacAddr tapmac;
545
    char macaddrstr[VIR_MAC_STRING_BUFLEN];
546
    size_t i;
547

548
    if (virNetDevTapCreate(ifname, tunpath, tapfd, tapfdSize, flags) < 0)
549 550 551 552 553 554 555 556
        return -1;

    /* We need to set the interface MAC before adding it
     * to the bridge, because the bridge assumes the lowest
     * MAC of all enslaved interfaces & we don't want it
     * seeing the kernel allocate random MAC for the TAP
     * device before we set our static MAC.
     */
557
    virMacAddrSet(&tapmac, macaddr);
558
    if (!(flags & VIR_NETDEV_TAP_CREATE_USE_MAC_FOR_BRIDGE)) {
559
        if (macaddr->addr[0] == 0xFE) {
560 561 562 563 564
            /* For normal use, the tap device's MAC address cannot
             * match the MAC address used by the guest. This results
             * in "received packet on vnetX with own address as source
             * address" error logs from the kernel.
             */
565 566
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("Unable to use MAC address starting with "
567 568
                             "reserved value 0xFE - '%s' - "),
                           virMacAddrFormat(macaddr, macaddrstr));
569 570
            goto error;
        }
571
        tapmac.addr[0] = 0xFE; /* Discourage bridge from using TAP dev MAC */
572
    }
573

574
    if (virNetDevSetMAC(*ifname, &tapmac) < 0)
575 576 577 578 579 580 581 582 583
        goto error;

    /* We need to set the interface MTU before adding it
     * to the bridge, because the bridge will have its
     * MTU adjusted automatically when we add the new interface.
     */
    if (virNetDevSetMTUFromDevice(*ifname, brname) < 0)
        goto error;

A
Ansis Atteka 已提交
584
    if (virtPortProfile) {
585
        if (virNetDevOpenvswitchAddPort(brname, *ifname, macaddr, vmuuid,
586
                                        virtPortProfile, virtVlan) < 0) {
A
Ansis Atteka 已提交
587 588 589 590 591 592
            goto error;
        }
    } else {
        if (virNetDevBridgeAddPort(brname, *ifname) < 0)
            goto error;
    }
593

594
    if (virNetDevSetOnline(*ifname, !!(flags & VIR_NETDEV_TAP_CREATE_IFUP)) < 0)
595 596 597 598
        goto error;

    return 0;

599
 error:
600 601
    for (i = 0; i < tapfdSize && tapfd[i] >= 0; i++)
        VIR_FORCE_CLOSE(tapfd[i]);
602

603
    return -1;
604
}