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