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         uint16_t idx;
 292
 293         /*
 294          * Should never be called without a valid tap fd
 295          */
 296         assert(sc->vsc_tapfd != -1);
 297
 298         /*
 299          * But, will be called when the rx ring hasn't yet
 300          * been set up or the guest is resetting the device.
 301          */
 302         if (!sc->vsc_rx_ready || sc->resetting) {
 303                 /*
 304                  * Drop the packet and try later.
 305                  */
 306                 (void) read(sc->vsc_tapfd, dummybuf, sizeof(dummybuf));
 307                 return;
 308         }
 309
 310         /*
 311          * Check for available rx buffers
 312          */
 313         vq = &sc->vsc_queues[VTNET_RXQ];
 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, &idx, 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_retchain(vq);
 346                         vq_endchains(vq, 0);
 347                         return;
 348                 }
 349
 350                 /*
 351                  * The only valid field in the rx packet header is the
 352                  * number of buffers if merged rx bufs were negotiated.
 353                  */
 354                 memset(vrx, 0, sc->rx_vhdrlen);
 355
 356                 if (sc->rx_merge) {
 357                         struct virtio_net_rxhdr *vrxh;
 358
 359                         vrxh = vrx;
 360                         vrxh->vrh_bufs = 1;
 361                 }
 362
 363                 /*
 364                  * Release this chain and handle more chains.
 365                  */
 366                 vq_relchain(vq, idx, len + sc->rx_vhdrlen);
 367         } while (vq_has_descs(vq));
 368
 369         /* Interrupt if needed, including for NOTIFY_ON_EMPTY. */
 370         vq_endchains(vq, 1);
 371 }
 372
 373 static void
 374 pci_vtnet_tap_callback(int fd, enum ev_type type, void *param)
 375 {
 376         struct pci_vtnet_softc *sc = param;
 377
 378         pthread_mutex_lock(&sc->rx_mtx);
 379         sc->rx_in_progress = 1;
 380         pci_vtnet_tap_rx(sc);
 381         sc->rx_in_progress = 0;
 382         pthread_mutex_unlock(&sc->rx_mtx);
 383
 384 }
 385
 386 static void
 387 pci_vtnet_ping_rxq(void *vsc, struct vqueue_info *vq)
 388 {
 389         struct pci_vtnet_softc *sc = vsc;
 390
 391         /*
 392          * A qnotify means that the rx process can now begin
 393          */
 394         if (sc->vsc_rx_ready == 0) {
 395                 sc->vsc_rx_ready = 1;
 396                 vq->vq_used->vu_flags |= VRING_USED_F_NO_NOTIFY;
 397         }
 398 }
 399
 400 static void
 401 pci_vtnet_proctx(struct pci_vtnet_softc *sc, struct vqueue_info *vq)
 402 {
 403         struct iovec iov[VTNET_MAXSEGS + 1];
 404         int i, n;
 405         int plen, tlen;
 406         uint16_t idx;
 407
 408         /*
 409          * Obtain chain of descriptors.  The first one is
 410          * really the header descriptor, so we need to sum
 411          * up two lengths: packet length and transfer length.
 412          */
 413         n = vq_getchain(vq, &idx, iov, VTNET_MAXSEGS, NULL);
 414         assert(n >= 1 && n <= VTNET_MAXSEGS);
 415         plen = 0;
 416         tlen = iov[0].iov_len;
 417         for (i = 1; i < n; i++) {
 418                 plen += iov[i].iov_len;
 419                 tlen += iov[i].iov_len;
 420         }
 421
 422         DPRINTF(("virtio: packet send, %d bytes, %d segs\n\r", plen, n));
 423         pci_vtnet_tap_tx(sc, &iov[1], n - 1, plen);
 424
 425         /* chain is processed, release it and set tlen */
 426         vq_relchain(vq, idx, tlen);
 427 }
 428
 429 static void
 430 pci_vtnet_ping_txq(void *vsc, struct vqueue_info *vq)
 431 {
 432         struct pci_vtnet_softc *sc = vsc;
 433
 434         /*
 435          * Any ring entries to process?
 436          */
 437         if (!vq_has_descs(vq))
 438                 return;
 439
 440         /* Signal the tx thread for processing */
 441         pthread_mutex_lock(&sc->tx_mtx);
 442         vq->vq_used->vu_flags |= VRING_USED_F_NO_NOTIFY;
 443         if (sc->tx_in_progress == 0)
 444                 pthread_cond_signal(&sc->tx_cond);
 445         pthread_mutex_unlock(&sc->tx_mtx);
 446 }
 447
 448 /*
 449  * Thread which will handle processing of TX desc
 450  */
 451 static void *
 452 pci_vtnet_tx_thread(void *param)
 453 {
 454         struct pci_vtnet_softc *sc = param;
 455         struct vqueue_info *vq;
 456         int have_work, error;
 457
 458         vq = &sc->vsc_queues[VTNET_TXQ];
 459
 460         /*
 461          * Let us wait till the tx queue pointers get initialised &
 462          * first tx signaled
 463          */
 464         pthread_mutex_lock(&sc->tx_mtx);
 465         error = pthread_cond_wait(&sc->tx_cond, &sc->tx_mtx);
 466         assert(error == 0);
 467
 468         for (;;) {
 469                 /* note - tx mutex is locked here */
 470                 do {
 471                         vq->vq_used->vu_flags &= ~VRING_USED_F_NO_NOTIFY;
 472                         if (sc->resetting)
 473                                 have_work = 0;
 474                         else
 475                                 have_work = vq_has_descs(vq);
 476
 477                         if (!have_work) {
 478                                 sc->tx_in_progress = 0;
 479                                 error = pthread_cond_wait(&sc->tx_cond,
 480                                                           &sc->tx_mtx);
 481                                 assert(error == 0);
 482                         }
 483                 } while (!have_work);
 484                 vq->vq_used->vu_flags |= VRING_USED_F_NO_NOTIFY;
 485                 sc->tx_in_progress = 1;
 486                 pthread_mutex_unlock(&sc->tx_mtx);
 487
 488                 do {
 489                         /*
 490                          * Run through entries, placing them into
 491                          * iovecs and sending when an end-of-packet
 492                          * is found
 493                          */
 494                         pci_vtnet_proctx(sc, vq);
 495                 } while (vq_has_descs(vq));
 496
 497                 /*
 498                  * Generate an interrupt if needed.
 499                  */
 500                 vq_endchains(vq, 1);
 501
 502                 pthread_mutex_lock(&sc->tx_mtx);
 503         }
 504 }
 505
 506 #ifdef notyet
 507 static void
 508 pci_vtnet_ping_ctlq(void *vsc, struct vqueue_info *vq)
 509 {
 510
 511         DPRINTF(("vtnet: control qnotify!\n\r"));
 512 }
 513 #endif
 514
 515 static int
 516 pci_vtnet_parsemac(char *mac_str, uint8_t *mac_addr)
 517 {
 518         struct ether_addr *ea;
 519         char *tmpstr;
 520         char zero_addr[ETHER_ADDR_LEN] = { 0, 0, 0, 0, 0, 0 };
 521
 522         tmpstr = strsep(&mac_str,"=");
 523
 524         if ((mac_str != NULL) && (!strcmp(tmpstr,"mac"))) {
 525                 ea = ether_aton(mac_str);
 526
 527                 if (ea == NULL || ETHER_IS_MULTICAST(ea->octet) ||
 528                     memcmp(ea->octet, zero_addr, ETHER_ADDR_LEN) == 0) {
 529                         fprintf(stderr, "Invalid MAC %s\n", mac_str);
 530                         return (EINVAL);
 531                 } else
 532                         memcpy(mac_addr, ea->octet, ETHER_ADDR_LEN);
 533         }
 534
 535         return (0);
 536 }
 537
 538
 539 static int
 540 pci_vtnet_init(struct vmctx *ctx, struct pci_devinst *pi, char *opts)
 541 {
 542         MD5_CTX mdctx;
 543         unsigned char digest[16];
 544         char nstr[80];
 545         char tname[MAXCOMLEN + 1];
 546         struct pci_vtnet_softc *sc;
 547         char *devname;
 548         char *vtopts;
 549         int mac_provided;
 550
 551         sc = calloc(1, sizeof(struct pci_vtnet_softc));
 552
 553         pthread_mutex_init(&sc->vsc_mtx, NULL);
 554
 555         vi_softc_linkup(&sc->vsc_vs, &vtnet_vi_consts, sc, pi, sc->vsc_queues);
 556         sc->vsc_vs.vs_mtx = &sc->vsc_mtx;
 557
 558         sc->vsc_queues[VTNET_RXQ].vq_qsize = VTNET_RINGSZ;
 559         sc->vsc_queues[VTNET_RXQ].vq_notify = pci_vtnet_ping_rxq;
 560         sc->vsc_queues[VTNET_TXQ].vq_qsize = VTNET_RINGSZ;
 561         sc->vsc_queues[VTNET_TXQ].vq_notify = pci_vtnet_ping_txq;
 562 #ifdef notyet
 563         sc->vsc_queues[VTNET_CTLQ].vq_qsize = VTNET_RINGSZ;
 564         sc->vsc_queues[VTNET_CTLQ].vq_notify = pci_vtnet_ping_ctlq;
 565 #endif
 566
 567         /*
 568          * Attempt to open the tap device and read the MAC address
 569          * if specified
 570          */
 571         mac_provided = 0;
 572         sc->vsc_tapfd = -1;
 573         if (opts != NULL) {
 574                 char tbuf[80];
 575                 int err;
 576
 577                 devname = vtopts = strdup(opts);
 578                 (void) strsep(&vtopts, ",");
 579
 580                 if (vtopts != NULL) {
 581                         err = pci_vtnet_parsemac(vtopts, sc->vsc_config.mac);
 582                         if (err != 0) {
 583                                 free(devname);
 584                                 return (err);
 585                         }
 586                         mac_provided = 1;
 587                 }
 588
 589                 strcpy(tbuf, "/dev/");
 590                 strlcat(tbuf, devname, sizeof(tbuf));
 591
 592                 free(devname);
 593
 594                 sc->vsc_tapfd = open(tbuf, O_RDWR);
 595                 if (sc->vsc_tapfd == -1) {
 596                         WPRINTF(("open of tap device %s failed\n", tbuf));
 597                 } else {
 598                         /*
 599                          * Set non-blocking and register for read
 600                          * notifications with the event loop
 601                          */
 602                         int opt = 1;
 603                         if (ioctl(sc->vsc_tapfd, FIONBIO, &opt) < 0) {
 604                                 WPRINTF(("tap device O_NONBLOCK failed\n"));
 605                                 close(sc->vsc_tapfd);
 606                                 sc->vsc_tapfd = -1;
 607                         }
 608
 609                         sc->vsc_mevp = mevent_add(sc->vsc_tapfd,
 610                                                   EVF_READ,
 611                                                   pci_vtnet_tap_callback,
 612                                                   sc);
 613                         if (sc->vsc_mevp == NULL) {
 614                                 WPRINTF(("Could not register event\n"));
 615                                 close(sc->vsc_tapfd);
 616                                 sc->vsc_tapfd = -1;
 617                         }
 618                 }
 619         }
 620
 621         /*
 622          * The default MAC address is the standard NetApp OUI of 00-a0-98,
 623          * followed by an MD5 of the PCI slot/func number and dev name
 624          */
 625         if (!mac_provided) {
 626                 snprintf(nstr, sizeof(nstr), "%d-%d-%s", pi->pi_slot,
 627                     pi->pi_func, vmname);
 628
 629                 MD5Init(&mdctx);
 630                 MD5Update(&mdctx, nstr, strlen(nstr));
 631                 MD5Final(digest, &mdctx);
 632
 633                 sc->vsc_config.mac[0] = 0x00;
 634                 sc->vsc_config.mac[1] = 0xa0;
 635                 sc->vsc_config.mac[2] = 0x98;
 636                 sc->vsc_config.mac[3] = digest[0];
 637                 sc->vsc_config.mac[4] = digest[1];
 638                 sc->vsc_config.mac[5] = digest[2];
 639         }
 640
 641         /* initialize config space */
 642         pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_NET);
 643         pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
 644         pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_NETWORK);
 645         pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_TYPE_NET);
 646
 647         /* Link is up if we managed to open tap device. */
 648         sc->vsc_config.status = (opts == NULL || sc->vsc_tapfd >= 0);
 649
 650         /* use BAR 1 to map MSI-X table and PBA, if we're using MSI-X */
 651         if (vi_intr_init(&sc->vsc_vs, 1, fbsdrun_virtio_msix()))
 652                 return (1);
 653
 654         /* use BAR 0 to map config regs in IO space */
 655         vi_set_io_bar(&sc->vsc_vs, 0);
 656
 657         sc->resetting = 0;
 658
 659         sc->rx_merge = 1;
 660         sc->rx_vhdrlen = sizeof(struct virtio_net_rxhdr);
 661         sc->rx_in_progress = 0;
 662         pthread_mutex_init(&sc->rx_mtx, NULL);
 663
 664         /*
 665          * Initialize tx semaphore & spawn TX processing thread.
 666          * As of now, only one thread for TX desc processing is
 667          * spawned.
 668          */
 669         sc->tx_in_progress = 0;
 670         pthread_mutex_init(&sc->tx_mtx, NULL);
 671         pthread_cond_init(&sc->tx_cond, NULL);
 672         pthread_create(&sc->tx_tid, NULL, pci_vtnet_tx_thread, (void *)sc);
 673         snprintf(tname, sizeof(tname), "vtnet-%d:%d tx", pi->pi_slot,
 674             pi->pi_func);
 675         pthread_set_name_np(sc->tx_tid, tname);
 676
 677         return (0);
 678 }
 679
 680 static int
 681 pci_vtnet_cfgwrite(void *vsc, int offset, int size, uint32_t value)
 682 {
 683         struct pci_vtnet_softc *sc = vsc;
 684         void *ptr;
 685
 686         if (offset < 6) {
 687                 assert(offset + size <= 6);
 688                 /*
 689                  * The driver is allowed to change the MAC address
 690                  */
 691                 ptr = &sc->vsc_config.mac[offset];
 692                 memcpy(ptr, &value, size);
 693         } else {
 694                 /* silently ignore other writes */
 695                 DPRINTF(("vtnet: write to readonly reg %d\n\r", offset));
 696         }
 697
 698         return (0);
 699 }
 700
 701 static int
 702 pci_vtnet_cfgread(void *vsc, int offset, int size, uint32_t *retval)
 703 {
 704         struct pci_vtnet_softc *sc = vsc;
 705         void *ptr;
 706
 707         ptr = (uint8_t *)&sc->vsc_config + offset;
 708         memcpy(retval, ptr, size);
 709         return (0);
 710 }
 711
 712 static void
 713 pci_vtnet_neg_features(void *vsc, uint64_t negotiated_features)
 714 {
 715         struct pci_vtnet_softc *sc = vsc;
 716
 717         sc->vsc_features = negotiated_features;
 718
 719         if (!(sc->vsc_features & VIRTIO_NET_F_MRG_RXBUF)) {
 720                 sc->rx_merge = 0;
 721                 /* non-merge rx header is 2 bytes shorter */
 722                 sc->rx_vhdrlen -= 2;
 723         }
 724 }
 725
 726 struct pci_devemu pci_de_vnet = {
 727         .pe_emu =       "virtio-net",
 728         .pe_init =      pci_vtnet_init,
 729         .pe_barwrite =  vi_pci_write,
 730         .pe_barread =   vi_pci_read
 731 };
 732 PCI_EMUL_SET(pci_de_vnet);