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); 928