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