 @@ -1,41 +1,41 @@
-/*      $NetBSD: xennetback_xenbus.c,v 1.71 2018/10/26 05:33:21 cherry Exp $      */
+/*      $NetBSD: xennetback_xenbus.c,v 1.72 2018/12/23 12:09:45 bouyer Exp $      */
 /*
  * Copyright (c) 2006 Manuel Bouyer.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: xennetback_xenbus.c,v 1.71 2018/10/26 05:33:21 cherry Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xennetback_xenbus.c,v 1.72 2018/12/23 12:09:45 bouyer Exp $");
 #include "opt_xen.h"
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/kmem.h>
 #include <sys/queue.h>
 #include <sys/kernel.h>
 #include <sys/mbuf.h>
 #include <sys/protosw.h>
 #include <sys/socket.h>
 @@ -1205,135 +1205,156 @@ xennetback_ifsoftstart_transfer(void *ar
 		 * note that we don't use RING_FINAL_CHECK_FOR_REQUESTS()
 		 * here, as the frontend doesn't notify when adding
 		 * requests anyway
 		 */
 		if (__predict_false(
 		    !RING_HAS_UNCONSUMED_REQUESTS(&xneti->xni_rxring))) {
 			/* ring full */
 			break;
+		}
+	}
 	splx(s);
+}
 /*
  * sighly different from m_dup(); for some reason m_dup() can return
  * a chain where the data area can cross a page boundary.
  * This doesn't happens with the function below.
  */
 static struct mbuf *
 xennetback_copymbuf(struct mbuf *m)
+{
 	struct mbuf *new_m;
 	MGETHDR(new_m, M_DONTWAIT, MT_DATA);
 	if (__predict_false(new_m == NULL)) {
 		return NULL;
+	}
 	if (m->m_pkthdr.len > MHLEN) {
 		MCLGET(new_m, M_DONTWAIT);
 		if (__predict_false(
 		    (new_m->m_flags & M_EXT) == 0)) {
 			m_freem(new_m);
 			return NULL;
+		}
+	}
 	m_copydata(m, 0, m->m_pkthdr.len,
 	    mtod(new_m, void *));
 	new_m->m_len = new_m->m_pkthdr.len =
 	    m->m_pkthdr.len;
 	return new_m;
+}
 /* return physical page address and offset of data area of an mbuf */
 static void
 xennetback_mbuf_addr(struct mbuf *m, paddr_t *xmit_pa, int *offset)
+{
 	switch (m->m_flags & (M_EXT|M_EXT_CLUSTER)) {
 	case M_EXT|M_EXT_CLUSTER:
 		KASSERT(m->m_ext.ext_paddr != M_PADDR_INVALID);
 		*xmit_pa = m->m_ext.ext_paddr;
 		*offset = m->m_data - m->m_ext.ext_buf;
 		break;
 	case 0:
 		KASSERT(m->m_paddr != M_PADDR_INVALID);
 		*xmit_pa = m->m_paddr;
 		*offset = M_BUFOFFSET(m) +
 		    (m->m_data - M_BUFADDR(m));
 		break;
 	default:
 		if (__predict_false(
 		    !pmap_extract(pmap_kernel(),
 		    (vaddr_t)m->m_data, xmit_pa))) {
 			panic("xennet_start: no pa");
+		}
 		*offset = 0;
 		break;
+	}
 	*offset += (*xmit_pa & ~PG_FRAME);
 	*xmit_pa = (*xmit_pa & PG_FRAME);
+}
 static void
 xennetback_ifsoftstart_copy(void *arg)
+{
 	struct xnetback_instance *xneti = arg;
 	struct ifnet *ifp = &xneti->xni_if;
 	struct mbuf *m, *new_m;
 	paddr_t xmit_pa;
 	paddr_t xmit_ma;
 	int i, j;
 	netif_rx_response_t *rxresp;
 	netif_rx_request_t rxreq;
 	RING_IDX req_prod, resp_prod;
 	int do_event = 0;
 	gnttab_copy_t *gop;
 	int id, offset;
 	bool abort;
 	XENPRINTF(("xennetback_ifsoftstart_copy "));
 	int s = splnet();
 	if (__predict_false(
 	    (ifp->if_flags & (IFF_RUNNING|IFF_OACTIVE)) != IFF_RUNNING)) {
 		splx(s);
 		return;
+	}
 	while (!IFQ_IS_EMPTY(&ifp->if_snd)) {
 		XENPRINTF(("pkt\n"));
 		req_prod = xneti->xni_rxring.sring->req_prod;
 		resp_prod = xneti->xni_rxring.rsp_prod_pvt;
 		xen_rmb();
 		gop = xstart_gop_copy;
 		abort = false;
 		for (i = 0; !IFQ_IS_EMPTY(&ifp->if_snd);) {
 			XENPRINTF(("have a packet\n"));
 			IFQ_POLL(&ifp->if_snd, m);
 			if (__predict_false(m == NULL))
 				panic("xennetback_ifstart: IFQ_POLL");
 			if (__predict_false(
 			    req_prod == xneti->xni_rxring.req_cons ||
 			    xneti->xni_rxring.req_cons - resp_prod ==
 			    NET_RX_RING_SIZE)) {
 				/* out of ring space */
 				XENPRINTF(("xennetback_ifstart: ring full "
 				    "req_prod 0x%x req_cons 0x%x resp_prod "
 				    "0x%x\n",
 				    req_prod, xneti->xni_rxring.req_cons,
 				    resp_prod));
-				ifp->if_timer = 1;
+				abort = true;
 				break;
+			}
 			if (__predict_false(i == NB_XMIT_PAGES_BATCH))
 				break; /* we filled the array */
 			switch (m->m_flags & (M_EXT|M_EXT_CLUSTER)) {
-			case M_EXT|M_EXT_CLUSTER:
+			xennetback_mbuf_addr(m, &xmit_pa, &offset);
 				KASSERT(m->m_ext.ext_paddr != M_PADDR_INVALID);
 				xmit_pa = m->m_ext.ext_paddr;
 				offset = m->m_data - m->m_ext.ext_buf;
 				break;
 			case 0:
 				KASSERT(m->m_paddr != M_PADDR_INVALID);
 				xmit_pa = m->m_paddr;
 				offset = M_BUFOFFSET(m) +
 				    (m->m_data - M_BUFADDR(m));
 				break;
 			default:
 				if (__predict_false(
 				    !pmap_extract(pmap_kernel(),
 				    (vaddr_t)m->m_data, &xmit_pa))) {
 					panic("xennet_start: no pa");
 				offset = 0;
 				break;
 			offset += (xmit_pa & ~PG_FRAME);
 			xmit_pa = (xmit_pa & PG_FRAME);
 			if (m->m_pkthdr.len != m->m_len ||
 			    (offset + m->m_pkthdr.len) > PAGE_SIZE) {
-				MGETHDR(new_m, M_DONTWAIT, MT_DATA);
+				new_m = xennetback_copymbuf(m);
 				if (__predict_false(new_m == NULL)) {
-					printf("%s: cannot allocate new mbuf\n",
+					static struct timeval lasttime;
-					    ifp->if_xname);
+					if (ratecheck(&lasttime, &xni_pool_errintvl))
 						printf("%s: cannot allocate new mbuf\n",
 						    ifp->if_xname);
 					abort = 1;
 					break;
 				if (m->m_pkthdr.len > MHLEN) {
 					MCLGET(new_m, M_DONTWAIT);
 					if (__predict_false(
 					    (new_m->m_flags & M_EXT) == 0)) {
 						XENPRINTF((
 						    "%s: no mbuf cluster\n",
 						    ifp->if_xname));
 						m_freem(new_m);
 						break;
 					xmit_pa = new_m->m_ext.ext_paddr;
 					offset = new_m->m_data -
 					    new_m->m_ext.ext_buf;
 				} else {
-					xmit_pa = new_m->m_paddr;
+					IFQ_DEQUEUE(&ifp->if_snd, m);
-					offset = M_BUFOFFSET(new_m) +
+					m_freem(m);
-					    (new_m->m_data - M_BUFADDR(new_m));
+					m = new_m;
 					xennetback_mbuf_addr(m,
 					    &xmit_pa, &offset);
+				}
 				offset += (xmit_pa & ~PG_FRAME);
 				xmit_pa = (xmit_pa & PG_FRAME);
 				m_copydata(m, 0, m->m_pkthdr.len,
 				    mtod(new_m, void *));
 				new_m->m_len = new_m->m_pkthdr.len =
 				    m->m_pkthdr.len;
 				IFQ_DEQUEUE(&ifp->if_snd, m);
 				m_freem(m);
 				m = new_m;
 			} else {
 				IFQ_DEQUEUE(&ifp->if_snd, m);
+			}
 			KASSERT(xmit_pa != POOL_PADDR_INVALID);
 			KASSERT((offset + m->m_pkthdr.len) <= PAGE_SIZE);
 			xmit_ma = xpmap_ptom(xmit_pa);
 			/* start filling ring */
 			gop->flags = GNTCOPY_dest_gref;
 			gop->source.offset = offset;
 			gop->source.domid = DOMID_SELF;
 			gop->source.u.gmfn = xmit_ma >> PAGE_SHIFT;
 @@ -1411,29 +1432,30 @@ xennetback_ifsoftstart_copy(void *arg)
 		/* send event */
 		if (do_event) {
 			xen_rmb();
 			XENPRINTF(("%s receive event\n",
 			    xneti->xni_if.if_xname));
 			hypervisor_notify_via_evtchn(xneti->xni_evtchn);
 			do_event = 0;
+		}
 		/*
 		 * note that we don't use RING_FINAL_CHECK_FOR_REQUESTS()
 		 * here, as the frontend doesn't notify when adding
 		 * requests anyway
 		 */
-		if (__predict_false(
+		if (__predict_false(abort ||
 		    !RING_HAS_UNCONSUMED_REQUESTS(&xneti->xni_rxring))) {
 			/* ring full */
 			ifp->if_timer = 1;
 			break;
+		}
+	}
 	splx(s);
+}
 static void
 xennetback_ifwatchdog(struct ifnet * ifp)
+{
 	/*
 	 * We can get to the following condition: transmit stalls because the
 	 * ring is full when the ifq is full too.
+	 *