usr.sbin/bhyve/pci_virtio_net.c

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