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