usr.sbin/bhyve/pci_virtio_net.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2011 NetApp, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #ifndef WITHOUT_CAPSICUM
  36 #include <sys/capsicum.h>
  37 #endif
  38 #include <sys/linker_set.h>
  39 #include <sys/select.h>
  40 #include <sys/uio.h>
  41 #include <sys/ioctl.h>
  42 #include <machine/atomic.h>
  43 #include <net/ethernet.h>
  44 #ifndef NETMAP_WITH_LIBS
  45 #define NETMAP_WITH_LIBS
  46 #endif
  47 #include <net/netmap_user.h>
  48
  49 #ifndef WITHOUT_CAPSICUM
  50 #include <capsicum_helpers.h>
  51 #endif
  52 #include <err.h>
  53 #include <errno.h>
  54 #include <fcntl.h>
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <stdint.h>
  58 #include <string.h>
  59 #include <strings.h>
  60 #include <unistd.h>
  61 #include <assert.h>
  62 #include <md5.h>
  63 #include <pthread.h>
  64 #include <pthread_np.h>
  65 #include <sysexits.h>
  66
  67 #include "bhyverun.h"
  68 #include "pci_emul.h"
  69 #include "mevent.h"
  70 #include "virtio.h"
  71
  72 #define VTNET_RINGSZ    1024
  73
  74 #define VTNET_MAXSEGS   256
  75
  76 /*
  77  * Host capabilities.  Note that we only offer a few of these.
  78  */
  79 #define VIRTIO_NET_F_CSUM       (1 <<  0) /* host handles partial cksum */
  80 #define VIRTIO_NET_F_GUEST_CSUM (1 <<  1) /* guest handles partial cksum */
  81 #define VIRTIO_NET_F_MAC        (1 <<  5) /* host supplies MAC */
  82 #define VIRTIO_NET_F_GSO_DEPREC (1 <<  6) /* deprecated: host handles GSO */
  83 #define VIRTIO_NET_F_GUEST_TSO4 (1 <<  7) /* guest can rcv TSOv4 */
  84 #define VIRTIO_NET_F_GUEST_TSO6 (1 <<  8) /* guest can rcv TSOv6 */
  85 #define VIRTIO_NET_F_GUEST_ECN  (1 <<  9) /* guest can rcv TSO with ECN */
  86 #define VIRTIO_NET_F_GUEST_UFO  (1 << 10) /* guest can rcv UFO */
  87 #define VIRTIO_NET_F_HOST_TSO4  (1 << 11) /* host can rcv TSOv4 */
  88 #define VIRTIO_NET_F_HOST_TSO6  (1 << 12) /* host can rcv TSOv6 */
  89 #define VIRTIO_NET_F_HOST_ECN   (1 << 13) /* host can rcv TSO with ECN */
  90 #define VIRTIO_NET_F_HOST_UFO   (1 << 14) /* host can rcv UFO */
  91 #define VIRTIO_NET_F_MRG_RXBUF  (1 << 15) /* host can merge RX buffers */
  92 #define VIRTIO_NET_F_STATUS     (1 << 16) /* config status field available */
  93 #define VIRTIO_NET_F_CTRL_VQ    (1 << 17) /* control channel available */
  94 #define VIRTIO_NET_F_CTRL_RX    (1 << 18) /* control channel RX mode support */
  95 #define VIRTIO_NET_F_CTRL_VLAN  (1 << 19) /* control channel VLAN filtering */
  96 #define VIRTIO_NET_F_GUEST_ANNOUNCE \
  97                                 (1 << 21) /* guest can send gratuitous pkts */
  98
  99 #define VTNET_S_HOSTCAPS      \
 100   ( VIRTIO_NET_F_MAC | VIRTIO_NET_F_MRG_RXBUF | VIRTIO_NET_F_STATUS | \
 101     VIRTIO_F_NOTIFY_ON_EMPTY | VIRTIO_RING_F_INDIRECT_DESC)
 102
 103 /*
 104  * PCI config-space "registers"
 105  */
 106 struct virtio_net_config {
 107         uint8_t  mac[6];
 108         uint16_t status;
 109 } __packed;
 110
 111 /*
 112  * Queue definitions.
 113  */
 114 #define VTNET_RXQ       0
 115 #define VTNET_TXQ       1
 116 #define VTNET_CTLQ      2       /* NB: not yet supported */
 117
 118 #define VTNET_MAXQ      3
 119
 120 /*
 121  * Fixed network header size
 122  */
 123 struct virtio_net_rxhdr {
 124         uint8_t         vrh_flags;
 125         uint8_t         vrh_gso_type;
 126         uint16_t        vrh_hdr_len;
 127         uint16_t        vrh_gso_size;
 128         uint16_t        vrh_csum_start;
 129         uint16_t        vrh_csum_offset;
 130         uint16_t        vrh_bufs;
 131 } __packed;
 132
 133 /*
 134  * Debug printf
 135  */
 136 static int pci_vtnet_debug;
 137 #define DPRINTF(params) if (pci_vtnet_debug) printf params
 138 #define WPRINTF(params) printf params
 139
 140 /*
 141  * Per-device softc
 142  */
 143 struct pci_vtnet_softc {
 144         struct virtio_softc vsc_vs;
 145         struct vqueue_info vsc_queues[VTNET_MAXQ - 1];
 146         pthread_mutex_t vsc_mtx;
 147         struct mevent   *vsc_mevp;
 148
 149         int             vsc_tapfd;
 150         struct nm_desc  *vsc_nmd;
 151
 152         int             vsc_rx_ready;
 153         volatile int    resetting;      /* set and checked outside lock */
 154
 155         uint64_t        vsc_features;   /* negotiated features */
 156
 157         struct virtio_net_config vsc_config;
 158
 159         pthread_mutex_t rx_mtx;
 160         int             rx_in_progress;
 161         int             rx_vhdrlen;
 162         int             rx_merge;       /* merged rx bufs in use */
 163
 164         pthread_t       tx_tid;
 165         pthread_mutex_t tx_mtx;
 166         pthread_cond_t  tx_cond;
 167         int             tx_in_progress;
 168
 169         void (*pci_vtnet_rx)(struct pci_vtnet_softc *sc);
 170         void (*pci_vtnet_tx)(struct pci_vtnet_softc *sc, struct iovec *iov,
 171                              int iovcnt, int len);
 172 };
 173
 174 static void pci_vtnet_reset(void *);
 175 /* static void pci_vtnet_notify(void *, struct vqueue_info *); */
 176 static int pci_vtnet_cfgread(void *, int, int, uint32_t *);
 177 static int pci_vtnet_cfgwrite(void *, int, int, uint32_t);
 178 static void pci_vtnet_neg_features(void *, uint64_t);
 179
 180 static struct virtio_consts vtnet_vi_consts = {
 181         "vtnet",                /* our name */
 182         VTNET_MAXQ - 1,         /* we currently support 2 virtqueues */
 183         sizeof(struct virtio_net_config), /* config reg size */
 184         pci_vtnet_reset,        /* reset */
 185         NULL,                   /* device-wide qnotify -- not used */
 186         pci_vtnet_cfgread,      /* read PCI config */
 187         pci_vtnet_cfgwrite,     /* write PCI config */
 188         pci_vtnet_neg_features, /* apply negotiated features */
 189         VTNET_S_HOSTCAPS,       /* our capabilities */
 190 };
 191
 192 /*
 193  * If the transmit thread is active then stall until it is done.
 194  */
 195 static void
 196 pci_vtnet_txwait(struct pci_vtnet_softc *sc)
 197 {
 198
 199         pthread_mutex_lock(&sc->tx_mtx);
 200         while (sc->tx_in_progress) {
 201                 pthread_mutex_unlock(&sc->tx_mtx);
 202                 usleep(10000);
 203                 pthread_mutex_lock(&sc->tx_mtx);
 204         }
 205         pthread_mutex_unlock(&sc->tx_mtx);
 206 }
 207
 208 /*
 209  * If the receive thread is active then stall until it is done.
 210  */
 211 static void
 212 pci_vtnet_rxwait(struct pci_vtnet_softc *sc)
 213 {
 214
 215         pthread_mutex_lock(&sc->rx_mtx);
 216         while (sc->rx_in_progress) {
 217                 pthread_mutex_unlock(&sc->rx_mtx);
 218                 usleep(10000);
 219                 pthread_mutex_lock(&sc->rx_mtx);
 220         }
 221         pthread_mutex_unlock(&sc->rx_mtx);
 222 }
 223
 224 static void
 225 pci_vtnet_reset(void *vsc)
 226 {
 227         struct pci_vtnet_softc *sc = vsc;
 228
 229         DPRINTF(("vtnet: device reset requested !\n"));
 230
 231         sc->resetting = 1;
 232
 233         /*
 234          * Wait for the transmit and receive threads to finish their
 235          * processing.
 236          */
 237         pci_vtnet_txwait(sc);
 238         pci_vtnet_rxwait(sc);
 239
 240         sc->vsc_rx_ready = 0;
 241         sc->rx_merge = 1;
 242         sc->rx_vhdrlen = sizeof(struct virtio_net_rxhdr);
 243
 244         /* now reset rings, MSI-X vectors, and negotiated capabilities */
 245         vi_reset_dev(&sc->vsc_vs);
 246
 247         sc->resetting = 0;
 248 }
 249
 250 /*
 251  * Called to send a buffer chain out to the tap device
 252  */
 253 static void
 254 pci_vtnet_tap_tx(struct pci_vtnet_softc *sc, struct iovec *iov, int iovcnt,
 255                  int len)
 256 {
 257         static char pad[60]; /* all zero bytes */
 258
 259         if (sc->vsc_tapfd == -1)
 260                 return;
 261
 262         /*
 263          * If the length is < 60, pad out to that and add the
 264          * extra zero'd segment to the iov. It is guaranteed that
 265          * there is always an extra iov available by the caller.
 266          */
 267         if (len < 60) {
 268                 iov[iovcnt].iov_base = pad;
 269                 iov[iovcnt].iov_len = 60 - len;
 270                 iovcnt++;
 271         }
 272         (void) writev(sc->vsc_tapfd, iov, iovcnt);
 273 }
 274
 275 /*
 276  *  Called when there is read activity on the tap file descriptor.
 277  * Each buffer posted by the guest is assumed to be able to contain
 278  * an entire ethernet frame + rx header.
 279  *  MP note: the dummybuf is only used for discarding frames, so there
 280  * is no need for it to be per-vtnet or locked.
 281  */
 282 static uint8_t dummybuf[2048];
 283
 284 static __inline struct iovec *
 285 rx_iov_trim(struct iovec *iov, int *niov, int tlen)
 286 {
 287         struct iovec *riov;
 288
 289         /* XXX short-cut: assume first segment is >= tlen */
 290         assert(iov[0].iov_len >= tlen);
 291
 292         iov[0].iov_len -= tlen;
 293         if (iov[0].iov_len == 0) {
 294                 assert(*niov > 1);
 295                 *niov -= 1;
 296                 riov = &iov[1];
 297         } else {
 298                 iov[0].iov_base = (void *)((uintptr_t)iov[0].iov_base + tlen);
 299                 riov = &iov[0];
 300         }
 301
 302         return (riov);
 303 }
 304
 305 static void
 306 pci_vtnet_tap_rx(struct pci_vtnet_softc *sc)
 307 {
 308         struct iovec iov[VTNET_MAXSEGS], *riov;
 309         struct vqueue_info *vq;
 310         void *vrx;
 311         int len, n;
 312         uint16_t idx;
 313
 314         /*
 315          * Should never be called without a valid tap fd
 316          */
 317         assert(sc->vsc_tapfd != -1);
 318
 319         /*
 320          * But, will be called when the rx ring hasn't yet
 321          * been set up or the guest is resetting the device.
 322          */
 323         if (!sc->vsc_rx_ready || sc->resetting) {
 324                 /*
 325                  * Drop the packet and try later.
 326                  */
 327                 (void) read(sc->vsc_tapfd, dummybuf, sizeof(dummybuf));
 328                 return;
 329         }
 330
 331         /*
 332          * Check for available rx buffers
 333          */
 334         vq = &sc->vsc_queues[VTNET_RXQ];
 335         if (!vq_has_descs(vq)) {
 336                 /*
 337                  * Drop the packet and try later.  Interrupt on
 338                  * empty, if that's negotiated.
 339                  */
 340                 (void) read(sc->vsc_tapfd, dummybuf, sizeof(dummybuf));
 341                 vq_endchains(vq, 1);
 342                 return;
 343         }
 344
 345         do {
 346                 /*
 347                  * Get descriptor chain.
 348                  */
 349                 n = vq_getchain(vq, &idx, iov, VTNET_MAXSEGS, NULL);
 350                 assert(n >= 1 && n <= VTNET_MAXSEGS);
 351
 352                 /*
 353                  * Get a pointer to the rx header, and use the
 354                  * data immediately following it for the packet buffer.
 355                  */
 356                 vrx = iov[0].iov_base;
 357                 riov = rx_iov_trim(iov, &n, sc->rx_vhdrlen);
 358
 359                 len = readv(sc->vsc_tapfd, riov, n);
 360
 361                 if (len < 0 && errno == EWOULDBLOCK) {
 362                         /*
 363                          * No more packets, but still some avail ring
 364                          * entries.  Interrupt if needed/appropriate.
 365                          */
 366                         vq_retchain(vq);
 367                         vq_endchains(vq, 0);
 368                         return;
 369                 }
 370
 371                 /*
 372                  * The only valid field in the rx packet header is the
 373                  * number of buffers if merged rx bufs were negotiated.
 374                  */
 375                 memset(vrx, 0, sc->rx_vhdrlen);
 376
 377                 if (sc->rx_merge) {
 378                         struct virtio_net_rxhdr *vrxh;
 379
 380                         vrxh = vrx;
 381                         vrxh->vrh_bufs = 1;
 382                 }
 383
 384                 /*
 385                  * Release this chain and handle more chains.
 386                  */
 387                 vq_relchain(vq, idx, len + sc->rx_vhdrlen);
 388         } while (vq_has_descs(vq));
 389
 390         /* Interrupt if needed, including for NOTIFY_ON_EMPTY. */
 391         vq_endchains(vq, 1);
 392 }
 393
 394 static __inline int
 395 pci_vtnet_netmap_writev(struct nm_desc *nmd, struct iovec *iov, int iovcnt)
 396 {
 397         int r, i;
 398         int len = 0;
 399
 400         for (r = nmd->cur_tx_ring; ; ) {
 401                 struct netmap_ring *ring = NETMAP_TXRING(nmd->nifp, r);
 402                 uint32_t cur, idx;
 403                 char *buf;
 404
 405                 if (nm_ring_empty(ring)) {
 406                         r++;
 407                         if (r > nmd->last_tx_ring)
 408                                 r = nmd->first_tx_ring;
 409                         if (r == nmd->cur_tx_ring)
 410                                 break;
 411                         continue;
 412                 }
 413                 cur = ring->cur;
 414                 idx = ring->slot[cur].buf_idx;
 415                 buf = NETMAP_BUF(ring, idx);
 416
 417                 for (i = 0; i < iovcnt; i++) {
 418                         if (len + iov[i].iov_len > 2048)
 419                                 break;
 420                         memcpy(&buf[len], iov[i].iov_base, iov[i].iov_len);
 421                         len += iov[i].iov_len;
 422                 }
 423                 ring->slot[cur].len = len;
 424                 ring->head = ring->cur = nm_ring_next(ring, cur);
 425                 nmd->cur_tx_ring = r;
 426                 ioctl(nmd->fd, NIOCTXSYNC, NULL);
 427                 break;
 428         }
 429
 430         return (len);
 431 }
 432
 433 static __inline int
 434 pci_vtnet_netmap_readv(struct nm_desc *nmd, struct iovec *iov, int iovcnt)
 435 {
 436         int len = 0;
 437         int i = 0;
 438         int r;
 439
 440         for (r = nmd->cur_rx_ring; ; ) {
 441                 struct netmap_ring *ring = NETMAP_RXRING(nmd->nifp, r);
 442                 uint32_t cur, idx;
 443                 char *buf;
 444                 size_t left;
 445
 446                 if (nm_ring_empty(ring)) {
 447                         r++;
 448                         if (r > nmd->last_rx_ring)
 449                                 r = nmd->first_rx_ring;
 450                         if (r == nmd->cur_rx_ring)
 451                                 break;
 452                         continue;
 453                 }
 454                 cur = ring->cur;
 455                 idx = ring->slot[cur].buf_idx;
 456                 buf = NETMAP_BUF(ring, idx);
 457                 left = ring->slot[cur].len;
 458
 459                 for (i = 0; i < iovcnt && left > 0; i++) {
 460                         if (iov[i].iov_len > left)
 461                                 iov[i].iov_len = left;
 462                         memcpy(iov[i].iov_base, &buf[len], iov[i].iov_len);
 463                         len += iov[i].iov_len;
 464                         left -= iov[i].iov_len;
 465                 }
 466                 ring->head = ring->cur = nm_ring_next(ring, cur);
 467                 nmd->cur_rx_ring = r;
 468                 ioctl(nmd->fd, NIOCRXSYNC, NULL);
 469                 break;
 470         }
 471         for (; i < iovcnt; i++)
 472                 iov[i].iov_len = 0;
 473
 474         return (len);
 475 }
 476
 477 /*
 478  * Called to send a buffer chain out to the vale port
 479  */
 480 static void
 481 pci_vtnet_netmap_tx(struct pci_vtnet_softc *sc, struct iovec *iov, int iovcnt,
 482                     int len)
 483 {
 484         static char pad[60]; /* all zero bytes */
 485
 486         if (sc->vsc_nmd == NULL)
 487                 return;
 488
 489         /*
 490          * If the length is < 60, pad out to that and add the
 491          * extra zero'd segment to the iov. It is guaranteed that
 492          * there is always an extra iov available by the caller.
 493          */
 494         if (len < 60) {
 495                 iov[iovcnt].iov_base = pad;
 496                 iov[iovcnt].iov_len = 60 - len;
 497                 iovcnt++;
 498         }
 499         (void) pci_vtnet_netmap_writev(sc->vsc_nmd, iov, iovcnt);
 500 }
 501
 502 static void
 503 pci_vtnet_netmap_rx(struct pci_vtnet_softc *sc)
 504 {
 505         struct iovec iov[VTNET_MAXSEGS], *riov;
 506         struct vqueue_info *vq;
 507         void *vrx;
 508         int len, n;
 509         uint16_t idx;
 510
 511         /*
 512          * Should never be called without a valid netmap descriptor
 513          */
 514         assert(sc->vsc_nmd != NULL);
 515
 516         /*
 517          * But, will be called when the rx ring hasn't yet
 518          * been set up or the guest is resetting the device.
 519          */
 520         if (!sc->vsc_rx_ready || sc->resetting) {
 521                 /*
 522                  * Drop the packet and try later.
 523                  */
 524                 (void) nm_nextpkt(sc->vsc_nmd, (void *)dummybuf);
 525                 return;
 526         }
 527
 528         /*
 529          * Check for available rx buffers
 530          */
 531         vq = &sc->vsc_queues[VTNET_RXQ];
 532         if (!vq_has_descs(vq)) {
 533                 /*
 534                  * Drop the packet and try later.  Interrupt on
 535                  * empty, if that's negotiated.
 536                  */
 537                 (void) nm_nextpkt(sc->vsc_nmd, (void *)dummybuf);
 538                 vq_endchains(vq, 1);
 539                 return;
 540         }
 541
 542         do {
 543                 /*
 544                  * Get descriptor chain.
 545                  */
 546                 n = vq_getchain(vq, &idx, iov, VTNET_MAXSEGS, NULL);
 547                 assert(n >= 1 && n <= VTNET_MAXSEGS);
 548
 549                 /*
 550                  * Get a pointer to the rx header, and use the
 551                  * data immediately following it for the packet buffer.
 552                  */
 553                 vrx = iov[0].iov_base;
 554                 riov = rx_iov_trim(iov, &n, sc->rx_vhdrlen);
 555
 556                 len = pci_vtnet_netmap_readv(sc->vsc_nmd, riov, n);
 557
 558                 if (len == 0) {
 559                         /*
 560                          * No more packets, but still some avail ring
 561                          * entries.  Interrupt if needed/appropriate.
 562                          */
 563                         vq_retchain(vq);
 564                         vq_endchains(vq, 0);
 565                         return;
 566                 }
 567
 568                 /*
 569                  * The only valid field in the rx packet header is the
 570                  * number of buffers if merged rx bufs were negotiated.
 571                  */
 572                 memset(vrx, 0, sc->rx_vhdrlen);
 573
 574                 if (sc->rx_merge) {
 575                         struct virtio_net_rxhdr *vrxh;
 576
 577                         vrxh = vrx;
 578                         vrxh->vrh_bufs = 1;
 579                 }
 580
 581                 /*
 582                  * Release this chain and handle more chains.
 583                  */
 584                 vq_relchain(vq, idx, len + sc->rx_vhdrlen);
 585         } while (vq_has_descs(vq));
 586
 587         /* Interrupt if needed, including for NOTIFY_ON_EMPTY. */
 588         vq_endchains(vq, 1);
 589 }
 590
 591 static void
 592 pci_vtnet_rx_callback(int fd, enum ev_type type, void *param)
 593 {
 594         struct pci_vtnet_softc *sc = param;
 595
 596         pthread_mutex_lock(&sc->rx_mtx);
 597         sc->rx_in_progress = 1;
 598         sc->pci_vtnet_rx(sc);
 599         sc->rx_in_progress = 0;
 600         pthread_mutex_unlock(&sc->rx_mtx);
 601
 602 }
 603
 604 static void
 605 pci_vtnet_ping_rxq(void *vsc, struct vqueue_info *vq)
 606 {
 607         struct pci_vtnet_softc *sc = vsc;
 608
 609         /*
 610          * A qnotify means that the rx process can now begin
 611          */
 612         if (sc->vsc_rx_ready == 0) {
 613                 sc->vsc_rx_ready = 1;
 614                 vq->vq_used->vu_flags |= VRING_USED_F_NO_NOTIFY;
 615         }
 616 }
 617
 618 static void
 619 pci_vtnet_proctx(struct pci_vtnet_softc *sc, struct vqueue_info *vq)
 620 {
 621         struct iovec iov[VTNET_MAXSEGS + 1];
 622         int i, n;
 623         int plen, tlen;
 624         uint16_t idx;
 625
 626         /*
 627          * Obtain chain of descriptors.  The first one is
 628          * really the header descriptor, so we need to sum
 629          * up two lengths: packet length and transfer length.
 630          */
 631         n = vq_getchain(vq, &idx, iov, VTNET_MAXSEGS, NULL);
 632         assert(n >= 1 && n <= VTNET_MAXSEGS);
 633         plen = 0;
 634         tlen = iov[0].iov_len;
 635         for (i = 1; i < n; i++) {
 636                 plen += iov[i].iov_len;
 637                 tlen += iov[i].iov_len;
 638         }
 639
 640         DPRINTF(("virtio: packet send, %d bytes, %d segs\n\r", plen, n));
 641         sc->pci_vtnet_tx(sc, &iov[1], n - 1, plen);
 642
 643         /* chain is processed, release it and set tlen */
 644         vq_relchain(vq, idx, tlen);
 645 }
 646
 647 static void
 648 pci_vtnet_ping_txq(void *vsc, struct vqueue_info *vq)
 649 {
 650         struct pci_vtnet_softc *sc = vsc;
 651
 652         /*
 653          * Any ring entries to process?
 654          */
 655         if (!vq_has_descs(vq))
 656                 return;
 657
 658         /* Signal the tx thread for processing */
 659         pthread_mutex_lock(&sc->tx_mtx);
 660         vq->vq_used->vu_flags |= VRING_USED_F_NO_NOTIFY;
 661         if (sc->tx_in_progress == 0)
 662                 pthread_cond_signal(&sc->tx_cond);
 663         pthread_mutex_unlock(&sc->tx_mtx);
 664 }
 665
 666 /*
 667  * Thread which will handle processing of TX desc
 668  */
 669 static void *
 670 pci_vtnet_tx_thread(void *param)
 671 {
 672         struct pci_vtnet_softc *sc = param;
 673         struct vqueue_info *vq;
 674         int error;
 675
 676         vq = &sc->vsc_queues[VTNET_TXQ];
 677
 678         /*
 679          * Let us wait till the tx queue pointers get initialised &
 680          * first tx signaled
 681          */
 682         pthread_mutex_lock(&sc->tx_mtx);
 683         error = pthread_cond_wait(&sc->tx_cond, &sc->tx_mtx);
 684         assert(error == 0);
 685
 686         for (;;) {
 687                 /* note - tx mutex is locked here */
 688                 while (sc->resetting || !vq_has_descs(vq)) {
 689                         vq->vq_used->vu_flags &= ~VRING_USED_F_NO_NOTIFY;
 690                         mb();
 691                         if (!sc->resetting && vq_has_descs(vq))
 692                                 break;
 693
 694                         sc->tx_in_progress = 0;
 695                         error = pthread_cond_wait(&sc->tx_cond, &sc->tx_mtx);
 696                         assert(error == 0);
 697                 }
 698                 vq->vq_used->vu_flags |= VRING_USED_F_NO_NOTIFY;
 699                 sc->tx_in_progress = 1;
 700                 pthread_mutex_unlock(&sc->tx_mtx);
 701
 702                 do {
 703                         /*
 704                          * Run through entries, placing them into
 705                          * iovecs and sending when an end-of-packet
 706                          * is found
 707                          */
 708                         pci_vtnet_proctx(sc, vq);
 709                 } while (vq_has_descs(vq));
 710
 711                 /*
 712                  * Generate an interrupt if needed.
 713                  */
 714                 vq_endchains(vq, 1);
 715
 716                 pthread_mutex_lock(&sc->tx_mtx);
 717         }
 718 }
 719
 720 #ifdef notyet
 721 static void
 722 pci_vtnet_ping_ctlq(void *vsc, struct vqueue_info *vq)
 723 {
 724
 725         DPRINTF(("vtnet: control qnotify!\n\r"));
 726 }
 727 #endif
 728
 729 static int
 730 pci_vtnet_parsemac(char *mac_str, uint8_t *mac_addr)
 731 {
 732         struct ether_addr *ea;
 733         char *tmpstr;
 734         char zero_addr[ETHER_ADDR_LEN] = { 0, 0, 0, 0, 0, 0 };
 735
 736         tmpstr = strsep(&mac_str,"=");
 737
 738         if ((mac_str != NULL) && (!strcmp(tmpstr,"mac"))) {
 739                 ea = ether_aton(mac_str);
 740
 741                 if (ea == NULL || ETHER_IS_MULTICAST(ea->octet) ||
 742                     memcmp(ea->octet, zero_addr, ETHER_ADDR_LEN) == 0) {
 743                         fprintf(stderr, "Invalid MAC %s\n", mac_str);
 744                         return (EINVAL);
 745                 } else
 746                         memcpy(mac_addr, ea->octet, ETHER_ADDR_LEN);
 747         }
 748
 749         return (0);
 750 }
 751
 752 static void
 753 pci_vtnet_tap_setup(struct pci_vtnet_softc *sc, char *devname)
 754 {
 755         char tbuf[80];
 756 #ifndef WITHOUT_CAPSICUM
 757         cap_rights_t rights;
 758 #endif
 759
 760         strcpy(tbuf, "/dev/");
 761         strlcat(tbuf, devname, sizeof(tbuf));
 762
 763         sc->pci_vtnet_rx = pci_vtnet_tap_rx;
 764         sc->pci_vtnet_tx = pci_vtnet_tap_tx;
 765
 766         sc->vsc_tapfd = open(tbuf, O_RDWR);
 767         if (sc->vsc_tapfd == -1) {
 768                 WPRINTF(("open of tap device %s failed\n", tbuf));
 769                 return;
 770         }
 771
 772         /*
 773          * Set non-blocking and register for read
 774          * notifications with the event loop
 775          */
 776         int opt = 1;
 777         if (ioctl(sc->vsc_tapfd, FIONBIO, &opt) < 0) {
 778                 WPRINTF(("tap device O_NONBLOCK failed\n"));
 779                 close(sc->vsc_tapfd);
 780                 sc->vsc_tapfd = -1;
 781         }
 782
 783 #ifndef WITHOUT_CAPSICUM
 784         cap_rights_init(&rights, CAP_EVENT, CAP_READ, CAP_WRITE);
 785         if (caph_rights_limit(sc->vsc_tapfd, &rights) == -1)
 786                 errx(EX_OSERR, "Unable to apply rights for sandbox");
 787 #endif
 788
 789         sc->vsc_mevp = mevent_add(sc->vsc_tapfd,
 790                                   EVF_READ,
 791                                   pci_vtnet_rx_callback,
 792                                   sc);
 793         if (sc->vsc_mevp == NULL) {
 794                 WPRINTF(("Could not register event\n"));
 795                 close(sc->vsc_tapfd);
 796                 sc->vsc_tapfd = -1;
 797         }
 798 }
 799
 800 static void
 801 pci_vtnet_netmap_setup(struct pci_vtnet_softc *sc, char *ifname)
 802 {
 803         sc->pci_vtnet_rx = pci_vtnet_netmap_rx;
 804         sc->pci_vtnet_tx = pci_vtnet_netmap_tx;
 805
 806         sc->vsc_nmd = nm_open(ifname, NULL, 0, 0);
 807         if (sc->vsc_nmd == NULL) {
 808                 WPRINTF(("open of netmap device %s failed\n", ifname));
 809                 return;
 810         }
 811
 812         sc->vsc_mevp = mevent_add(sc->vsc_nmd->fd,
 813                                   EVF_READ,
 814                                   pci_vtnet_rx_callback,
 815                                   sc);
 816         if (sc->vsc_mevp == NULL) {
 817                 WPRINTF(("Could not register event\n"));
 818                 nm_close(sc->vsc_nmd);
 819                 sc->vsc_nmd = NULL;
 820         }
 821 }
 822
 823 static int
 824 pci_vtnet_init(struct vmctx *ctx, struct pci_devinst *pi, char *opts)
 825 {
 826         MD5_CTX mdctx;
 827         unsigned char digest[16];
 828         char nstr[80];
 829         char tname[MAXCOMLEN + 1];
 830         struct pci_vtnet_softc *sc;
 831         char *devname;
 832         char *vtopts;
 833         int mac_provided;
 834
 835         sc = calloc(1, sizeof(struct pci_vtnet_softc));
 836
 837         pthread_mutex_init(&sc->vsc_mtx, NULL);
 838
 839         vi_softc_linkup(&sc->vsc_vs, &vtnet_vi_consts, sc, pi, sc->vsc_queues);
 840         sc->vsc_vs.vs_mtx = &sc->vsc_mtx;
 841
 842         sc->vsc_queues[VTNET_RXQ].vq_qsize = VTNET_RINGSZ;
 843         sc->vsc_queues[VTNET_RXQ].vq_notify = pci_vtnet_ping_rxq;
 844         sc->vsc_queues[VTNET_TXQ].vq_qsize = VTNET_RINGSZ;
 845         sc->vsc_queues[VTNET_TXQ].vq_notify = pci_vtnet_ping_txq;
 846 #ifdef notyet
 847         sc->vsc_queues[VTNET_CTLQ].vq_qsize = VTNET_RINGSZ;
 848         sc->vsc_queues[VTNET_CTLQ].vq_notify = pci_vtnet_ping_ctlq;
 849 #endif
 850
 851         /*
 852          * Attempt to open the tap device and read the MAC address
 853          * if specified
 854          */
 855         mac_provided = 0;
 856         sc->vsc_tapfd = -1;
 857         sc->vsc_nmd = NULL;
 858         if (opts != NULL) {
 859                 int err;
 860
 861                 devname = vtopts = strdup(opts);
 862                 (void) strsep(&vtopts, ",");
 863
 864                 if (vtopts != NULL) {
 865                         err = pci_vtnet_parsemac(vtopts, sc->vsc_config.mac);
 866                         if (err != 0) {
 867                                 free(devname);
 868                                 return (err);
 869                         }
 870                         mac_provided = 1;
 871                 }
 872
 873                 if (strncmp(devname, "vale", 4) == 0)
 874                         pci_vtnet_netmap_setup(sc, devname);
 875                 if (strncmp(devname, "tap", 3) == 0 ||
 876                     strncmp(devname, "vmnet", 5) == 0)
 877                         pci_vtnet_tap_setup(sc, devname);
 878
 879                 free(devname);
 880         }
 881
 882         /*
 883          * The default MAC address is the standard NetApp OUI of 00-a0-98,
 884          * followed by an MD5 of the PCI slot/func number and dev name
 885          */
 886         if (!mac_provided) {
 887                 snprintf(nstr, sizeof(nstr), "%d-%d-%s", pi->pi_slot,
 888                     pi->pi_func, vmname);
 889
 890                 MD5Init(&mdctx);
 891                 MD5Update(&mdctx, nstr, strlen(nstr));
 892                 MD5Final(digest, &mdctx);
 893
 894                 sc->vsc_config.mac[0] = 0x00;
 895                 sc->vsc_config.mac[1] = 0xa0;
 896                 sc->vsc_config.mac[2] = 0x98;
 897                 sc->vsc_config.mac[3] = digest[0];
 898                 sc->vsc_config.mac[4] = digest[1];
 899                 sc->vsc_config.mac[5] = digest[2];
 900         }
 901
 902         /* initialize config space */
 903         pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_NET);
 904         pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
 905         pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_NETWORK);
 906         pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_TYPE_NET);
 907         pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_VENDOR);
 908
 909         /* Link is up if we managed to open tap device or vale port. */
 910         sc->vsc_config.status = (opts == NULL || sc->vsc_tapfd >= 0 ||
 911             sc->vsc_nmd != NULL);
 912
 913         /* use BAR 1 to map MSI-X table and PBA, if we're using MSI-X */
 914         if (vi_intr_init(&sc->vsc_vs, 1, fbsdrun_virtio_msix()))
 915                 return (1);
 916
 917         /* use BAR 0 to map config regs in IO space */
 918         vi_set_io_bar(&sc->vsc_vs, 0);
 919
 920         sc->resetting = 0;
 921
 922         sc->rx_merge = 1;
 923         sc->rx_vhdrlen = sizeof(struct virtio_net_rxhdr);
 924         sc->rx_in_progress = 0;
 925         pthread_mutex_init(&sc->rx_mtx, NULL);
 926
 927         /*
 928          * Initialize tx semaphore & spawn TX processing thread.
 929          * As of now, only one thread for TX desc processing is
 930          * spawned.
 931          */
 932         sc->tx_in_progress = 0;
 933         pthread_mutex_init(&sc->tx_mtx, NULL);
 934         pthread_cond_init(&sc->tx_cond, NULL);
 935         pthread_create(&sc->tx_tid, NULL, pci_vtnet_tx_thread, (void *)sc);
 936         snprintf(tname, sizeof(tname), "vtnet-%d:%d tx", pi->pi_slot,
 937             pi->pi_func);
 938         pthread_set_name_np(sc->tx_tid, tname);
 939
 940         return (0);
 941 }
 942
 943 static int
 944 pci_vtnet_cfgwrite(void *vsc, int offset, int size, uint32_t value)
 945 {
 946         struct pci_vtnet_softc *sc = vsc;
 947         void *ptr;
 948
 949         if (offset < 6) {
 950                 assert(offset + size <= 6);
 951                 /*
 952                  * The driver is allowed to change the MAC address
 953                  */
 954                 ptr = &sc->vsc_config.mac[offset];
 955                 memcpy(ptr, &value, size);
 956         } else {
 957                 /* silently ignore other writes */
 958                 DPRINTF(("vtnet: write to readonly reg %d\n\r", offset));
 959         }
 960
 961         return (0);
 962 }
 963
 964 static int
 965 pci_vtnet_cfgread(void *vsc, int offset, int size, uint32_t *retval)
 966 {
 967         struct pci_vtnet_softc *sc = vsc;
 968         void *ptr;
 969
 970         ptr = (uint8_t *)&sc->vsc_config + offset;
 971         memcpy(retval, ptr, size);
 972         return (0);
 973 }
 974
 975 static void
 976 pci_vtnet_neg_features(void *vsc, uint64_t negotiated_features)
 977 {
 978         struct pci_vtnet_softc *sc = vsc;
 979
 980         sc->vsc_features = negotiated_features;
 981
 982         if (!(sc->vsc_features & VIRTIO_NET_F_MRG_RXBUF)) {
 983                 sc->rx_merge = 0;
 984                 /* non-merge rx header is 2 bytes shorter */
 985                 sc->rx_vhdrlen -= 2;
 986         }
 987 }
 988
 989 struct pci_devemu pci_de_vnet = {
 990         .pe_emu =       "virtio-net",
 991         .pe_init =      pci_vtnet_init,
 992         .pe_barwrite =  vi_pci_write,
 993         .pe_barread =   vi_pci_read
 994 };
 995 PCI_EMUL_SET(pci_de_vnet);