 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_vioif.c,v 1.81 2022/05/04 02:38:27 simonb Exp $	*/
+/*	$NetBSD: if_vioif.c,v 1.82 2022/09/12 07:26:04 knakahara Exp $	*/
 /*
  * Copyright (c) 2020 The NetBSD Foundation, Inc.
  * Copyright (c) 2010 Minoura Makoto.
  * All rights reserved.
+ *
  * 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
 @@ -17,27 +17,27 @@
  * 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: if_vioif.c,v 1.81 2022/05/04 02:38:27 simonb Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_vioif.c,v 1.82 2022/09/12 07:26:04 knakahara Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_net_mpsafe.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/bus.h>
 #include <sys/condvar.h>
 #include <sys/device.h>
 #include <sys/evcnt.h>
 @@ -309,27 +309,27 @@ struct vioif_softc {
 	kmutex_t		sc_lock;
 	struct sysctllog	*sc_sysctllog;
 	struct virtio_softc	*sc_virtio;
 	struct virtqueue	*sc_vqs;
 	u_int			 sc_hdr_size;
 	int			sc_max_nvq_pairs;
 	int			sc_req_nvq_pairs;
 	int			sc_act_nvq_pairs;
 	uint8_t			sc_mac[ETHER_ADDR_LEN];
 	struct ethercom		sc_ethercom;
-	bool			sc_link_active;
+	int			sc_link_state;
 	struct vioif_txqueue	*sc_txq;
 	struct vioif_rxqueue	*sc_rxq;
 	bool			sc_has_ctrl;
 	struct vioif_ctrlqueue	sc_ctrlq;
 	bus_dma_segment_t	sc_hdr_segs[1];
 	void			*sc_dmamem;
 	void			*sc_kmem;
 	void			*sc_ctl_softint;
 @@ -339,26 +339,28 @@ struct vioif_softc {
 	u_int			 sc_tx_process_limit;
 	u_int			 sc_rx_intr_process_limit;
 	u_int			 sc_rx_process_limit;
 };
 #define VIRTIO_NET_TX_MAXNSEGS		(16) /* XXX */
 #define VIRTIO_NET_CTRL_MAC_MAXENTRIES	(64) /* XXX */
 #define VIOIF_TX_INTR_PROCESS_LIMIT	256
 #define VIOIF_TX_PROCESS_LIMIT		256
 #define VIOIF_RX_INTR_PROCESS_LIMIT	0U
 #define VIOIF_RX_PROCESS_LIMIT		256
 #define VIOIF_WORKQUEUE_PRI		PRI_SOFTNET
 #define VIOIF_IS_LINK_ACTIVE(_sc)	((_sc)->sc_link_state == LINK_STATE_UP ? \
 					    true : false)
 /* cfattach interface functions */
 static int	vioif_match(device_t, cfdata_t, void *);
 static void	vioif_attach(device_t, device_t, void *);
 static int	vioif_finalize_teardown(device_t);
 /* ifnet interface functions */
 static int	vioif_init(struct ifnet *);
 static void	vioif_stop(struct ifnet *, int);
 static void	vioif_start(struct ifnet *);
 static void	vioif_start_locked(struct ifnet *, struct vioif_txqueue *);
 static int	vioif_transmit(struct ifnet *, struct mbuf *);
 static void	vioif_transmit_locked(struct ifnet *, struct vioif_txqueue *);
 @@ -391,27 +393,27 @@ static bool	vioif_tx_deq_locked(struct v
 static void	vioif_tx_drain(struct vioif_txqueue *);
 static void	vioif_deferred_transmit(void *);
 /* workqueue */
 static struct workqueue*
 		vioif_workq_create(const char *, pri_t, int, int);
 static void	vioif_workq_destroy(struct workqueue *);
 static void	vioif_workq_work(struct work *, void *);
 static void	vioif_work_set(struct vioif_work *, void(*)(void *), void *);
 static void	vioif_work_add(struct workqueue *, struct vioif_work *);
 static void	vioif_work_wait(struct workqueue *, struct vioif_work *);
 /* other control */
-static bool	vioif_is_link_up(struct vioif_softc *);
+static int	vioif_get_link_status(struct vioif_softc *);
 static void	vioif_update_link_status(struct vioif_softc *);
 static int	vioif_ctrl_rx(struct vioif_softc *, int, bool);
 static int	vioif_set_promisc(struct vioif_softc *, bool);
 static int	vioif_set_allmulti(struct vioif_softc *, bool);
 static int	vioif_set_rx_filter(struct vioif_softc *);
 static int	vioif_rx_filter(struct vioif_softc *);
 static int	vioif_set_mac_addr(struct vioif_softc *);
 static int	vioif_ctrl_intr(void *);
 static int	vioif_config_change(struct virtio_softc *);
 static void	vioif_ctl_softint(void *);
 static int	vioif_ctrl_mq_vq_pairs_set(struct vioif_softc *, int);
 static void	vioif_enable_interrupt_vqpairs(struct vioif_softc *);
 static void	vioif_disable_interrupt_vqpairs(struct vioif_softc *);
 @@ -820,27 +822,27 @@ vioif_attach(device_t parent, device_t s
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	u_int softint_flags;
 	int r, i, nvqs = 0, req_flags;
 	char xnamebuf[MAXCOMLEN];
 	if (virtio_child(vsc) != NULL) {
 		aprint_normal(": child already attached for %s; "
 		    "something wrong...\n", device_xname(parent));
 		return;
+	}
 	sc->sc_dev = self;
 	sc->sc_virtio = vsc;
-	sc->sc_link_active = false;
+	sc->sc_link_state = LINK_STATE_UNKNOWN;
 	sc->sc_max_nvq_pairs = 1;
 	sc->sc_req_nvq_pairs = 1;
 	sc->sc_act_nvq_pairs = 1;
 	sc->sc_txrx_workqueue_sysctl = true;
 	sc->sc_tx_intr_process_limit = VIOIF_TX_INTR_PROCESS_LIMIT;
 	sc->sc_tx_process_limit = VIOIF_TX_PROCESS_LIMIT;
 	sc->sc_rx_intr_process_limit = VIOIF_RX_INTR_PROCESS_LIMIT;
 	sc->sc_rx_process_limit = VIOIF_RX_PROCESS_LIMIT;
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
 	snprintf(xnamebuf, sizeof(xnamebuf), "%s_txrx", device_xname(self));
 @@ -973,27 +975,27 @@ vioif_attach(device_t parent, device_t s
 			aprint_error_dev(self, "cannot establish tx softint\n");
 			goto err;
+		}
 		snprintf(qname, sizeof(qname), "tx%d", i);
 		r = virtio_alloc_vq(vsc, txq->txq_vq, nvqs,
 		    sc->sc_hdr_size + (ETHER_MAX_LEN - ETHER_HDR_LEN),
 		    VIRTIO_NET_TX_MAXNSEGS + 1, qname);
 		if (r != 0)
 			goto err;
 		nvqs++;
 		txq->txq_vq->vq_intrhand = vioif_tx_intr;
 		txq->txq_vq->vq_intrhand_arg = (void *)txq;
-		txq->txq_link_active = sc->sc_link_active;
+		txq->txq_link_active = VIOIF_IS_LINK_ACTIVE(sc);
 		txq->txq_stopping = false;
 		txq->txq_intrq = pcq_create(txq->txq_vq->vq_num, KM_SLEEP);
 		vioif_work_set(&txq->txq_work, vioif_tx_handle, txq);
+	}
 	if (sc->sc_has_ctrl) {
 		/*
 		 * Allocating a virtqueue for control channel
 		 */
 		r = virtio_alloc_vq(vsc, ctrlq->ctrlq_vq, nvqs,
 		    NBPG, 1, "control");
 		if (r != 0) {
 			aprint_error_dev(self, "failed to allocate "
 @@ -1247,34 +1249,31 @@ vioif_stop(struct ifnet *ifp, int disabl
 		mutex_exit(txq->txq_lock);
 		vioif_work_wait(sc->sc_txrx_workqueue, &txq->txq_work);
+	}
 	/* only way to stop I/O and DMA is resetting... */
 	virtio_reset(vsc);
 	for (i = 0; i < sc->sc_act_nvq_pairs; i++) {
 		vioif_rx_queue_clear(&sc->sc_rxq[i]);
 		vioif_tx_queue_clear(&sc->sc_txq[i]);
+	}
 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 	sc->sc_link_active = false;
 	for (i = 0; i < sc->sc_act_nvq_pairs; i++) {
 		txq = &sc->sc_txq[i];
 		rxq = &sc->sc_rxq[i];
 		txq->txq_link_active = false;
 		if (disable)
 			vioif_rx_drain(rxq);
 		vioif_tx_drain(txq);
+	}
+}
 static void
 vioif_send_common_locked(struct ifnet *ifp, struct vioif_txqueue *txq,
     bool is_transmit)
+{
 	struct vioif_softc *sc = ifp->if_softc;
 	struct virtio_softc *vsc = sc->sc_virtio;
 @@ -2383,81 +2382,74 @@ vioif_rx_filter(struct vioif_softc *sc)
 			    ifp->if_xname);
 			/* what to do on failure? */
+		}
 		ifp->if_flags |= IFF_ALLMULTI;
+	}
 set_ifflags:
 	r = vioif_ifflags(sc);
 	return r;
+}
-static bool
+static int
-vioif_is_link_up(struct vioif_softc *sc)
+vioif_get_link_status(struct vioif_softc *sc)
+{
 	struct virtio_softc *vsc = sc->sc_virtio;
 	uint16_t status;
 	if (virtio_features(vsc) & VIRTIO_NET_F_STATUS)
 		status = virtio_read_device_config_2(vsc,
 		    VIRTIO_NET_CONFIG_STATUS);
 	else
 		status = VIRTIO_NET_S_LINK_UP;
-	return ((status & VIRTIO_NET_S_LINK_UP) != 0);
+	if ((status & VIRTIO_NET_S_LINK_UP) != 0)
 		return LINK_STATE_UP;
 	return LINK_STATE_DOWN;
+}
 /* change link status */
 static void
 vioif_update_link_status(struct vioif_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct vioif_txqueue *txq;
-	bool active, changed;
+	bool active;
 	int link, i;
 	mutex_enter(&sc->sc_lock);
-	active = vioif_is_link_up(sc);
+	link = vioif_get_link_status(sc);
 	changed = false;
-	if (active) {
+	if (link == sc->sc_link_state)
-		if (!sc->sc_link_active)
+		goto done;
 			changed = true;
-		link = LINK_STATE_UP;
+	sc->sc_link_state = link;
 		sc->sc_link_active = true;
 	} else {
 		if (sc->sc_link_active)
 			changed = true;
 		link = LINK_STATE_DOWN;
 		sc->sc_link_active = false;
-	if (changed) {
+	active = VIOIF_IS_LINK_ACTIVE(sc);
-		for (i = 0; i < sc->sc_act_nvq_pairs; i++) {
+	for (i = 0; i < sc->sc_act_nvq_pairs; i++) {
-			txq = &sc->sc_txq[i];
+		txq = &sc->sc_txq[i];
 			mutex_enter(txq->txq_lock);
 			txq->txq_link_active = sc->sc_link_active;
 			mutex_exit(txq->txq_lock);
-		if_link_state_change(ifp, link);
+		mutex_enter(txq->txq_lock);
 		txq->txq_link_active = active;
 		mutex_exit(txq->txq_lock);
+	}
 	if_link_state_change(ifp, sc->sc_link_state);
 done:
 	mutex_exit(&sc->sc_lock);
+}
 static int
 vioif_config_change(struct virtio_softc *vsc)
+{
 	struct vioif_softc *sc = device_private(virtio_child(vsc));
 	softint_schedule(sc->sc_ctl_softint);
 	return 0;
+}
 static void