1 /* 2 * Copyright (c) 2006, Cisco Systems, 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 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. Neither the name of Cisco Systems, Inc. nor the names of its contributors 15 * may be used to endorse or promote products derived from this software 16 * without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 #include "opt_sctp.h" 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/sockio.h> 38 #include <sys/mbuf.h> 39 #include <sys/malloc.h> 40 #include <sys/kernel.h> 41 #include <sys/socket.h> 42 #include <sys/queue.h> 43 #include <sys/taskqueue.h> 44 45 #include <sys/module.h> 46 #include <sys/bus.h> 47 #include <sys/sysctl.h> 48 49 #include <net/if.h> 50 #include <net/if_arp.h> 51 #include <net/if_types.h> 52 #include <net/ethernet.h> 53 #include <net/if_bridgevar.h> 54 55 #include <netinet/in_systm.h> 56 #include <netinet/in.h> 57 #include <netinet/in_var.h> 58 #include <netinet/ip.h> 59 #include <netinet/tcp.h> 60 #include <netinet/udp.h> 61 #ifdef SCTP 62 #include <netinet/sctp.h> 63 #include <netinet/sctp_crc32.h> 64 #endif 65 66 #include <vm/vm_extern.h> 67 #include <vm/vm_kern.h> 68 69 #include <machine/in_cksum.h> 70 #include <machine/xen-os.h> 71 #include <machine/hypervisor.h> 72 #include <machine/hypervisor-ifs.h> 73 #include <machine/xen_intr.h> 74 #include <machine/evtchn.h> 75 #include <machine/xenbus.h> 76 #include <machine/gnttab.h> 77 #include <machine/xen-public/memory.h> 78 #include <dev/xen/xenbus/xenbus_comms.h> 79 80 81 #ifdef XEN_NETBACK_DEBUG 82 #define DPRINTF(fmt, args...) \ 83 printf("netback (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args) 84 #else 85 #define DPRINTF(fmt, args...) ((void)0) 86 #endif 87 88 #ifdef XEN_NETBACK_DEBUG_LOTS 89 #define DDPRINTF(fmt, args...) \ 90 printf("netback (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args) 91 #define DPRINTF_MBUF(_m) print_mbuf(_m, 0) 92 #define DPRINTF_MBUF_LEN(_m, _len) print_mbuf(_m, _len) 93 #else 94 #define DDPRINTF(fmt, args...) ((void)0) 95 #define DPRINTF_MBUF(_m) ((void)0) 96 #define DPRINTF_MBUF_LEN(_m, _len) ((void)0) 97 #endif 98 99 #define WPRINTF(fmt, args...) \ 100 printf("netback (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args) 101 102 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) 103 #define BUG_ON PANIC_IF 104 105 #define IFNAME(_np) (_np)->ifp->if_xname 106 107 #define NET_TX_RING_SIZE __RING_SIZE((netif_tx_sring_t *)0, PAGE_SIZE) 108 #define NET_RX_RING_SIZE __RING_SIZE((netif_rx_sring_t *)0, PAGE_SIZE) 109 110 struct ring_ref { 111 vm_offset_t va; 112 grant_handle_t handle; 113 uint64_t bus_addr; 114 }; 115 116 typedef struct netback_info { 117 118 /* Schedule lists */ 119 STAILQ_ENTRY(netback_info) next_tx; 120 STAILQ_ENTRY(netback_info) next_rx; 121 int on_tx_sched_list; 122 int on_rx_sched_list; 123 124 struct xenbus_device *xdev; 125 XenbusState frontend_state; 126 127 domid_t domid; 128 int handle; 129 char *bridge; 130 131 int rings_connected; 132 struct ring_ref tx_ring_ref; 133 struct ring_ref rx_ring_ref; 134 netif_tx_back_ring_t tx; 135 netif_rx_back_ring_t rx; 136 evtchn_port_t evtchn; 137 int irq; 138 void *irq_cookie; 139 140 struct ifnet *ifp; 141 int ref_cnt; 142 143 device_t ndev; 144 int attached; 145 } netif_t; 146 147 148 #define MAX_PENDING_REQS 256 149 #define PKT_PROT_LEN 64 150 151 static struct { 152 netif_tx_request_t req; 153 netif_t *netif; 154 } pending_tx_info[MAX_PENDING_REQS]; 155 static uint16_t pending_ring[MAX_PENDING_REQS]; 156 typedef unsigned int PEND_RING_IDX; 157 #define MASK_PEND_IDX(_i) ((_i)&(MAX_PENDING_REQS-1)) 158 static PEND_RING_IDX pending_prod, pending_cons; 159 #define NR_PENDING_REQS (MAX_PENDING_REQS - pending_prod + pending_cons) 160 161 static unsigned long mmap_vstart; 162 #define MMAP_VADDR(_req) (mmap_vstart + ((_req) * PAGE_SIZE)) 163 164 /* Freed TX mbufs get batched on this ring before return to pending_ring. */ 165 static uint16_t dealloc_ring[MAX_PENDING_REQS]; 166 static PEND_RING_IDX dealloc_prod, dealloc_cons; 167 168 static multicall_entry_t rx_mcl[NET_RX_RING_SIZE+1]; 169 static mmu_update_t rx_mmu[NET_RX_RING_SIZE]; 170 static gnttab_transfer_t grant_rx_op[NET_RX_RING_SIZE]; 171 172 static grant_handle_t grant_tx_handle[MAX_PENDING_REQS]; 173 static gnttab_unmap_grant_ref_t tx_unmap_ops[MAX_PENDING_REQS]; 174 static gnttab_map_grant_ref_t tx_map_ops[MAX_PENDING_REQS]; 175 176 static struct task net_tx_task, net_rx_task; 177 static struct callout rx_task_callout; 178 179 static STAILQ_HEAD(netback_tx_sched_list, netback_info) tx_sched_list = 180 STAILQ_HEAD_INITIALIZER(tx_sched_list); 181 static STAILQ_HEAD(netback_rx_sched_list, netback_info) rx_sched_list = 182 STAILQ_HEAD_INITIALIZER(rx_sched_list); 183 static struct mtx tx_sched_list_lock; 184 static struct mtx rx_sched_list_lock; 185 186 static int vif_unit_maker = 0; 187 188 /* Protos */ 189 static void netback_start(struct ifnet *ifp); 190 static int netback_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data); 191 static int vif_add_dev(struct xenbus_device *xdev); 192 static void disconnect_rings(netif_t *netif); 193 194 #ifdef XEN_NETBACK_DEBUG_LOTS 195 /* Debug code to display the contents of an mbuf */ 196 static void 197 print_mbuf(struct mbuf *m, int max) 198 { 199 int i, j=0; 200 printf("mbuf %08x len = %d", (unsigned int)m, m->m_pkthdr.len); 201 for (; m; m = m->m_next) { 202 unsigned char *d = m->m_data; 203 for (i=0; i < m->m_len; i++) { 204 if (max && j == max) 205 break; 206 if ((j++ % 16) == 0) 207 printf("\n%04x:", j); 208 printf(" %02x", d[i]); 209 } 210 } 211 printf("\n"); 212 } 213 #endif 214 215 216 #define MAX_MFN_ALLOC 64 217 static unsigned long mfn_list[MAX_MFN_ALLOC]; 218 static unsigned int alloc_index = 0; 219 220 static unsigned long 221 alloc_mfn(void) 222 { 223 unsigned long mfn = 0; 224 struct xen_memory_reservation reservation = { 225 .extent_start = mfn_list, 226 .nr_extents = MAX_MFN_ALLOC, 227 .extent_order = 0, 228 .domid = DOMID_SELF 229 }; 230 if ( unlikely(alloc_index == 0) ) 231 alloc_index = HYPERVISOR_memory_op( 232 XENMEM_increase_reservation, &reservation); 233 if ( alloc_index != 0 ) 234 mfn = mfn_list[--alloc_index]; 235 return mfn; 236 } 237 238 static unsigned long 239 alloc_empty_page_range(unsigned long nr_pages) 240 { 241 void *pages; 242 int i = 0, j = 0; 243 multicall_entry_t mcl[17]; 244 unsigned long mfn_list[16]; 245 struct xen_memory_reservation reservation = { 246 .extent_start = mfn_list, 247 .nr_extents = 0, 248 .address_bits = 0, 249 .extent_order = 0, 250 .domid = DOMID_SELF 251 }; 252 253 pages = malloc(nr_pages*PAGE_SIZE, M_DEVBUF, M_NOWAIT); 254 if (pages == NULL) 255 return 0; 256 257 memset(mcl, 0, sizeof(mcl)); 258 259 while (i < nr_pages) { 260 unsigned long va = (unsigned long)pages + (i++ * PAGE_SIZE); 261 262 mcl[j].op = __HYPERVISOR_update_va_mapping; 263 mcl[j].args[0] = va; 264 265 mfn_list[j++] = vtomach(va) >> PAGE_SHIFT; 266 267 xen_phys_machine[(vtophys(va) >> PAGE_SHIFT)] = INVALID_P2M_ENTRY; 268 269 if (j == 16 || i == nr_pages) { 270 mcl[j-1].args[MULTI_UVMFLAGS_INDEX] = UVMF_TLB_FLUSH|UVMF_LOCAL; 271 272 reservation.nr_extents = j; 273 274 mcl[j].op = __HYPERVISOR_memory_op; 275 mcl[j].args[0] = XENMEM_decrease_reservation; 276 mcl[j].args[1] = (unsigned long)&reservation; 277 278 (void)HYPERVISOR_multicall(mcl, j+1); 279 280 mcl[j-1].args[MULTI_UVMFLAGS_INDEX] = 0; 281 j = 0; 282 } 283 } 284 285 return (unsigned long)pages; 286 } 287 288 #ifdef XEN_NETBACK_FIXUP_CSUM 289 static void 290 fixup_checksum(struct mbuf *m) 291 { 292 struct ether_header *eh = mtod(m, struct ether_header *); 293 struct ip *ip = (struct ip *)(eh + 1); 294 int iphlen = ip->ip_hl << 2; 295 int iplen = ntohs(ip->ip_len); 296 297 if ((m->m_pkthdr.csum_flags & CSUM_TCP)) { 298 struct tcphdr *th = (struct tcphdr *)((caddr_t)ip + iphlen); 299 th->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr, 300 htons(IPPROTO_TCP + (iplen - iphlen))); 301 th->th_sum = in_cksum_skip(m, iplen + sizeof(*eh), sizeof(*eh) + iphlen); 302 m->m_pkthdr.csum_flags &= ~CSUM_TCP; 303 #ifdef SCTP 304 } else if (sw_csum & CSUM_SCTP) { 305 sctp_delayed_cksum(m, iphlen); 306 sw_csum &= ~CSUM_SCTP; 307 #endif 308 } else { 309 u_short csum; 310 struct udphdr *uh = (struct udphdr *)((caddr_t)ip + iphlen); 311 uh->uh_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr, 312 htons(IPPROTO_UDP + (iplen - iphlen))); 313 if ((csum = in_cksum_skip(m, iplen + sizeof(*eh), sizeof(*eh) + iphlen)) == 0) 314 csum = 0xffff; 315 uh->uh_sum = csum; 316 m->m_pkthdr.csum_flags &= ~CSUM_UDP; 317 } 318 } 319 #endif 320 321 /* Add the interface to the specified bridge */ 322 static int 323 add_to_bridge(struct ifnet *ifp, char *bridge) 324 { 325 struct ifdrv ifd; 326 struct ifbreq ifb; 327 struct ifnet *ifp_bridge = ifunit(bridge); 328 329 if (!ifp_bridge) 330 return ENOENT; 331 332 bzero(&ifd, sizeof(ifd)); 333 bzero(&ifb, sizeof(ifb)); 334 335 strcpy(ifb.ifbr_ifsname, ifp->if_xname); 336 strcpy(ifd.ifd_name, ifp->if_xname); 337 ifd.ifd_cmd = BRDGADD; 338 ifd.ifd_len = sizeof(ifb); 339 ifd.ifd_data = &ifb; 340 341 return bridge_ioctl_kern(ifp_bridge, SIOCSDRVSPEC, &ifd); 342 343 } 344 345 static int 346 netif_create(int handle, struct xenbus_device *xdev, char *bridge) 347 { 348 netif_t *netif; 349 struct ifnet *ifp; 350 351 netif = (netif_t *)malloc(sizeof(*netif), M_DEVBUF, M_NOWAIT | M_ZERO); 352 if (!netif) 353 return ENOMEM; 354 355 netif->ref_cnt = 1; 356 netif->handle = handle; 357 netif->domid = xdev->otherend_id; 358 netif->xdev = xdev; 359 netif->bridge = bridge; 360 xdev->data = netif; 361 362 /* Set up ifnet structure */ 363 ifp = netif->ifp = if_alloc(IFT_ETHER); 364 if (!ifp) { 365 if (bridge) 366 free(bridge, M_DEVBUF); 367 free(netif, M_DEVBUF); 368 return ENOMEM; 369 } 370 371 ifp->if_softc = netif; 372 if_initname(ifp, "vif", 373 atomic_fetchadd_int(&vif_unit_maker, 1) /* ifno */ ); 374 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX; 375 ifp->if_output = ether_output; 376 ifp->if_start = netback_start; 377 ifp->if_ioctl = netback_ioctl; 378 ifp->if_mtu = ETHERMTU; 379 ifp->if_snd.ifq_maxlen = NET_TX_RING_SIZE - 1; 380 381 DPRINTF("Created %s for domid=%d handle=%d\n", IFNAME(netif), netif->domid, netif->handle); 382 383 return 0; 384 } 385 386 static void 387 netif_get(netif_t *netif) 388 { 389 atomic_add_int(&netif->ref_cnt, 1); 390 } 391 392 static void 393 netif_put(netif_t *netif) 394 { 395 if (atomic_fetchadd_int(&netif->ref_cnt, -1) == 1) { 396 DPRINTF("%s\n", IFNAME(netif)); 397 disconnect_rings(netif); 398 if (netif->ifp) { 399 if_free(netif->ifp); 400 netif->ifp = NULL; 401 } 402 if (netif->bridge) 403 free(netif->bridge, M_DEVBUF); 404 free(netif, M_DEVBUF); 405 } 406 } 407 408 static int 409 netback_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 410 { 411 switch (cmd) { 412 case SIOCSIFFLAGS: 413 DDPRINTF("%s cmd=SIOCSIFFLAGS flags=%x\n", 414 IFNAME((struct netback_info *)ifp->if_softc), ((struct ifreq *)data)->ifr_flags); 415 return 0; 416 } 417 418 DDPRINTF("%s cmd=%lx\n", IFNAME((struct netback_info *)ifp->if_softc), cmd); 419 420 return ether_ioctl(ifp, cmd, data); 421 } 422 423 static inline void 424 maybe_schedule_tx_action(void) 425 { 426 smp_mb(); 427 if ((NR_PENDING_REQS < (MAX_PENDING_REQS/2)) && !STAILQ_EMPTY(&tx_sched_list)) 428 taskqueue_enqueue(taskqueue_swi, &net_tx_task); 429 } 430 431 /* Removes netif from front of list and does not call netif_put() (caller must) */ 432 static netif_t * 433 remove_from_tx_schedule_list(void) 434 { 435 netif_t *netif; 436 437 mtx_lock(&tx_sched_list_lock); 438 439 if ((netif = STAILQ_FIRST(&tx_sched_list))) { 440 STAILQ_REMOVE(&tx_sched_list, netif, netback_info, next_tx); 441 STAILQ_NEXT(netif, next_tx) = NULL; 442 netif->on_tx_sched_list = 0; 443 } 444 445 mtx_unlock(&tx_sched_list_lock); 446 447 return netif; 448 } 449 450 /* Adds netif to end of list and calls netif_get() */ 451 static void 452 add_to_tx_schedule_list_tail(netif_t *netif) 453 { 454 if (netif->on_tx_sched_list) 455 return; 456 457 mtx_lock(&tx_sched_list_lock); 458 if (!netif->on_tx_sched_list && (netif->ifp->if_drv_flags & IFF_DRV_RUNNING)) { 459 netif_get(netif); 460 STAILQ_INSERT_TAIL(&tx_sched_list, netif, next_tx); 461 netif->on_tx_sched_list = 1; 462 } 463 mtx_unlock(&tx_sched_list_lock); 464 } 465 466 /* 467 * Note on CONFIG_XEN_NETDEV_PIPELINED_TRANSMITTER: 468 * If this driver is pipelining transmit requests then we can be very 469 * aggressive in avoiding new-packet notifications -- frontend only needs to 470 * send a notification if there are no outstanding unreceived responses. 471 * If we may be buffer transmit buffers for any reason then we must be rather 472 * more conservative and treat this as the final check for pending work. 473 */ 474 static void 475 netif_schedule_tx_work(netif_t *netif) 476 { 477 int more_to_do; 478 479 #ifdef CONFIG_XEN_NETDEV_PIPELINED_TRANSMITTER 480 more_to_do = RING_HAS_UNCONSUMED_REQUESTS(&netif->tx); 481 #else 482 RING_FINAL_CHECK_FOR_REQUESTS(&netif->tx, more_to_do); 483 #endif 484 485 if (more_to_do) { 486 DDPRINTF("Adding %s to tx sched list\n", IFNAME(netif)); 487 add_to_tx_schedule_list_tail(netif); 488 maybe_schedule_tx_action(); 489 } 490 } 491 492 static struct mtx dealloc_lock; 493 MTX_SYSINIT(netback_dealloc, &dealloc_lock, "DEALLOC LOCK", MTX_SPIN | MTX_NOWITNESS); 494 495 static void 496 netif_idx_release(uint16_t pending_idx) 497 { 498 mtx_lock_spin(&dealloc_lock); 499 dealloc_ring[MASK_PEND_IDX(dealloc_prod++)] = pending_idx; 500 mtx_unlock_spin(&dealloc_lock); 501 502 taskqueue_enqueue(taskqueue_swi, &net_tx_task); 503 } 504 505 static void 506 make_tx_response(netif_t *netif, 507 uint16_t id, 508 int8_t st) 509 { 510 RING_IDX i = netif->tx.rsp_prod_pvt; 511 netif_tx_response_t *resp; 512 int notify; 513 514 resp = RING_GET_RESPONSE(&netif->tx, i); 515 resp->id = id; 516 resp->status = st; 517 518 netif->tx.rsp_prod_pvt = ++i; 519 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netif->tx, notify); 520 if (notify) 521 notify_remote_via_irq(netif->irq); 522 523 #ifdef CONFIG_XEN_NETDEV_PIPELINED_TRANSMITTER 524 if (i == netif->tx.req_cons) { 525 int more_to_do; 526 RING_FINAL_CHECK_FOR_REQUESTS(&netif->tx, more_to_do); 527 if (more_to_do) 528 add_to_tx_schedule_list_tail(netif); 529 } 530 #endif 531 } 532 533 inline static void 534 net_tx_action_dealloc(void) 535 { 536 gnttab_unmap_grant_ref_t *gop; 537 uint16_t pending_idx; 538 PEND_RING_IDX dc, dp; 539 netif_t *netif; 540 int ret; 541 542 dc = dealloc_cons; 543 dp = dealloc_prod; 544 545 /* 546 * Free up any grants we have finished using 547 */ 548 gop = tx_unmap_ops; 549 while (dc != dp) { 550 pending_idx = dealloc_ring[MASK_PEND_IDX(dc++)]; 551 gop->host_addr = MMAP_VADDR(pending_idx); 552 gop->dev_bus_addr = 0; 553 gop->handle = grant_tx_handle[pending_idx]; 554 gop++; 555 } 556 ret = HYPERVISOR_grant_table_op( 557 GNTTABOP_unmap_grant_ref, tx_unmap_ops, gop - tx_unmap_ops); 558 BUG_ON(ret); 559 560 while (dealloc_cons != dp) { 561 pending_idx = dealloc_ring[MASK_PEND_IDX(dealloc_cons++)]; 562 563 netif = pending_tx_info[pending_idx].netif; 564 565 make_tx_response(netif, pending_tx_info[pending_idx].req.id, 566 NETIF_RSP_OKAY); 567 568 pending_ring[MASK_PEND_IDX(pending_prod++)] = pending_idx; 569 570 netif_put(netif); 571 } 572 } 573 574 static void 575 netif_page_release(void *buf, void *args) 576 { 577 uint16_t pending_idx = (unsigned int)args; 578 579 DDPRINTF("pending_idx=%u\n", pending_idx); 580 581 KASSERT(pending_idx < MAX_PENDING_REQS, ("%s: bad index %u", __func__, pending_idx)); 582 583 netif_idx_release(pending_idx); 584 } 585 586 static void 587 net_tx_action(void *context, int pending) 588 { 589 struct mbuf *m; 590 netif_t *netif; 591 netif_tx_request_t txreq; 592 uint16_t pending_idx; 593 RING_IDX i; 594 gnttab_map_grant_ref_t *mop; 595 int ret, work_to_do; 596 struct mbuf *txq = NULL, *txq_last = NULL; 597 598 if (dealloc_cons != dealloc_prod) 599 net_tx_action_dealloc(); 600 601 mop = tx_map_ops; 602 while ((NR_PENDING_REQS < MAX_PENDING_REQS) && !STAILQ_EMPTY(&tx_sched_list)) { 603 604 /* Get a netif from the list with work to do. */ 605 netif = remove_from_tx_schedule_list(); 606 607 DDPRINTF("Processing %s (prod=%u, cons=%u)\n", 608 IFNAME(netif), netif->tx.sring->req_prod, netif->tx.req_cons); 609 610 RING_FINAL_CHECK_FOR_REQUESTS(&netif->tx, work_to_do); 611 if (!work_to_do) { 612 netif_put(netif); 613 continue; 614 } 615 616 i = netif->tx.req_cons; 617 rmb(); /* Ensure that we see the request before we copy it. */ 618 memcpy(&txreq, RING_GET_REQUEST(&netif->tx, i), sizeof(txreq)); 619 620 /* If we want credit-based scheduling, coud add it here - WORK */ 621 622 netif->tx.req_cons++; 623 624 netif_schedule_tx_work(netif); 625 626 if (unlikely(txreq.size < ETHER_HDR_LEN) || 627 unlikely(txreq.size > (ETHER_MAX_LEN-ETHER_CRC_LEN))) { 628 WPRINTF("Bad packet size: %d\n", txreq.size); 629 make_tx_response(netif, txreq.id, NETIF_RSP_ERROR); 630 netif_put(netif); 631 continue; 632 } 633 634 /* No crossing a page as the payload mustn't fragment. */ 635 if (unlikely((txreq.offset + txreq.size) >= PAGE_SIZE)) { 636 WPRINTF("txreq.offset: %x, size: %u, end: %u\n", 637 txreq.offset, txreq.size, 638 (txreq.offset & PAGE_MASK) + txreq.size); 639 make_tx_response(netif, txreq.id, NETIF_RSP_ERROR); 640 netif_put(netif); 641 continue; 642 } 643 644 pending_idx = pending_ring[MASK_PEND_IDX(pending_cons)]; 645 646 MGETHDR(m, M_DONTWAIT, MT_DATA); 647 if (!m) { 648 WPRINTF("Failed to allocate mbuf\n"); 649 make_tx_response(netif, txreq.id, NETIF_RSP_ERROR); 650 netif_put(netif); 651 break; 652 } 653 m->m_pkthdr.rcvif = netif->ifp; 654 655 if ((m->m_pkthdr.len = txreq.size) > PKT_PROT_LEN) { 656 struct mbuf *n; 657 MGET(n, M_DONTWAIT, MT_DATA); 658 if (!(m->m_next = n)) { 659 m_freem(m); 660 WPRINTF("Failed to allocate second mbuf\n"); 661 make_tx_response(netif, txreq.id, NETIF_RSP_ERROR); 662 netif_put(netif); 663 break; 664 } 665 n->m_len = txreq.size - PKT_PROT_LEN; 666 m->m_len = PKT_PROT_LEN; 667 } else 668 m->m_len = txreq.size; 669 670 mop->host_addr = MMAP_VADDR(pending_idx); 671 mop->dom = netif->domid; 672 mop->ref = txreq.gref; 673 mop->flags = GNTMAP_host_map | GNTMAP_readonly; 674 mop++; 675 676 memcpy(&pending_tx_info[pending_idx].req, 677 &txreq, sizeof(txreq)); 678 pending_tx_info[pending_idx].netif = netif; 679 *((uint16_t *)m->m_data) = pending_idx; 680 681 if (txq_last) 682 txq_last->m_nextpkt = m; 683 else 684 txq = m; 685 txq_last = m; 686 687 pending_cons++; 688 689 if ((mop - tx_map_ops) >= ARRAY_SIZE(tx_map_ops)) 690 break; 691 } 692 693 if (!txq) 694 return; 695 696 ret = HYPERVISOR_grant_table_op( 697 GNTTABOP_map_grant_ref, tx_map_ops, mop - tx_map_ops); 698 BUG_ON(ret); 699 700 mop = tx_map_ops; 701 while ((m = txq) != NULL) { 702 caddr_t data; 703 704 txq = m->m_nextpkt; 705 m->m_nextpkt = NULL; 706 707 pending_idx = *((uint16_t *)m->m_data); 708 netif = pending_tx_info[pending_idx].netif; 709 memcpy(&txreq, &pending_tx_info[pending_idx].req, sizeof(txreq)); 710 711 /* Check the remap error code. */ 712 if (unlikely(mop->status)) { 713 WPRINTF("#### netback grant fails\n"); 714 make_tx_response(netif, txreq.id, NETIF_RSP_ERROR); 715 netif_put(netif); 716 m_freem(m); 717 mop++; 718 pending_ring[MASK_PEND_IDX(pending_prod++)] = pending_idx; 719 continue; 720 } 721 722 #if 0 723 /* Can't do this in FreeBSD since vtophys() returns the pfn */ 724 /* of the remote domain who loaned us the machine page - DPT */ 725 xen_phys_machine[(vtophys(MMAP_VADDR(pending_idx)) >> PAGE_SHIFT)] = 726 mop->dev_bus_addr >> PAGE_SHIFT; 727 #endif 728 grant_tx_handle[pending_idx] = mop->handle; 729 730 /* Setup data in mbuf (lengths are already set) */ 731 data = (caddr_t)(MMAP_VADDR(pending_idx)|txreq.offset); 732 bcopy(data, m->m_data, m->m_len); 733 if (m->m_next) { 734 struct mbuf *n = m->m_next; 735 MEXTADD(n, MMAP_VADDR(pending_idx), PAGE_SIZE, netif_page_release, 736 (void *)(unsigned int)pending_idx, M_RDONLY, EXT_NET_DRV); 737 n->m_data = &data[PKT_PROT_LEN]; 738 } else { 739 /* Schedule a response immediately. */ 740 netif_idx_release(pending_idx); 741 } 742 743 if ((txreq.flags & NETTXF_data_validated)) { 744 /* Tell the stack the checksums are okay */ 745 m->m_pkthdr.csum_flags |= 746 (CSUM_IP_CHECKED | CSUM_IP_VALID | CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 747 m->m_pkthdr.csum_data = 0xffff; 748 } 749 750 /* If necessary, inform stack to compute the checksums if it forwards the packet */ 751 if ((txreq.flags & NETTXF_csum_blank)) { 752 struct ether_header *eh = mtod(m, struct ether_header *); 753 if (ntohs(eh->ether_type) == ETHERTYPE_IP) { 754 struct ip *ip = (struct ip *)&m->m_data[14]; 755 if (ip->ip_p == IPPROTO_TCP) 756 m->m_pkthdr.csum_flags |= CSUM_TCP; 757 else if (ip->ip_p == IPPROTO_UDP) 758 m->m_pkthdr.csum_flags |= CSUM_UDP; 759 } 760 } 761 762 netif->ifp->if_ibytes += m->m_pkthdr.len; 763 netif->ifp->if_ipackets++; 764 765 DDPRINTF("RECV %d bytes from %s (cflags=%x)\n", 766 m->m_pkthdr.len, IFNAME(netif), m->m_pkthdr.csum_flags); 767 DPRINTF_MBUF_LEN(m, 128); 768 769 (*netif->ifp->if_input)(netif->ifp, m); 770 771 mop++; 772 } 773 } 774 775 /* Handle interrupt from a frontend */ 776 static void 777 netback_intr(void *arg) 778 { 779 netif_t *netif = arg; 780 DDPRINTF("%s\n", IFNAME(netif)); 781 add_to_tx_schedule_list_tail(netif); 782 maybe_schedule_tx_action(); 783 } 784 785 /* Removes netif from front of list and does not call netif_put() (caller must) */ 786 static netif_t * 787 remove_from_rx_schedule_list(void) 788 { 789 netif_t *netif; 790 791 mtx_lock(&rx_sched_list_lock); 792 793 if ((netif = STAILQ_FIRST(&rx_sched_list))) { 794 STAILQ_REMOVE(&rx_sched_list, netif, netback_info, next_rx); 795 STAILQ_NEXT(netif, next_rx) = NULL; 796 netif->on_rx_sched_list = 0; 797 } 798 799 mtx_unlock(&rx_sched_list_lock); 800 801 return netif; 802 } 803 804 /* Adds netif to end of list and calls netif_get() */ 805 static void 806 add_to_rx_schedule_list_tail(netif_t *netif) 807 { 808 if (netif->on_rx_sched_list) 809 return; 810 811 mtx_lock(&rx_sched_list_lock); 812 if (!netif->on_rx_sched_list && (netif->ifp->if_drv_flags & IFF_DRV_RUNNING)) { 813 netif_get(netif); 814 STAILQ_INSERT_TAIL(&rx_sched_list, netif, next_rx); 815 netif->on_rx_sched_list = 1; 816 } 817 mtx_unlock(&rx_sched_list_lock); 818 } 819 820 static int 821 make_rx_response(netif_t *netif, uint16_t id, int8_t st, 822 uint16_t offset, uint16_t size, uint16_t flags) 823 { 824 RING_IDX i = netif->rx.rsp_prod_pvt; 825 netif_rx_response_t *resp; 826 int notify; 827 828 resp = RING_GET_RESPONSE(&netif->rx, i); 829 resp->offset = offset; 830 resp->flags = flags; 831 resp->id = id; 832 resp->status = (int16_t)size; 833 if (st < 0) 834 resp->status = (int16_t)st; 835 836 DDPRINTF("rx resp(%d): off=%x fl=%x id=%x stat=%d\n", 837 i, resp->offset, resp->flags, resp->id, resp->status); 838 839 netif->rx.rsp_prod_pvt = ++i; 840 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netif->rx, notify); 841 842 return notify; 843 } 844 845 static int 846 netif_rx(netif_t *netif) 847 { 848 struct ifnet *ifp = netif->ifp; 849 struct mbuf *m; 850 multicall_entry_t *mcl; 851 mmu_update_t *mmu; 852 gnttab_transfer_t *gop; 853 unsigned long vdata, old_mfn, new_mfn; 854 struct mbuf *rxq = NULL, *rxq_last = NULL; 855 int ret, notify = 0, pkts_dequeued = 0; 856 857 DDPRINTF("%s\n", IFNAME(netif)); 858 859 mcl = rx_mcl; 860 mmu = rx_mmu; 861 gop = grant_rx_op; 862 863 while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) { 864 865 /* Quit if the target domain has no receive buffers */ 866 if (netif->rx.req_cons == netif->rx.sring->req_prod) 867 break; 868 869 IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 870 if (m == NULL) 871 break; 872 873 pkts_dequeued++; 874 875 /* Check if we need to copy the data */ 876 if (((m->m_flags & (M_RDONLY|M_EXT)) != M_EXT) || 877 (*m->m_ext.ref_cnt > 1) || m->m_next != NULL) { 878 struct mbuf *n; 879 880 DDPRINTF("copying mbuf (fl=%x ext=%x rc=%d n=%x)\n", 881 m->m_flags, 882 (m->m_flags & M_EXT) ? m->m_ext.ext_type : 0, 883 (m->m_flags & M_EXT) ? *m->m_ext.ref_cnt : 0, 884 (unsigned int)m->m_next); 885 886 /* Make copy */ 887 MGETHDR(n, M_DONTWAIT, MT_DATA); 888 if (!n) 889 goto drop; 890 891 MCLGET(n, M_DONTWAIT); 892 if (!(n->m_flags & M_EXT)) { 893 m_freem(n); 894 goto drop; 895 } 896 897 /* Leave space at front and keep current alignment */ 898 n->m_data += 16 + ((unsigned int)m->m_data & 0x3); 899 900 if (m->m_pkthdr.len > M_TRAILINGSPACE(n)) { 901 WPRINTF("pkt to big %d\n", m->m_pkthdr.len); 902 m_freem(n); 903 goto drop; 904 } 905 m_copydata(m, 0, m->m_pkthdr.len, n->m_data); 906 n->m_pkthdr.len = n->m_len = m->m_pkthdr.len; 907 n->m_pkthdr.csum_flags = (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA); 908 m_freem(m); 909 m = n; 910 } 911 912 vdata = (unsigned long)m->m_data; 913 old_mfn = vtomach(vdata) >> PAGE_SHIFT; 914 915 if ((new_mfn = alloc_mfn()) == 0) 916 goto drop; 917 918 #ifdef XEN_NETBACK_FIXUP_CSUM 919 /* Check if we need to compute a checksum. This happens */ 920 /* when bridging from one domain to another. */ 921 if ((m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) || 922 (m->m_pkthdr.csum_flags & CSUM_SCTP)) 923 fixup_checksum(m); 924 #endif 925 926 xen_phys_machine[(vtophys(vdata) >> PAGE_SHIFT)] = new_mfn; 927 928 mcl->op = __HYPERVISOR_update_va_mapping; 929 mcl->args[0] = vdata; 930 mcl->args[1] = (new_mfn << PAGE_SHIFT) | PG_V | PG_RW | PG_M | PG_A; 931 mcl->args[2] = 0; 932 mcl->args[3] = 0; 933 mcl++; 934 935 gop->mfn = old_mfn; 936 gop->domid = netif->domid; 937 gop->ref = RING_GET_REQUEST(&netif->rx, netif->rx.req_cons)->gref; 938 netif->rx.req_cons++; 939 gop++; 940 941 mmu->ptr = (new_mfn << PAGE_SHIFT) | MMU_MACHPHYS_UPDATE; 942 mmu->val = vtophys(vdata) >> PAGE_SHIFT; 943 mmu++; 944 945 if (rxq_last) 946 rxq_last->m_nextpkt = m; 947 else 948 rxq = m; 949 rxq_last = m; 950 951 DDPRINTF("XMIT %d bytes to %s\n", m->m_pkthdr.len, IFNAME(netif)); 952 DPRINTF_MBUF_LEN(m, 128); 953 954 /* Filled the batch queue? */ 955 if ((gop - grant_rx_op) == ARRAY_SIZE(grant_rx_op)) 956 break; 957 958 continue; 959 drop: 960 DDPRINTF("dropping pkt\n"); 961 ifp->if_oerrors++; 962 m_freem(m); 963 } 964 965 if (mcl == rx_mcl) 966 return pkts_dequeued; 967 968 mcl->op = __HYPERVISOR_mmu_update; 969 mcl->args[0] = (unsigned long)rx_mmu; 970 mcl->args[1] = mmu - rx_mmu; 971 mcl->args[2] = 0; 972 mcl->args[3] = DOMID_SELF; 973 mcl++; 974 975 mcl[-2].args[MULTI_UVMFLAGS_INDEX] = UVMF_TLB_FLUSH|UVMF_ALL; 976 ret = HYPERVISOR_multicall(rx_mcl, mcl - rx_mcl); 977 BUG_ON(ret != 0); 978 979 ret = HYPERVISOR_grant_table_op(GNTTABOP_transfer, grant_rx_op, gop - grant_rx_op); 980 BUG_ON(ret != 0); 981 982 mcl = rx_mcl; 983 gop = grant_rx_op; 984 985 while ((m = rxq) != NULL) { 986 int8_t status; 987 uint16_t id, flags = 0; 988 989 rxq = m->m_nextpkt; 990 m->m_nextpkt = NULL; 991 992 /* Rederive the machine addresses. */ 993 new_mfn = mcl->args[1] >> PAGE_SHIFT; 994 old_mfn = gop->mfn; 995 996 ifp->if_obytes += m->m_pkthdr.len; 997 ifp->if_opackets++; 998 999 /* The update_va_mapping() must not fail. */ 1000 BUG_ON(mcl->result != 0); 1001 1002 /* Setup flags */ 1003 if ((m->m_pkthdr.csum_flags & CSUM_DELAY_DATA)) 1004 flags |= NETRXF_csum_blank | NETRXF_data_validated; 1005 else if ((m->m_pkthdr.csum_flags & CSUM_DATA_VALID)) 1006 flags |= NETRXF_data_validated; 1007 1008 /* Check the reassignment error code. */ 1009 status = NETIF_RSP_OKAY; 1010 if (gop->status != 0) { 1011 DPRINTF("Bad status %d from grant transfer to DOM%u\n", 1012 gop->status, netif->domid); 1013 /* 1014 * Page no longer belongs to us unless GNTST_bad_page, 1015 * but that should be a fatal error anyway. 1016 */ 1017 BUG_ON(gop->status == GNTST_bad_page); 1018 status = NETIF_RSP_ERROR; 1019 } 1020 id = RING_GET_REQUEST(&netif->rx, netif->rx.rsp_prod_pvt)->id; 1021 notify |= make_rx_response(netif, id, status, 1022 (unsigned long)m->m_data & PAGE_MASK, 1023 m->m_pkthdr.len, flags); 1024 1025 m_freem(m); 1026 mcl++; 1027 gop++; 1028 } 1029 1030 if (notify) 1031 notify_remote_via_irq(netif->irq); 1032 1033 return pkts_dequeued; 1034 } 1035 1036 static void 1037 rx_task_timer(void *arg) 1038 { 1039 DDPRINTF("\n"); 1040 taskqueue_enqueue(taskqueue_swi, &net_rx_task); 1041 } 1042 1043 static void 1044 net_rx_action(void *context, int pending) 1045 { 1046 netif_t *netif, *last_zero_work = NULL; 1047 1048 DDPRINTF("\n"); 1049 1050 while ((netif = remove_from_rx_schedule_list())) { 1051 struct ifnet *ifp = netif->ifp; 1052 1053 if (netif == last_zero_work) { 1054 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) 1055 add_to_rx_schedule_list_tail(netif); 1056 netif_put(netif); 1057 if (!STAILQ_EMPTY(&rx_sched_list)) 1058 callout_reset(&rx_task_callout, 1, rx_task_timer, NULL); 1059 break; 1060 } 1061 1062 if ((ifp->if_drv_flags & IFF_DRV_RUNNING)) { 1063 if (netif_rx(netif)) 1064 last_zero_work = NULL; 1065 else if (!last_zero_work) 1066 last_zero_work = netif; 1067 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) 1068 add_to_rx_schedule_list_tail(netif); 1069 } 1070 1071 netif_put(netif); 1072 } 1073 } 1074 1075 static void 1076 netback_start(struct ifnet *ifp) 1077 { 1078 netif_t *netif = (netif_t *)ifp->if_softc; 1079 1080 DDPRINTF("%s\n", IFNAME(netif)); 1081 1082 add_to_rx_schedule_list_tail(netif); 1083 taskqueue_enqueue(taskqueue_swi, &net_rx_task); 1084 } 1085 1086 /* Map a grant ref to a ring */ 1087 static int 1088 map_ring(grant_ref_t ref, domid_t dom, struct ring_ref *ring) 1089 { 1090 struct gnttab_map_grant_ref op; 1091 1092 ring->va = kmem_alloc_nofault(kernel_map, PAGE_SIZE); 1093 if (ring->va == 0) 1094 return ENOMEM; 1095 1096 op.host_addr = ring->va; 1097 op.flags = GNTMAP_host_map; 1098 op.ref = ref; 1099 op.dom = dom; 1100 HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1); 1101 if (op.status) { 1102 WPRINTF("grant table op err=%d\n", op.status); 1103 kmem_free(kernel_map, ring->va, PAGE_SIZE); 1104 ring->va = 0; 1105 return EACCES; 1106 } 1107 1108 ring->handle = op.handle; 1109 ring->bus_addr = op.dev_bus_addr; 1110 1111 return 0; 1112 } 1113 1114 /* Unmap grant ref for a ring */ 1115 static void 1116 unmap_ring(struct ring_ref *ring) 1117 { 1118 struct gnttab_unmap_grant_ref op; 1119 1120 op.host_addr = ring->va; 1121 op.dev_bus_addr = ring->bus_addr; 1122 op.handle = ring->handle; 1123 HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1); 1124 if (op.status) 1125 WPRINTF("grant table op err=%d\n", op.status); 1126 1127 kmem_free(kernel_map, ring->va, PAGE_SIZE); 1128 ring->va = 0; 1129 } 1130 1131 static int 1132 connect_rings(netif_t *netif) 1133 { 1134 struct xenbus_device *xdev = netif->xdev; 1135 netif_tx_sring_t *txs; 1136 netif_rx_sring_t *rxs; 1137 unsigned long tx_ring_ref, rx_ring_ref; 1138 evtchn_port_t evtchn; 1139 evtchn_op_t op = { .cmd = EVTCHNOP_bind_interdomain }; 1140 int err; 1141 1142 // Grab FE data and map his memory 1143 err = xenbus_gather(NULL, xdev->otherend, 1144 "tx-ring-ref", "%lu", &tx_ring_ref, 1145 "rx-ring-ref", "%lu", &rx_ring_ref, 1146 "event-channel", "%u", &evtchn, NULL); 1147 if (err) { 1148 xenbus_dev_fatal(xdev, err, 1149 "reading %s/ring-ref and event-channel", 1150 xdev->otherend); 1151 return err; 1152 } 1153 1154 err = map_ring(tx_ring_ref, netif->domid, &netif->tx_ring_ref); 1155 if (err) { 1156 xenbus_dev_fatal(xdev, err, "mapping tx ring"); 1157 return err; 1158 } 1159 txs = (netif_tx_sring_t *)netif->tx_ring_ref.va; 1160 BACK_RING_INIT(&netif->tx, txs, PAGE_SIZE); 1161 1162 err = map_ring(rx_ring_ref, netif->domid, &netif->rx_ring_ref); 1163 if (err) { 1164 unmap_ring(&netif->tx_ring_ref); 1165 xenbus_dev_fatal(xdev, err, "mapping rx ring"); 1166 return err; 1167 } 1168 rxs = (netif_rx_sring_t *)netif->rx_ring_ref.va; 1169 BACK_RING_INIT(&netif->rx, rxs, PAGE_SIZE); 1170 1171 op.u.bind_interdomain.remote_dom = netif->domid; 1172 op.u.bind_interdomain.remote_port = evtchn; 1173 err = HYPERVISOR_event_channel_op(&op); 1174 if (err) { 1175 unmap_ring(&netif->tx_ring_ref); 1176 unmap_ring(&netif->rx_ring_ref); 1177 xenbus_dev_fatal(xdev, err, "binding event channel"); 1178 return err; 1179 } 1180 netif->evtchn = op.u.bind_interdomain.local_port; 1181 1182 /* bind evtchn to irq handler */ 1183 netif->irq = 1184 bind_evtchn_to_irqhandler(netif->evtchn, "netback", 1185 netback_intr, netif, INTR_TYPE_NET|INTR_MPSAFE, &netif->irq_cookie); 1186 1187 netif->rings_connected = 1; 1188 1189 DPRINTF("%s connected! evtchn=%d irq=%d\n", 1190 IFNAME(netif), netif->evtchn, netif->irq); 1191 1192 return 0; 1193 } 1194 1195 static void 1196 disconnect_rings(netif_t *netif) 1197 { 1198 DPRINTF("\n"); 1199 1200 if (netif->rings_connected) { 1201 unbind_from_irqhandler(netif->irq, netif->irq_cookie); 1202 netif->irq = 0; 1203 unmap_ring(&netif->tx_ring_ref); 1204 unmap_ring(&netif->rx_ring_ref); 1205 netif->rings_connected = 0; 1206 } 1207 } 1208 1209 static void 1210 connect(netif_t *netif) 1211 { 1212 if (!netif->xdev || 1213 !netif->attached || 1214 netif->frontend_state != XenbusStateConnected) { 1215 return; 1216 } 1217 1218 if (!connect_rings(netif)) { 1219 xenbus_switch_state(netif->xdev, NULL, XenbusStateConnected); 1220 1221 /* Turn on interface */ 1222 netif->ifp->if_drv_flags |= IFF_DRV_RUNNING; 1223 netif->ifp->if_flags |= IFF_UP; 1224 } 1225 } 1226 1227 static int 1228 netback_remove(struct xenbus_device *xdev) 1229 { 1230 netif_t *netif = xdev->data; 1231 device_t ndev; 1232 1233 DPRINTF("remove %s\n", xdev->nodename); 1234 1235 if ((ndev = netif->ndev)) { 1236 netif->ndev = NULL; 1237 mtx_lock(&Giant); 1238 device_detach(ndev); 1239 mtx_unlock(&Giant); 1240 } 1241 1242 xdev->data = NULL; 1243 netif->xdev = NULL; 1244 netif_put(netif); 1245 1246 return 0; 1247 } 1248 1249 /** 1250 * Entry point to this code when a new device is created. Allocate the basic 1251 * structures and the ring buffers for communication with the frontend. 1252 * Switch to Connected state. 1253 */ 1254 static int 1255 netback_probe(struct xenbus_device *xdev, const struct xenbus_device_id *id) 1256 { 1257 int err; 1258 long handle; 1259 char *bridge; 1260 1261 DPRINTF("node=%s\n", xdev->nodename); 1262 1263 /* Grab the handle */ 1264 err = xenbus_scanf(NULL, xdev->nodename, "handle", "%li", &handle); 1265 if (err != 1) { 1266 xenbus_dev_fatal(xdev, err, "reading handle"); 1267 return err; 1268 } 1269 1270 /* Check for bridge */ 1271 bridge = xenbus_read(NULL, xdev->nodename, "bridge", NULL); 1272 if (IS_ERR(bridge)) 1273 bridge = NULL; 1274 1275 err = xenbus_switch_state(xdev, NULL, XenbusStateInitWait); 1276 if (err) { 1277 xenbus_dev_fatal(xdev, err, "writing switch state"); 1278 return err; 1279 } 1280 1281 err = netif_create(handle, xdev, bridge); 1282 if (err) { 1283 xenbus_dev_fatal(xdev, err, "creating netif"); 1284 return err; 1285 } 1286 1287 err = vif_add_dev(xdev); 1288 if (err) { 1289 netif_put((netif_t *)xdev->data); 1290 xenbus_dev_fatal(xdev, err, "adding vif device"); 1291 return err; 1292 } 1293 1294 return 0; 1295 } 1296 1297 /** 1298 * We are reconnecting to the backend, due to a suspend/resume, or a backend 1299 * driver restart. We tear down our netif structure and recreate it, but 1300 * leave the device-layer structures intact so that this is transparent to the 1301 * rest of the kernel. 1302 */ 1303 static int netback_resume(struct xenbus_device *xdev) 1304 { 1305 DPRINTF("node=%s\n", xdev->nodename); 1306 return 0; 1307 } 1308 1309 1310 /** 1311 * Callback received when the frontend's state changes. 1312 */ 1313 static void frontend_changed(struct xenbus_device *xdev, 1314 XenbusState frontend_state) 1315 { 1316 netif_t *netif = xdev->data; 1317 1318 DPRINTF("state=%d\n", frontend_state); 1319 1320 netif->frontend_state = frontend_state; 1321 1322 switch (frontend_state) { 1323 case XenbusStateInitialising: 1324 case XenbusStateInitialised: 1325 break; 1326 case XenbusStateConnected: 1327 connect(netif); 1328 break; 1329 case XenbusStateClosing: 1330 xenbus_switch_state(xdev, NULL, XenbusStateClosing); 1331 break; 1332 case XenbusStateClosed: 1333 xenbus_remove_device(xdev); 1334 break; 1335 case XenbusStateUnknown: 1336 case XenbusStateInitWait: 1337 xenbus_dev_fatal(xdev, EINVAL, "saw state %d at frontend", 1338 frontend_state); 1339 break; 1340 } 1341 } 1342 1343 /* ** Driver registration ** */ 1344 1345 static struct xenbus_device_id netback_ids[] = { 1346 { "vif" }, 1347 { "" } 1348 }; 1349 1350 static struct xenbus_driver netback = { 1351 .name = "netback", 1352 .ids = netback_ids, 1353 .probe = netback_probe, 1354 .remove = netback_remove, 1355 .resume= netback_resume, 1356 .otherend_changed = frontend_changed, 1357 }; 1358 1359 static void 1360 netback_init(void *unused) 1361 { 1362 callout_init(&rx_task_callout, CALLOUT_MPSAFE); 1363 1364 mmap_vstart = alloc_empty_page_range(MAX_PENDING_REQS); 1365 BUG_ON(!mmap_vstart); 1366 1367 pending_cons = 0; 1368 for (pending_prod = 0; pending_prod < MAX_PENDING_REQS; pending_prod++) 1369 pending_ring[pending_prod] = pending_prod; 1370 1371 TASK_INIT(&net_tx_task, 0, net_tx_action, NULL); 1372 TASK_INIT(&net_rx_task, 0, net_rx_action, NULL); 1373 mtx_init(&tx_sched_list_lock, "nb_tx_sched_lock", "netback tx sched lock", MTX_DEF); 1374 mtx_init(&rx_sched_list_lock, "nb_rx_sched_lock", "netback rx sched lock", MTX_DEF); 1375 1376 DPRINTF("registering %s\n", netback.name); 1377 1378 xenbus_register_backend(&netback); 1379 } 1380 1381 SYSINIT(xnbedev, SI_SUB_PSEUDO, SI_ORDER_ANY, netback_init, NULL) 1382 1383 static int 1384 vif_add_dev(struct xenbus_device *xdev) 1385 { 1386 netif_t *netif = xdev->data; 1387 device_t nexus, ndev; 1388 devclass_t dc; 1389 int err = 0; 1390 1391 mtx_lock(&Giant); 1392 1393 /* We will add a vif device as a child of nexus0 (for now) */ 1394 if (!(dc = devclass_find("nexus")) || 1395 !(nexus = devclass_get_device(dc, 0))) { 1396 WPRINTF("could not find nexus0!\n"); 1397 err = ENOENT; 1398 goto done; 1399 } 1400 1401 1402 /* Create a newbus device representing the vif */ 1403 ndev = BUS_ADD_CHILD(nexus, 0, "vif", netif->ifp->if_dunit); 1404 if (!ndev) { 1405 WPRINTF("could not create newbus device %s!\n", IFNAME(netif)); 1406 err = EFAULT; 1407 goto done; 1408 } 1409 1410 netif_get(netif); 1411 device_set_ivars(ndev, netif); 1412 netif->ndev = ndev; 1413 1414 device_probe_and_attach(ndev); 1415 1416 done: 1417 1418 mtx_unlock(&Giant); 1419 1420 return err; 1421 } 1422 1423 enum { 1424 VIF_SYSCTL_DOMID, 1425 VIF_SYSCTL_HANDLE, 1426 VIF_SYSCTL_TXRING, 1427 VIF_SYSCTL_RXRING, 1428 }; 1429 1430 static char * 1431 vif_sysctl_ring_info(netif_t *netif, int cmd) 1432 { 1433 char *buf = malloc(256, M_DEVBUF, M_WAITOK); 1434 if (buf) { 1435 if (!netif->rings_connected) 1436 sprintf(buf, "rings not connected\n"); 1437 else if (cmd == VIF_SYSCTL_TXRING) { 1438 netif_tx_back_ring_t *tx = &netif->tx; 1439 sprintf(buf, "nr_ents=%x req_cons=%x" 1440 " req_prod=%x req_event=%x" 1441 " rsp_prod=%x rsp_event=%x", 1442 tx->nr_ents, tx->req_cons, 1443 tx->sring->req_prod, tx->sring->req_event, 1444 tx->sring->rsp_prod, tx->sring->rsp_event); 1445 } else { 1446 netif_rx_back_ring_t *rx = &netif->rx; 1447 sprintf(buf, "nr_ents=%x req_cons=%x" 1448 " req_prod=%x req_event=%x" 1449 " rsp_prod=%x rsp_event=%x", 1450 rx->nr_ents, rx->req_cons, 1451 rx->sring->req_prod, rx->sring->req_event, 1452 rx->sring->rsp_prod, rx->sring->rsp_event); 1453 } 1454 } 1455 return buf; 1456 } 1457 1458 static int 1459 vif_sysctl_handler(SYSCTL_HANDLER_ARGS) 1460 { 1461 device_t dev = (device_t)arg1; 1462 netif_t *netif = (netif_t *)device_get_ivars(dev); 1463 const char *value; 1464 char *buf = NULL; 1465 int err; 1466 1467 switch (arg2) { 1468 case VIF_SYSCTL_DOMID: 1469 return sysctl_handle_int(oidp, NULL, netif->domid, req); 1470 case VIF_SYSCTL_HANDLE: 1471 return sysctl_handle_int(oidp, NULL, netif->handle, req); 1472 case VIF_SYSCTL_TXRING: 1473 case VIF_SYSCTL_RXRING: 1474 value = buf = vif_sysctl_ring_info(netif, arg2); 1475 break; 1476 default: 1477 return (EINVAL); 1478 } 1479 1480 err = SYSCTL_OUT(req, value, strlen(value)); 1481 if (buf != NULL) 1482 free(buf, M_DEVBUF); 1483 1484 return err; 1485 } 1486 1487 /* Newbus vif device driver probe */ 1488 static int 1489 vif_probe(device_t dev) 1490 { 1491 DDPRINTF("vif%d\n", device_get_unit(dev)); 1492 return 0; 1493 } 1494 1495 /* Newbus vif device driver attach */ 1496 static int 1497 vif_attach(device_t dev) 1498 { 1499 netif_t *netif = (netif_t *)device_get_ivars(dev); 1500 uint8_t mac[ETHER_ADDR_LEN]; 1501 1502 DDPRINTF("%s\n", IFNAME(netif)); 1503 1504 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 1505 OID_AUTO, "domid", CTLTYPE_INT|CTLFLAG_RD, 1506 dev, VIF_SYSCTL_DOMID, vif_sysctl_handler, "I", 1507 "domid of frontend"); 1508 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 1509 OID_AUTO, "handle", CTLTYPE_INT|CTLFLAG_RD, 1510 dev, VIF_SYSCTL_HANDLE, vif_sysctl_handler, "I", 1511 "handle of frontend"); 1512 #ifdef XEN_NETBACK_DEBUG 1513 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 1514 OID_AUTO, "txring", CTLFLAG_RD, 1515 dev, VIF_SYSCTL_TXRING, vif_sysctl_handler, "A", 1516 "tx ring info"); 1517 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 1518 OID_AUTO, "rxring", CTLFLAG_RD, 1519 dev, VIF_SYSCTL_RXRING, vif_sysctl_handler, "A", 1520 "rx ring info"); 1521 #endif 1522 1523 memset(mac, 0xff, sizeof(mac)); 1524 mac[0] &= ~0x01; 1525 1526 ether_ifattach(netif->ifp, mac); 1527 netif->attached = 1; 1528 1529 connect(netif); 1530 1531 if (netif->bridge) { 1532 DPRINTF("Adding %s to bridge %s\n", IFNAME(netif), netif->bridge); 1533 int err = add_to_bridge(netif->ifp, netif->bridge); 1534 if (err) { 1535 WPRINTF("Error adding %s to %s; err=%d\n", 1536 IFNAME(netif), netif->bridge, err); 1537 } 1538 } 1539 1540 return bus_generic_attach(dev); 1541 } 1542 1543 /* Newbus vif device driver detach */ 1544 static int 1545 vif_detach(device_t dev) 1546 { 1547 netif_t *netif = (netif_t *)device_get_ivars(dev); 1548 struct ifnet *ifp = netif->ifp; 1549 1550 DDPRINTF("%s\n", IFNAME(netif)); 1551 1552 /* Tell the stack that the interface is no longer active */ 1553 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 1554 1555 ether_ifdetach(ifp); 1556 1557 bus_generic_detach(dev); 1558 1559 netif->attached = 0; 1560 1561 netif_put(netif); 1562 1563 return 0; 1564 } 1565 1566 static device_method_t vif_methods[] = { 1567 /* Device interface */ 1568 DEVMETHOD(device_probe, vif_probe), 1569 DEVMETHOD(device_attach, vif_attach), 1570 DEVMETHOD(device_detach, vif_detach), 1571 DEVMETHOD(device_shutdown, bus_generic_shutdown), 1572 DEVMETHOD(device_suspend, bus_generic_suspend), 1573 DEVMETHOD(device_resume, bus_generic_resume), 1574 {0, 0} 1575 }; 1576 1577 static devclass_t vif_devclass; 1578 1579 static driver_t vif_driver = { 1580 "vif", 1581 vif_methods, 1582 0, 1583 }; 1584 1585 DRIVER_MODULE(vif, nexus, vif_driver, vif_devclass, 0, 0); 1586 1587 1588 /* 1589 * Local variables: 1590 * mode: C 1591 * c-set-style: "BSD" 1592 * c-basic-offset: 4 1593 * tab-width: 4 1594 * indent-tabs-mode: t 1595 * End: 1596 */ 1597