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