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