 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_vioif.c,v 1.102 2023/03/23 03:02:17 yamaguchi Exp $	*/
+/*	$NetBSD: if_vioif.c,v 1.103 2023/03/23 03:27:48 yamaguchi 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.102 2023/03/23 03:02:17 yamaguchi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_vioif.c,v 1.103 2023/03/23 03:27:48 yamaguchi 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>
 @@ -455,27 +455,27 @@ vioif_match(device_t parent, cfdata_t ma
 static void
 vioif_attach(device_t parent, device_t self, void *aux)
+{
 	struct vioif_softc *sc = device_private(self);
 	struct virtio_softc *vsc = device_private(parent);
 	struct vioif_netqueue *txq0;
 	struct vioif_ctrlqueue *ctrlq = &sc->sc_ctrlq;
 	uint64_t features, req_features;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	u_int softint_flags;
 	int r, i, req_flags;
 	char xnamebuf[MAXCOMLEN];
-	size_t netq_num;
+	size_t nvqs;
 	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_state = LINK_STATE_UNKNOWN;
 	sc->sc_max_nvq_pairs = 1;
 	sc->sc_req_nvq_pairs = 1;
 @@ -499,31 +499,31 @@ vioif_attach(device_t parent, device_t s
 #ifdef VIOIF_MPSAFE
 	req_flags |= VIRTIO_F_INTR_MPSAFE;
 #endif
 	req_flags |= VIRTIO_F_INTR_MSIX;
 	req_features =
 	    VIRTIO_NET_F_MAC | VIRTIO_NET_F_STATUS | VIRTIO_NET_F_CTRL_VQ |
 	    VIRTIO_NET_F_CTRL_RX | VIRTIO_F_NOTIFY_ON_EMPTY;
 	req_features |= VIRTIO_F_RING_EVENT_IDX;
 	req_features |= VIRTIO_NET_F_CTRL_MAC_ADDR;
 #ifdef VIOIF_MULTIQ
 	req_features |= VIRTIO_NET_F_MQ;
 #endif
 	virtio_child_attach_start(vsc, self, IPL_NET, NULL,
 	    vioif_config_change, virtio_vq_intrhand, req_flags,
 	    req_features, VIRTIO_NET_FLAG_BITS);
 	virtio_child_attach_start(vsc, self, IPL_NET,
 	    req_features, VIRTIO_NET_FLAG_BITS);
 	features = virtio_features(vsc);
 	if (features == 0)
 		goto err;
 	if (features & VIRTIO_NET_F_MAC) {
 		for (i = 0; i < __arraycount(sc->sc_mac); i++) {
 			sc->sc_mac[i] = virtio_read_device_config_1(vsc,
 			    VIRTIO_NET_CONFIG_MAC + i);
+		}
 	} else {
 		/* code stolen from sys/net/if_tap.c */
 		struct timeval tv;
 		uint32_t ui;
 		getmicrouptime(&tv);
 @@ -555,49 +555,53 @@ vioif_attach(device_t parent, device_t s
 	} else {
 		sc->sc_has_ctrl = false;
+	}
 	if (sc->sc_has_ctrl && (features & VIRTIO_NET_F_MQ)) {
 		sc->sc_max_nvq_pairs = virtio_read_device_config_2(vsc,
 		    VIRTIO_NET_CONFIG_MAX_VQ_PAIRS);
 		if (sc->sc_max_nvq_pairs > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX)
 			goto err;
 		/* Limit the number of queue pairs to use */
 		sc->sc_req_nvq_pairs = MIN(sc->sc_max_nvq_pairs, ncpu);
 		if (sc->sc_max_nvq_pairs > 1)
 			req_flags |= VIRTIO_F_INTR_PERVQ;
+	}
 	vioif_alloc_queues(sc);
 	virtio_child_attach_set_vqs(vsc, sc->sc_vqs, sc->sc_req_nvq_pairs);
 #ifdef VIOIF_MPSAFE
 	softint_flags = SOFTINT_NET | SOFTINT_MPSAFE;
 #else
 	softint_flags = SOFTINT_NET;
 #endif
 	/*
 	 * Initialize network queues
 	 */
-	netq_num = sc->sc_max_nvq_pairs * 2;
+	nvqs = sc->sc_max_nvq_pairs * 2;
-	for (i = 0; i < netq_num; i++) {
+	for (i = 0; i < nvqs; i++) {
 		r = vioif_netqueue_init(sc, vsc, i, softint_flags);
 		if (r != 0)
 			goto err;
+	}
 	if (sc->sc_has_ctrl) {
-		int ctrlq_idx = sc->sc_max_nvq_pairs * 2;
+		int ctrlq_idx = nvqs;
 		nvqs++;
 		/*
 		 * Allocating a virtqueue for control channel
 		 */
 		sc->sc_ctrlq.ctrlq_vq = &sc->sc_vqs[ctrlq_idx];
 		r = virtio_alloc_vq(vsc, ctrlq->ctrlq_vq, ctrlq_idx,
 		    NBPG, 1, "control");
 		if (r != 0) {
 			aprint_error_dev(self, "failed to allocate "
 			    "a virtqueue for control channel, error code %d\n",
 			    r);
 			sc->sc_has_ctrl = false;
 			cv_destroy(&ctrlq->ctrlq_wait);
 @@ -608,27 +612,29 @@ vioif_attach(device_t parent, device_t s
+		}
+	}
 	sc->sc_cfg_softint = softint_establish(softint_flags,
 	    vioif_cfg_softint, sc);
 	if (sc->sc_cfg_softint == NULL) {
 		aprint_error_dev(self, "cannot establish ctl softint\n");
 		goto err;
+	}
 	if (vioif_alloc_mems(sc) < 0)
 		goto err;
-	if (virtio_child_attach_finish(vsc) != 0)
+	r = virtio_child_attach_finish(vsc, sc->sc_vqs, nvqs,
 	    vioif_config_change, virtio_vq_intrhand, req_flags);
 	if (r != 0)
 		goto err;
 	if (vioif_setup_sysctl(sc) != 0) {
 		aprint_error_dev(self, "unable to create sysctl node\n");
 		/* continue */
+	}
 	vioif_setup_stats(sc);
 	strlcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
 	ifp->if_softc = sc;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 #ifdef VIOIF_MPSAFE
 @@ -646,28 +652,28 @@ vioif_attach(device_t parent, device_t s
 	IFQ_SET_MAXLEN(&ifp->if_snd, MAX(txq0->netq_vq->vq_num, IFQ_MAXLEN));
 	IFQ_SET_READY(&ifp->if_snd);
 	sc->sc_ethercom.ec_capabilities |= ETHERCAP_VLAN_MTU;
 	if_attach(ifp);
 	if_deferred_start_init(ifp, NULL);
 	ether_ifattach(ifp, sc->sc_mac);
 	ether_set_ifflags_cb(&sc->sc_ethercom, vioif_ifflags_cb);
 	return;
 err:
-	netq_num = sc->sc_max_nvq_pairs * 2;
+	nvqs = sc->sc_max_nvq_pairs * 2;
-	for (i = 0; i < netq_num; i++) {
+	for (i = 0; i < nvqs; i++) {
 		vioif_netqueue_teardown(sc, vsc, i);
+	}
 	if (sc->sc_has_ctrl) {
 		cv_destroy(&ctrlq->ctrlq_wait);
 		mutex_destroy(&ctrlq->ctrlq_wait_lock);
 		virtio_free_vq(vsc, ctrlq->ctrlq_vq);
 		ctrlq->ctrlq_vq = NULL;
+	}
 	vioif_free_queues(sc);
 	mutex_destroy(&sc->sc_lock);
 	virtio_child_attach_failed(vsc);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ld_virtio.c,v 1.30 2022/04/13 10:42:12 uwe Exp $	*/
+/*	$NetBSD: ld_virtio.c,v 1.31 2023/03/23 03:27:48 yamaguchi Exp $	*/
 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
 @@ -16,27 +16,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: ld_virtio.c,v 1.30 2022/04/13 10:42:12 uwe Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ld_virtio.c,v 1.31 2023/03/23 03:27:48 yamaguchi Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/disk.h>
 #include <sys/mutex.h>
 #include <sys/module.h>
 #include <dev/ldvar.h>
 @@ -265,28 +265,27 @@ ld_virtio_attach(device_t parent, device
 	struct virtio_softc *vsc = device_private(parent);
 	uint64_t features;
 	int qsize, maxxfersize, maxnsegs;
 	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;
-	virtio_child_attach_start(vsc, self, IPL_BIO, &sc->sc_vq,
+	virtio_child_attach_start(vsc, self, IPL_BIO,
 	    NULL, virtio_vq_intr, VIRTIO_F_INTR_MSIX,
 	    (VIRTIO_BLK_F_SIZE_MAX | VIRTIO_BLK_F_SEG_MAX |
 	     VIRTIO_BLK_F_GEOMETRY | VIRTIO_BLK_F_RO | VIRTIO_BLK_F_BLK_SIZE |
 	     VIRTIO_BLK_F_FLUSH | VIRTIO_BLK_F_CONFIG_WCE),
 	    VIRTIO_BLK_FLAG_BITS);
 	features = virtio_features(vsc);
 	if (features == 0)
 		goto err;
 	if (features & VIRTIO_BLK_F_RO)
 		sc->sc_readonly = 1;
 	else
 		sc->sc_readonly = 0;
 @@ -330,27 +329,28 @@ ld_virtio_attach(device_t parent, device
 	} else
 		maxnsegs = maxxfersize / NBPG;
 	/* 2 for the minimum size */
 	maxnsegs += VIRTIO_BLK_MIN_SEGMENTS;
 	if (virtio_alloc_vq(vsc, &sc->sc_vq, 0, maxxfersize, maxnsegs,
 	    "I/O request") != 0) {
 		goto err;
+	}
 	qsize = sc->sc_vq.vq_num;
 	sc->sc_vq.vq_done = ld_virtio_vq_done;
-	if (virtio_child_attach_finish(vsc) != 0)
+	if (virtio_child_attach_finish(vsc, &sc->sc_vq, 1,
 	    NULL, virtio_vq_intr, VIRTIO_F_INTR_MSIX) != 0)
 		goto err;
 	ld->sc_dv = self;
 	ld->sc_secperunit = virtio_read_device_config_8(vsc,
 	    VIRTIO_BLK_CONFIG_CAPACITY) / (ld->sc_secsize / VIRTIO_BLK_BSIZE);
 	ld->sc_maxxfer = maxxfersize;
 	if (features & VIRTIO_BLK_F_GEOMETRY) {
 		ld->sc_ncylinders = virtio_read_device_config_2(vsc,
 					VIRTIO_BLK_CONFIG_GEOMETRY_C);
 		ld->sc_nheads     = virtio_read_device_config_1(vsc,
 					VIRTIO_BLK_CONFIG_GEOMETRY_H);
 		ld->sc_nsectors   = virtio_read_device_config_1(vsc,
 					VIRTIO_BLK_CONFIG_GEOMETRY_S);

 @@ -1,34 +1,34 @@
-/*	$NetBSD: vioscsi.c,v 1.30 2022/10/11 22:03:37 andvar Exp $	*/
+/*	$NetBSD: vioscsi.c,v 1.31 2023/03/23 03:27:48 yamaguchi Exp $	*/
 /*	$OpenBSD: vioscsi.c,v 1.3 2015/03/14 03:38:49 jsg Exp $	*/
 /*
  * Copyright (c) 2013 Google Inc.
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vioscsi.c,v 1.30 2022/10/11 22:03:37 andvar Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vioscsi.c,v 1.31 2023/03/23 03:27:48 yamaguchi Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/bus.h>
 #include <sys/buf.h>
 #include <sys/module.h>
 #include <dev/pci/vioscsireg.h>
 #include <dev/pci/virtiovar.h>
 #include <dev/scsipi/scsi_all.h>
 #include <dev/scsipi/scsiconf.h>
 @@ -118,28 +118,27 @@ vioscsi_attach(device_t parent, device_t
 	struct scsipi_adapter *adapt = &sc->sc_adapter;
 	struct scsipi_channel *chan = &sc->sc_channel;
 	int rv, qsize = 0, i = 0;
 	int ipl = IPL_BIO;
 	if (virtio_child(vsc) != NULL) {
 		aprint_error(": parent %s already has a child\n",
 		    device_xname(parent));
 		return;
+	}
 	sc->sc_dev = self;
-	virtio_child_attach_start(vsc, self, ipl, sc->sc_vqs,
+	virtio_child_attach_start(vsc, self, ipl,
 	    NULL, virtio_vq_intr, VIRTIO_F_INTR_MSIX,
 , VIRTIO_COMMON_FLAG_BITS);
 	mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, ipl);
 	uint32_t cmd_per_lun = virtio_read_device_config_4(vsc,
 	    VIRTIO_SCSI_CONFIG_CMD_PER_LUN);
 	uint32_t seg_max = virtio_read_device_config_4(vsc,
 	    VIRTIO_SCSI_CONFIG_SEG_MAX);
 	uint16_t max_target = virtio_read_device_config_2(vsc,
 	    VIRTIO_SCSI_CONFIG_MAX_TARGET);
 @@ -161,27 +160,29 @@ vioscsi_attach(device_t parent, device_t
 		if (i == VIOSCSI_VQ_REQUEST)
 			sc->sc_vqs[i].vq_done = vioscsi_vq_done;
+	}
 	qsize = sc->sc_vqs[VIOSCSI_VQ_REQUEST].vq_num;
 	if (vioscsi_alloc_reqs(sc, vsc, qsize))
 		goto err;
 	aprint_normal_dev(sc->sc_dev,
 	    "cmd_per_lun %u qsize %d seg_max %u max_target %hu"
 	    " max_lun %u\n",
 	    cmd_per_lun, qsize, seg_max, max_target, max_lun);
-	if (virtio_child_attach_finish(vsc) != 0)
+	if (virtio_child_attach_finish(vsc, sc->sc_vqs,
 	    __arraycount(sc->sc_vqs), NULL, virtio_vq_intr,
 	    VIRTIO_F_INTR_MSIX) != 0)
 		goto err;
 	/*
 	 * Fill in the scsipi_adapter.
 	 */
 	memset(adapt, 0, sizeof(*adapt));
 	adapt->adapt_dev = sc->sc_dev;
 	adapt->adapt_nchannels = 1;
 	adapt->adapt_openings = MIN(qsize, cmd_per_lun);
 	adapt->adapt_max_periph = adapt->adapt_openings;
 	adapt->adapt_request = vioscsi_scsipi_request;
 	adapt->adapt_minphys = minphys;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vio9p.c,v 1.9 2022/04/20 22:08:10 uwe Exp $	*/
+/*	$NetBSD: vio9p.c,v 1.10 2023/03/23 03:27:48 yamaguchi Exp $	*/
 /*
  * Copyright (c) 2019 Internet Initiative Japan, Inc.
  * 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
  *    documentation and/or other materials provided with the distribution.
 @@ -16,27 +16,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: vio9p.c,v 1.9 2022/04/20 22:08:10 uwe Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vio9p.c,v 1.10 2023/03/23 03:27:48 yamaguchi Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
 #include <sys/condvar.h>
 #include <sys/device.h>
 #include <sys/mutex.h>
 #include <sys/sysctl.h>
 #include <sys/module.h>
 #include <sys/syslog.h>
 #include <sys/select.h>
 @@ -490,45 +490,40 @@ vio9p_attach(device_t parent, device_t s
 	struct virtio_softc *vsc = device_private(parent);
 	uint64_t features;
 	int error;
 	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;
-	virtio_child_attach_start(vsc, self, IPL_VM, sc->sc_vq,
+	virtio_child_attach_start(vsc, self, IPL_VM,
-	    NULL, virtio_vq_intr,
+	    VIO9P_F_MOUNT_TAG, VIO9P_FLAG_BITS);
 	    VIRTIO_F_INTR_MPSAFE | VIRTIO_F_INTR_SOFTINT,
 	    VIO9P_F_MOUNT_TAG,
 	    VIO9P_FLAG_BITS);
 	features = virtio_features(vsc);
 	if ((features & VIO9P_F_MOUNT_TAG) == 0)
 		goto err_none;
 	error = virtio_alloc_vq(vsc, &sc->sc_vq[0], 0, VIO9P_MAX_REQLEN,
 	    VIO9P_N_SEGMENTS * 2, "vio9p");
 	if (error != 0)
 		goto err_none;
 	sc->sc_vq[0].vq_done = vio9p_request_done;
 	virtio_child_attach_set_vqs(vsc, sc->sc_vq, 1);
 	sc->sc_buf_tx = kmem_alloc(VIO9P_MAX_REQLEN, KM_SLEEP);
 	sc->sc_buf_rx = kmem_alloc(VIO9P_MAX_REQLEN, KM_SLEEP);
 	error = bus_dmamap_create(virtio_dmat(vsc), VIO9P_MAX_REQLEN,
 	    VIO9P_N_SEGMENTS, VIO9P_SEGSIZE, 0, BUS_DMA_WAITOK, &sc->sc_dmamap_tx);
 	if (error != 0) {
 		aprint_error_dev(sc->sc_dev, "bus_dmamap_create failed: %d\n",
 		    error);
 		goto err_vq;
+	}
 	error = bus_dmamap_create(virtio_dmat(vsc), VIO9P_MAX_REQLEN,
 	    VIO9P_N_SEGMENTS, VIO9P_SEGSIZE, 0, BUS_DMA_WAITOK, &sc->sc_dmamap_rx);
 	if (error != 0) {
 @@ -549,27 +544,29 @@ vio9p_attach(device_t parent, device_t s
 	if (error != 0) {
 		aprint_error_dev(sc->sc_dev, "bus_dmamap_load failed: %d\n",
 		    error);
 		goto err_dmamap;
+	}
 	sc->sc_state = VIO9P_S_INIT;
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&sc->sc_wait, "vio9p");
 	vio9p_read_config(sc);
 	aprint_normal_dev(self, "tagged as %s\n", sc->sc_tag);
-	error = virtio_child_attach_finish(vsc);
+	error = virtio_child_attach_finish(vsc, sc->sc_vq,
 	    __arraycount(sc->sc_vq), NULL, virtio_vq_intr,
 	    VIRTIO_F_INTR_MPSAFE | VIRTIO_F_INTR_SOFTINT);
 	if (error != 0)
 		goto err_mutex;
 	return;
 err_mutex:
 	cv_destroy(&sc->sc_wait);
 	mutex_destroy(&sc->sc_lock);
 err_dmamap:
 	bus_dmamap_destroy(virtio_dmat(vsc), sc->sc_dmamap_tx);
 	bus_dmamap_destroy(virtio_dmat(vsc), sc->sc_dmamap_rx);
 err_vq:
 	virtio_free_vq(vsc, &sc->sc_vq[0]);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: viomb.c,v 1.13 2022/04/13 10:42:12 uwe Exp $	*/
+/*	$NetBSD: viomb.c,v 1.14 2023/03/23 03:27:48 yamaguchi Exp $	*/
 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
 @@ -16,27 +16,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: viomb.c,v 1.13 2022/04/13 10:42:12 uwe Exp $");
+__KERNEL_RCSID(0, "$NetBSD: viomb.c,v 1.14 2023/03/23 03:27:48 yamaguchi Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/bus.h>
 #include <sys/condvar.h>
 #include <sys/device.h>
 #include <sys/kthread.h>
 #include <sys/mutex.h>
 #include <sys/sysctl.h>
 #include <uvm/uvm_page.h>
 #include <sys/module.h>
 @@ -138,28 +138,27 @@ viomb_attach(device_t parent, device_t s
 		return;
+	}
 	/* fail on non-4K page size archs */
 	if (VIRTIO_PAGE_SIZE != PAGE_SIZE){
 		aprint_normal("non-4K page size arch found, needs %d, got %d\n",
 		    VIRTIO_PAGE_SIZE, PAGE_SIZE);
 		return;
+	}
 	sc->sc_dev = self;
 	sc->sc_virtio = vsc;
-	virtio_child_attach_start(vsc, self, IPL_VM, sc->sc_vq,
+	virtio_child_attach_start(vsc, self, IPL_VM,
 	    viomb_config_change, virtio_vq_intr, 0,
 	    VIRTIO_BALLOON_F_MUST_TELL_HOST, VIRTIO_BALLOON_FLAG_BITS);
 	features = virtio_features(vsc);
 	if (features == 0)
 		goto err_none;
 	viomb_read_config(sc);
 	sc->sc_inflight = 0;
 	TAILQ_INIT(&sc->sc_balloon_pages);
 	sc->sc_inflate_done = sc->sc_deflate_done = 0;
 	mutex_init(&sc->sc_waitlock, MUTEX_DEFAULT, IPL_VM); /* spin */
 	cv_init(&sc->sc_wait, "balloon");
 @@ -180,27 +179,28 @@ viomb_attach(device_t parent, device_t s
 , sizeof(uint32_t)*PGS_PER_REQ, 0,
 			      BUS_DMA_NOWAIT, &sc->sc_req.bl_dmamap)) {
 		aprint_error_dev(sc->sc_dev, "dmamap creation failed.\n");
 		goto err_vq;
+	}
 	if (bus_dmamap_load(virtio_dmat(vsc), sc->sc_req.bl_dmamap,
 			    &sc->sc_req.bl_pages[0],
 			    sizeof(uint32_t) * PGS_PER_REQ,
 			    NULL, BUS_DMA_NOWAIT)) {
 		aprint_error_dev(sc->sc_dev, "dmamap load failed.\n");
 		goto err_dmamap;
+	}
-	if (virtio_child_attach_finish(vsc) != 0)
+	if (virtio_child_attach_finish(vsc, sc->sc_vq, __arraycount(sc->sc_vq),
 	    viomb_config_change, virtio_vq_intr, 0) != 0)
 		goto err_out;
 	if (kthread_create(PRI_IDLE, KTHREAD_MPSAFE, NULL,
 			   viomb_thread, sc, NULL, "viomb")) {
 		aprint_error_dev(sc->sc_dev, "cannot create kthread.\n");
 		goto err_out;
+	}
 	sysctl_createv(NULL, 0, NULL, &node, 0, CTLTYPE_NODE,
 		       "viomb", SYSCTL_DESCR("VirtIO Balloon status"),
 		       NULL, 0, NULL, 0,
 		       CTL_HW, CTL_CREATE, CTL_EOL);
 	sysctl_createv(NULL, 0, NULL, NULL, 0, CTLTYPE_INT,

 @@ -1,14 +1,14 @@
-/*	$NetBSD: virtio.c,v 1.65 2023/01/03 19:33:31 jakllsch Exp $	*/
+/*	$NetBSD: virtio.c,v 1.66 2023/03/23 03:27:48 yamaguchi Exp $	*/
 /*
  * Copyright (c) 2020 The NetBSD Foundation, Inc.
  * Copyright (c) 2012 Stefan Fritsch, Alexander Fiveg.
  * 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
 @@ -18,27 +18,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: virtio.c,v 1.65 2023/01/03 19:33:31 jakllsch Exp $");
+__KERNEL_RCSID(0, "$NetBSD: virtio.c,v 1.66 2023/03/23 03:27:48 yamaguchi Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #define VIRTIO_PRIVATE
 #include <dev/pci/virtioreg.h> /* XXX: move to non-pci */
 @@ -752,29 +752,26 @@ virtio_init_vq(struct virtio_softc *sc,
+}
 /*
  * Allocate/free a vq.
  */
 int
 virtio_alloc_vq(struct virtio_softc *sc, struct virtqueue *vq, int index,
     int maxsegsize, int maxnsegs, const char *name)
+{
 	int vq_size, allocsize1, allocsize2, allocsize3, allocsize = 0;
 	int rsegs, r, hdrlen;
 #define VIRTQUEUE_ALIGN(n)	roundup(n, VIRTIO_PAGE_SIZE)
 	/* Make sure callers allocate vqs in order */
 	KASSERT(sc->sc_nvqs == index);
 	memset(vq, 0, sizeof(*vq));
 	vq_size = sc->sc_ops->read_queue_size(sc, index);
 	if (vq_size == 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "virtqueue not exist, index %d for %s\n",
 		    index, name);
 		goto err;
+	}
 	hdrlen = sc->sc_active_features & VIRTIO_F_RING_EVENT_IDX ? 3 : 2;
 	/* allocsize1: descriptor table + avail ring + pad */
 @@ -854,28 +851,26 @@ virtio_alloc_vq(struct virtio_softc *sc,
 	/* set the vq address */
 	sc->sc_ops->setup_queue(sc, index,
 	    vq->vq_dmamap->dm_segs[0].ds_addr);
 	aprint_verbose_dev(sc->sc_dev,
 	    "allocated %u byte for virtqueue %d for %s, size %d\n",
 	    allocsize, index, name, vq_size);
 	if (allocsize3 > 0)
 		aprint_verbose_dev(sc->sc_dev,
 		    "using %d byte (%d entries) indirect descriptors\n",
 		    allocsize3, maxnsegs * vq_size);
 	sc->sc_nvqs++;
 	return 0;
 err:
 	sc->sc_ops->setup_queue(sc, index, 0);
 	if (vq->vq_dmamap)
 		bus_dmamap_destroy(sc->sc_dmat, vq->vq_dmamap);
 	if (vq->vq_vaddr)
 		bus_dmamem_unmap(sc->sc_dmat, vq->vq_vaddr, allocsize);
 	if (vq->vq_segs[0].ds_addr)
 		bus_dmamem_free(sc->sc_dmat, &vq->vq_segs[0], 1);
 	memset(vq, 0, sizeof(*vq));
 	return -1;
 @@ -903,28 +898,26 @@ virtio_free_vq(struct virtio_softc *sc,
 	vq_sync_aring_all(sc, vq, BUS_DMASYNC_POSTWRITE);
 	kmem_free(vq->vq_entries, sizeof(*vq->vq_entries) * vq->vq_num);
 	bus_dmamap_unload(sc->sc_dmat, vq->vq_dmamap);
 	bus_dmamap_destroy(sc->sc_dmat, vq->vq_dmamap);
 	bus_dmamem_unmap(sc->sc_dmat, vq->vq_vaddr, vq->vq_bytesize);
 	bus_dmamem_free(sc->sc_dmat, &vq->vq_segs[0], 1);
 	mutex_destroy(&vq->vq_freelist_lock);
 	mutex_destroy(&vq->vq_uring_lock);
 	mutex_destroy(&vq->vq_aring_lock);
 	memset(vq, 0, sizeof(*vq));
 	sc->sc_nvqs--;
 	return 0;
+}
 /*
  * Free descriptor management.
  */
 static struct vq_entry *
 vq_alloc_entry(struct virtqueue *vq)
+{
 	struct vq_entry *qe;
 	mutex_enter(&vq->vq_freelist_lock);
 	if (SIMPLEQ_EMPTY(&vq->vq_freelist)) {
 @@ -1260,65 +1253,68 @@ virtio_dequeue_commit(struct virtio_soft
 		vq_free_entry(vq, qe);
 		qe = &vq->vq_entries[s];
+	}
 	vq_free_entry(vq, qe);
 	return 0;
+}
 /*
  * Attach a child, fill all the members.
  */
 void
 virtio_child_attach_start(struct virtio_softc *sc, device_t child, int ipl,
-    struct virtqueue *vqs,
+    uint64_t req_features, const char *feat_bits)
     virtio_callback config_change,
     virtio_callback intr_hand,
     int req_flags, int req_features, const char *feat_bits)
+{
 	char buf[1024];
 	sc->sc_child = child;
 	sc->sc_ipl = ipl;
 	sc->sc_vqs = vqs;
 	sc->sc_config_change = config_change;
 	sc->sc_intrhand = intr_hand;
 	sc->sc_flags = req_flags;
 	virtio_negotiate_features(sc, req_features);
 	snprintb(buf, sizeof(buf), feat_bits, sc->sc_active_features);
 	aprint_normal(": features: %s\n", buf);
 	aprint_naive("\n");
+}
 void
 virtio_child_attach_set_vqs(struct virtio_softc *sc,
     struct virtqueue *vqs, int nvq_pairs)
 	KASSERT(nvq_pairs == 1 ||
 	    (sc->sc_flags & VIRTIO_F_INTR_SOFTINT) == 0);
 	if (nvq_pairs > 1)
 		sc->sc_child_mq = true;
 	sc->sc_vqs = vqs;
 int
-virtio_child_attach_finish(struct virtio_softc *sc)
+virtio_child_attach_finish(struct virtio_softc *sc,
     struct virtqueue *vqs, size_t nvqs,
     virtio_callback config_change, virtio_callback intr_hand,
     int req_flags)
+{
 	int r;
 #ifdef DIAGNOSTIC
 	KASSERT(nvqs > 0);
 #define VIRTIO_ASSERT_FLAGS	(VIRTIO_F_INTR_SOFTINT | VIRTIO_F_INTR_PERVQ)
 	KASSERT((req_flags & VIRTIO_ASSERT_FLAGS) != VIRTIO_ASSERT_FLAGS);
 #undef VIRTIO_ASSERT_FLAGS
 	for (size_t _i = 0; _i < nvqs; _i++){
 		KASSERT(vqs[_i].vq_index == _i);
 		KASSERT((req_flags & VIRTIO_F_INTR_PERVQ) == 0 ||
 		    vqs[_i].vq_intrhand != NULL);
+	}
 #endif
 	sc->sc_finished_called = true;
 	sc->sc_vqs = vqs;
 	sc->sc_nvqs = nvqs;
 	sc->sc_config_change = config_change;
 	sc->sc_intrhand = intr_hand;
 	sc->sc_flags = req_flags;
 	r = sc->sc_ops->alloc_interrupts(sc);
 	if (r != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "failed to allocate interrupts\n");
 		goto fail;
+	}
 	r = sc->sc_ops->setup_interrupts(sc, 0);
 	if (r != 0) {
 		aprint_error_dev(sc->sc_dev, "failed to setup interrupts\n");
 		goto fail;
+	}

 @@ -1,14 +1,14 @@
-/* $NetBSD: virtio_pci.c,v 1.38 2022/05/30 20:28:18 riastradh Exp $ */
+/* $NetBSD: virtio_pci.c,v 1.39 2023/03/23 03:27:48 yamaguchi Exp $ */
 /*
  * Copyright (c) 2020 The NetBSD Foundation, Inc.
  * Copyright (c) 2012 Stefan Fritsch.
  * 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
 @@ -18,27 +18,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: virtio_pci.c,v 1.38 2022/05/30 20:28:18 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: virtio_pci.c,v 1.39 2023/03/23 03:27:48 yamaguchi Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include <sys/endian.h>
 #include <sys/interrupt.h>
 #include <sys/syslog.h>
 #include <sys/device.h>
 #include <dev/pci/pcidevs.h>
 #include <dev/pci/pcireg.h>
 @@ -63,26 +63,27 @@ do {							\
 	}						\
 } while(0)
 static int	virtio_pci_match(device_t, cfdata_t, void *);
 static void	virtio_pci_attach(device_t, device_t, void *);
 static int	virtio_pci_rescan(device_t, const char *, const int *);
 static int	virtio_pci_detach(device_t, int);
 #define NMAPREG		((PCI_MAPREG_END - PCI_MAPREG_START) / \
 				sizeof(pcireg_t))
 struct virtio_pci_softc {
 	struct virtio_softc	sc_sc;
 	bool			sc_intr_pervq;
 	/* IO space */
 	bus_space_tag_t		sc_iot;
 	bus_space_handle_t	sc_ioh;
 	bus_size_t		sc_iosize;
 	bus_size_t		sc_mapped_iosize;
 	/* BARs */
 	bus_space_tag_t		sc_bars_iot[NMAPREG];
 	bus_space_handle_t	sc_bars_ioh[NMAPREG];
 	bus_size_t		sc_bars_iosize[NMAPREG];
 	/* notify space */
 @@ -619,27 +620,27 @@ virtio_pci_read_queue_size_09(struct vir
 static void
 virtio_pci_setup_queue_09(struct virtio_softc *sc, uint16_t idx, uint64_t addr)
+{
 	struct virtio_pci_softc * const psc = (struct virtio_pci_softc *)sc;
 	bus_space_write_2(psc->sc_iot, psc->sc_ioh,
 	    VIRTIO_CONFIG_QUEUE_SELECT, idx);
 	bus_space_write_4(psc->sc_iot, psc->sc_ioh,
 	    VIRTIO_CONFIG_QUEUE_ADDRESS, addr / VIRTIO_PAGE_SIZE);
 	if (psc->sc_ihs_num > 1) {
 		int vec = VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
-		if (sc->sc_child_mq)
+		if (psc->sc_intr_pervq)
 			vec += idx;
 		bus_space_write_2(psc->sc_iot, psc->sc_ioh,
 		    VIRTIO_CONFIG_MSI_QUEUE_VECTOR, vec);
+	}
+}
 static void
 virtio_pci_set_status_09(struct virtio_softc *sc, int status)
+{
 	struct virtio_pci_softc * const psc = (struct virtio_pci_softc *)sc;
 	int old = 0;
 	if (status != 0) {
 @@ -741,27 +742,27 @@ virtio_pci_setup_queue_10(struct virtio_
 			VIRTIO_CONFIG1_QUEUE_DESC, addr);
 		virtio_pci_bus_space_write_8(iot, ioh,
 			VIRTIO_CONFIG1_QUEUE_AVAIL, addr + vq->vq_availoffset);
 		virtio_pci_bus_space_write_8(iot, ioh,
 			VIRTIO_CONFIG1_QUEUE_USED, addr + vq->vq_usedoffset);
 		bus_space_write_2(iot, ioh,
 			VIRTIO_CONFIG1_QUEUE_ENABLE, 1);
 		vq->vq_notify_off = bus_space_read_2(iot, ioh,
 			VIRTIO_CONFIG1_QUEUE_NOTIFY_OFF);
+	}
 	if (psc->sc_ihs_num > 1) {
 		int vec = VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
-		if (sc->sc_child_mq)
+		if (psc->sc_intr_pervq)
 			vec += idx;
 		bus_space_write_2(iot, ioh,
 			VIRTIO_CONFIG1_QUEUE_MSIX_VECTOR, vec);
+	}
+}
 static void
 virtio_pci_set_status_10(struct virtio_softc *sc, int status)
+{
 	struct virtio_pci_softc * const psc = (struct virtio_pci_softc *)sc;
 	bus_space_tag_t	   iot = psc->sc_iot;
 	bus_space_handle_t ioh = psc->sc_ioh;
 	int old = 0;
 @@ -839,27 +840,27 @@ virtio_pci_setup_interrupts_10(struct vi
 	vector = VIRTIO_MSIX_CONFIG_VECTOR_INDEX;
 	bus_space_write_2(iot, ioh,
 		VIRTIO_CONFIG1_CONFIG_MSIX_VECTOR, vector);
 	ret = bus_space_read_2(iot, ioh, VIRTIO_CONFIG1_CONFIG_MSIX_VECTOR);
 	if (ret != vector) {
 		VIRTIO_PCI_LOG(sc, reinit,
 		    "can't set config msix vector\n");
 		return -1;
+	}
 	for (qid = 0; qid < sc->sc_nvqs; qid++) {
 		vector = VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
-		if (sc->sc_child_mq)
+		if (psc->sc_intr_pervq)
 			vector += qid;
 		bus_space_write_2(iot, ioh, VIRTIO_CONFIG1_QUEUE_SELECT, qid);
 		bus_space_write_2(iot, ioh, VIRTIO_CONFIG1_QUEUE_MSIX_VECTOR,
 			vector);
 		ret = bus_space_read_2(iot, ioh,
 			VIRTIO_CONFIG1_QUEUE_MSIX_VECTOR);
 		if (ret != vector) {
 			VIRTIO_PCI_LOG(sc, reinit, "can't set queue %d "
 			    "msix vector\n", qid);
 			return -1;
+		}
+	}
 @@ -885,27 +886,27 @@ virtio_pci_setup_interrupts_09(struct vi
 		    __func__, vector, ret);
 		VIRTIO_PCI_LOG(sc, reinit,
 		    "can't set config msix vector\n");
 		return -1;
+	}
 	for (qid = 0; qid < sc->sc_nvqs; qid++) {
 		offset = VIRTIO_CONFIG_QUEUE_SELECT;
 		bus_space_write_2(psc->sc_iot, psc->sc_ioh, offset, qid);
 		offset = VIRTIO_CONFIG_MSI_QUEUE_VECTOR;
 		vector = VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
-		if (sc->sc_child_mq)
+		if (psc->sc_intr_pervq)
 			vector += qid;
 		bus_space_write_2(psc->sc_iot, psc->sc_ioh, offset, vector);
 		ret = bus_space_read_2(psc->sc_iot, psc->sc_ioh, offset);
 		if (ret != vector) {
 			aprint_debug_dev(sc->sc_dev, "%s[qid=%d]:"
 			    " expected=%d, actual=%d\n",
 			    __func__, qid, vector, ret);
 			VIRTIO_PCI_LOG(sc, reinit, "can't set queue %d "
 			    "msix vector\n", qid);
 			return -1;
+		}
+	}
 @@ -931,27 +932,27 @@ virtio_pci_establish_msix_interrupts(str
 		pci_intr_setattr(pc, &psc->sc_ihp[idx], PCI_INTR_MPSAFE, true);
 	snprintf(intr_xname, sizeof(intr_xname), "%s config",
 	    device_xname(sc->sc_dev));
 	psc->sc_ihs[idx] = pci_intr_establish_xname(pc, psc->sc_ihp[idx],
 	    sc->sc_ipl, virtio_pci_msix_config_intr, sc, intr_xname);
 	if (psc->sc_ihs[idx] == NULL) {
 		aprint_error_dev(self, "couldn't establish MSI-X for config\n");
 		goto error;
+	}
 	idx = VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
-	if (sc->sc_child_mq) {
+	if (psc->sc_intr_pervq) {
 		for (qid = 0; qid < sc->sc_nvqs; qid++) {
 			n = idx + qid;
 			vq = &sc->sc_vqs[qid];
 			snprintf(intr_xname, sizeof(intr_xname), "%s vq#%d",
 			    device_xname(sc->sc_dev), qid);
 			if (sc->sc_flags & VIRTIO_F_INTR_MPSAFE) {
 				pci_intr_setattr(pc, &psc->sc_ihp[n],
 				    PCI_INTR_MPSAFE, true);
+			}
 			psc->sc_ihs[n] = pci_intr_establish_xname(pc, psc->sc_ihp[n],
 @@ -969,27 +970,27 @@ virtio_pci_establish_msix_interrupts(str
 		    device_xname(sc->sc_dev));
 		psc->sc_ihs[idx] = pci_intr_establish_xname(pc, psc->sc_ihp[idx],
 		    sc->sc_ipl, virtio_pci_msix_queue_intr, sc, intr_xname);
 		if (psc->sc_ihs[idx] == NULL) {
 			aprint_error_dev(self, "couldn't establish MSI-X for queues\n");
 			goto error;
+		}
+	}
 	idx = VIRTIO_MSIX_CONFIG_VECTOR_INDEX;
 	intrstr = pci_intr_string(pc, psc->sc_ihp[idx], intrbuf, sizeof(intrbuf));
 	aprint_normal_dev(self, "config interrupting at %s\n", intrstr);
 	idx = VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
-	if (sc->sc_child_mq) {
+	if (psc->sc_intr_pervq) {
 		kcpuset_t *affinity;
 		int affinity_to, r;
 		kcpuset_create(&affinity, false);
 		for (qid = 0; qid < sc->sc_nvqs; qid++) {
 			n = idx + qid;
 			affinity_to = (qid / 2) % ncpu;
 			intrstr = pci_intr_string(pc, psc->sc_ihp[n],
 			    intrbuf, sizeof(intrbuf));
 			kcpuset_zero(affinity);
 @@ -1009,27 +1010,27 @@ virtio_pci_establish_msix_interrupts(str
 		kcpuset_destroy(affinity);
 	} else {
 		intrstr = pci_intr_string(pc, psc->sc_ihp[idx], intrbuf, sizeof(intrbuf));
 		aprint_normal_dev(self, "queues interrupting at %s\n", intrstr);
+	}
 	return 0;
 error:
 	idx = VIRTIO_MSIX_CONFIG_VECTOR_INDEX;
 	if (psc->sc_ihs[idx] != NULL)
 		pci_intr_disestablish(psc->sc_pa.pa_pc, psc->sc_ihs[idx]);
 	idx = VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
-	if (sc->sc_child_mq) {
+	if (psc->sc_intr_pervq) {
 		for (qid = 0; qid < sc->sc_nvqs; qid++) {
 			n = idx + qid;
 			if (psc->sc_ihs[n] == NULL)
 				continue;
 			pci_intr_disestablish(psc->sc_pa.pa_pc, psc->sc_ihs[n]);
+		}
 	} else {
 		if (psc->sc_ihs[idx] != NULL)
 			pci_intr_disestablish(psc->sc_pa.pa_pc, psc->sc_ihs[idx]);
+	}
 	return -1;
 @@ -1075,90 +1076,91 @@ virtio_pci_alloc_interrupts(struct virti
 	pci_intr_type_t max_type;
 	pcireg_t ctl;
 	nmsix = pci_msix_count(psc->sc_pa.pa_pc, psc->sc_pa.pa_tag);
 	aprint_debug_dev(self, "pci_msix_count=%d\n", nmsix);
 	/* We need at least two: one for config and the other for queues */
 	if ((sc->sc_flags & VIRTIO_F_INTR_MSIX) == 0 || nmsix < 2) {
 		/* Try INTx only */
 		max_type = PCI_INTR_TYPE_INTX;
 		counts[PCI_INTR_TYPE_INTX] = 1;
 	} else {
 		/* Try MSI-X first and INTx second */
-		if (sc->sc_nvqs + VIRTIO_MSIX_QUEUE_VECTOR_INDEX <= nmsix) {
+		if (ISSET(sc->sc_flags, VIRTIO_F_INTR_PERVQ) &&
 		    sc->sc_nvqs + VIRTIO_MSIX_QUEUE_VECTOR_INDEX <= nmsix) {
 			nmsix = sc->sc_nvqs + VIRTIO_MSIX_QUEUE_VECTOR_INDEX;
 		} else {
 			sc->sc_child_mq = false;
 		if (sc->sc_child_mq == false) {
 			nmsix = 2;
+		}
 		max_type = PCI_INTR_TYPE_MSIX;
 		counts[PCI_INTR_TYPE_MSIX] = nmsix;
 		counts[PCI_INTR_TYPE_MSI] = 0;
 		counts[PCI_INTR_TYPE_INTX] = 1;
+	}
 retry:
 	error = pci_intr_alloc(&psc->sc_pa, &psc->sc_ihp, counts, max_type);
 	if (error != 0) {
 		aprint_error_dev(self, "couldn't map interrupt\n");
 		return -1;
+	}
 	if (pci_intr_type(pc, psc->sc_ihp[0]) == PCI_INTR_TYPE_MSIX) {
 		psc->sc_intr_pervq = nmsix > 2 ? true : false;
 		psc->sc_ihs = kmem_zalloc(sizeof(*psc->sc_ihs) * nmsix,
 		    KM_SLEEP);
 		error = virtio_pci_establish_msix_interrupts(sc, &psc->sc_pa);
 		if (error != 0) {
 			kmem_free(psc->sc_ihs, sizeof(*psc->sc_ihs) * nmsix);
 			pci_intr_release(pc, psc->sc_ihp, nmsix);
 			/* Retry INTx */
 			max_type = PCI_INTR_TYPE_INTX;
 			counts[PCI_INTR_TYPE_INTX] = 1;
 			goto retry;
+		}
 		psc->sc_ihs_num = nmsix;
 		psc->sc_devcfg_offset = VIRTIO_CONFIG_DEVICE_CONFIG_MSI;
 		virtio_pci_adjust_config_region(psc);
 	} else if (pci_intr_type(pc, psc->sc_ihp[0]) == PCI_INTR_TYPE_INTX) {
 		psc->sc_intr_pervq = false;
 		psc->sc_ihs = kmem_zalloc(sizeof(*psc->sc_ihs) * 1,
 		    KM_SLEEP);
 		error = virtio_pci_establish_intx_interrupt(sc, &psc->sc_pa);
 		if (error != 0) {
 			kmem_free(psc->sc_ihs, sizeof(*psc->sc_ihs) * 1);
 			pci_intr_release(pc, psc->sc_ihp, 1);
 			return -1;
+		}
 		psc->sc_ihs_num = 1;
 		psc->sc_devcfg_offset = VIRTIO_CONFIG_DEVICE_CONFIG_NOMSI;
 		virtio_pci_adjust_config_region(psc);
 		error = pci_get_capability(pc, tag, PCI_CAP_MSIX, &off, NULL);
 		if (error != 0) {
 			ctl = pci_conf_read(pc, tag, off + PCI_MSIX_CTL);
 			ctl &= ~PCI_MSIX_CTL_ENABLE;
 			pci_conf_write(pc, tag, off + PCI_MSIX_CTL, ctl);
+		}
+	}
 	if (!psc->sc_intr_pervq)
 		CLR(sc->sc_flags, VIRTIO_F_INTR_PERVQ);
 	return 0;
+}
 static void
 virtio_pci_free_interrupts(struct virtio_softc *sc)
+{
 	struct virtio_pci_softc * const psc = (struct virtio_pci_softc *)sc;
 	for (int i = 0; i < psc->sc_ihs_num; i++) {
 		if (psc->sc_ihs[i] == NULL)
 			continue;
 		pci_intr_disestablish(psc->sc_pa.pa_pc, psc->sc_ihs[i]);
 		psc->sc_ihs[i] = NULL;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: virtiovar.h,v 1.24 2022/03/24 08:08:05 andvar Exp $	*/
+/*	$NetBSD: virtiovar.h,v 1.25 2023/03/23 03:27:48 yamaguchi Exp $	*/
 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
 @@ -161,39 +161,39 @@ struct virtio_softc {
 	int			sc_flags; /* set by child */
 	uint64_t		sc_active_features;
 	bool			sc_indirect;
 	bool			sc_version_1;
 	bool			sc_finished_called;
 	int			sc_nvqs; /* set by child */
 	struct virtqueue	*sc_vqs; /* set by child */
 	int			sc_childdevid;
 	device_t		sc_child; 		/* set by child */
 	bool			sc_child_mq;
 	virtio_callback		sc_config_change; 	/* set by child */
 	virtio_callback		sc_intrhand;		/* set by child */
 };
 #else
 struct virtio_softc;
 #endif
 /* interrupt types, stored in virtio_softc->sc_flags */
 #define VIRTIO_F_INTR_MPSAFE	(1 << 0)
 #define VIRTIO_F_INTR_SOFTINT	(1 << 1)
 #define VIRTIO_F_INTR_MSIX	(1 << 2)
 #define VIRTIO_F_INTR_PERVQ	(1 << 3)
 #define	VIRTIO_CHILD_FAILED		((void *)1)
 /* public interface */
 void virtio_negotiate_features(struct virtio_softc*, uint64_t);
 uint8_t virtio_read_device_config_1(struct virtio_softc *, int);
 uint16_t virtio_read_device_config_2(struct virtio_softc *, int);
 uint32_t virtio_read_device_config_4(struct virtio_softc *, int);
 uint64_t virtio_read_device_config_8(struct virtio_softc *, int);
 uint16_t virtio_read_device_config_le_2(struct virtio_softc *, int);
 uint32_t virtio_read_device_config_le_4(struct virtio_softc *, int);
 @@ -201,32 +201,30 @@ void virtio_write_device_config_1(struct
 void virtio_write_device_config_2(struct virtio_softc *, int, uint16_t);
 void virtio_write_device_config_4(struct virtio_softc *, int, uint32_t);
 void virtio_write_device_config_8(struct virtio_softc *, int, uint64_t);
 void virtio_write_device_config_le_2(struct virtio_softc *, int, uint16_t);
 void virtio_write_device_config_le_4(struct virtio_softc *, int, uint32_t);
 int virtio_alloc_vq(struct virtio_softc*, struct virtqueue*, int, int, int,
 		    const char*);
 int virtio_free_vq(struct virtio_softc*, struct virtqueue*);
 void virtio_reset(struct virtio_softc *);
 int virtio_reinit_start(struct virtio_softc *);
 void virtio_reinit_end(struct virtio_softc *);
 void virtio_child_attach_start(struct virtio_softc *, device_t, int,
-                    struct virtqueue *,
+		    uint64_t, const char *);
-                    virtio_callback, virtio_callback, int,
+int virtio_child_attach_finish(struct virtio_softc *,
-		    int, const char *);
+		    struct virtqueue *, size_t,
-void virtio_child_attach_set_vqs(struct virtio_softc *,
+		    virtio_callback, virtio_callback, int);
                     struct virtqueue *, int);
 int virtio_child_attach_finish(struct virtio_softc *);
 void virtio_child_attach_failed(struct virtio_softc *);
 void virtio_child_detach(struct virtio_softc *);
 int virtio_enqueue_prep(struct virtio_softc*, struct virtqueue*, int*);
 int virtio_enqueue_reserve(struct virtio_softc*, struct virtqueue*, int, int);
 int virtio_enqueue(struct virtio_softc*, struct virtqueue*, int,
 		   bus_dmamap_t, bool);
 int virtio_enqueue_p(struct virtio_softc*, struct virtqueue*, int,
 		     bus_dmamap_t, bus_addr_t, bus_size_t, bool);
 int virtio_enqueue_commit(struct virtio_softc*, struct virtqueue*, int, bool);
 int virtio_enqueue_abort(struct virtio_softc*, struct virtqueue*, int);
 int virtio_dequeue(struct virtio_softc*, struct virtqueue*, int *, int *);

 @@ -1,34 +1,34 @@
-/*	$NetBSD: viocon.c,v 1.5 2022/08/13 17:31:32 riastradh Exp $	*/
+/*	$NetBSD: viocon.c,v 1.6 2023/03/23 03:27:48 yamaguchi Exp $	*/
 /*	$OpenBSD: viocon.c,v 1.8 2021/11/05 11:38:29 mpi Exp $	*/
 /*
  * Copyright (c) 2013-2015 Stefan Fritsch <sf@sfritsch.de>
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: viocon.c,v 1.5 2022/08/13 17:31:32 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: viocon.c,v 1.6 2023/03/23 03:27:48 yamaguchi Exp $");
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/kauth.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include <sys/systm.h>
 #include <sys/tty.h>
 @@ -199,39 +199,38 @@ viocon_attach(struct device *parent, str
 	if (virtio_child(vsc) != NULL) {
 		aprint_error(": parent %s already has a child\n",
 		    device_xname(parent));
 		return;
+	}
 	sc->sc_virtio = vsc;
 	sc->sc_max_ports = maxports;
 	sc->sc_vqs = kmem_zalloc(2 * (maxports + 1) * sizeof(sc->sc_vqs[0]),
 	    KM_SLEEP);
 	sc->sc_ports = kmem_zalloc(maxports * sizeof(sc->sc_ports[0]),
 	    KM_SLEEP);
-	virtio_child_attach_start(vsc, self, IPL_TTY, sc->sc_vqs,
+	virtio_child_attach_start(vsc, self, IPL_TTY,
-	    /*config_change*/NULL, virtio_vq_intr,
+	    /*req_features*/VIRTIO_CONSOLE_F_SIZE, VIRTIO_CONSOLE_FLAG_BITS);
 	    /*req_flags*/0, /*req_features*/VIRTIO_CONSOLE_F_SIZE,
 	    VIRTIO_CONSOLE_FLAG_BITS);
 	DPRINTF("%s: softc: %p\n", __func__, sc);
 	if (viocon_port_create(sc, 0) != 0) {
 		printf("\n%s: viocon_port_create failed\n", __func__);
 		goto err;
+	}
 	viocon_rx_fill(sc->sc_ports[0]);
-	if (virtio_child_attach_finish(vsc) != 0)
+	if (virtio_child_attach_finish(vsc, sc->sc_vqs, sc->sc_max_ports * 2,
 	    /*config_change*/NULL, virtio_vq_intr, /*req_flags*/0) != 0)
 		goto err;
 	return;
 err:
 	kmem_free(sc->sc_vqs, 2 * (maxports + 1) * sizeof(sc->sc_vqs[0]));
 	kmem_free(sc->sc_ports, maxports * sizeof(sc->sc_ports[0]));
 	virtio_child_attach_failed(vsc);
+}
 int
 viocon_port_create(struct viocon_softc *sc, int portidx)
+{
 	struct virtio_softc *vsc = sc->sc_virtio;

 @@ -1,14 +1,14 @@
-/* 	$NetBSD: viornd.c,v 1.18 2022/04/14 19:47:14 riastradh Exp $ */
+/* 	$NetBSD: viornd.c,v 1.19 2023/03/23 03:27:48 yamaguchi Exp $ */
 /*	$OpenBSD: viornd.c,v 1.1 2014/01/21 21:14:58 sf Exp $	*/
 /*
  * Copyright (c) 2014 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Thor Lancelot Simon (tls@NetBSD.org).
+ *
  * 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
 @@ -166,40 +166,41 @@ viornd_attach(device_t parent, device_t
 				 error);
 		goto create_failed;
+	}
 	error = bus_dmamap_load(virtio_dmat(vsc), sc->sc_dmamap,
 	    			sc->sc_buf, VIORND_BUFSIZE, NULL,
 				BUS_DMA_NOWAIT|BUS_DMA_READ);
 	if (error) {
 		aprint_error_dev(sc->sc_dev, "can't load dmamap: %d\n",
 				 error);
 		goto load_failed;
+	}
-	virtio_child_attach_start(vsc, self, IPL_NET, &sc->sc_vq,
+	virtio_child_attach_start(vsc, self, IPL_NET,
 	    NULL, virtio_vq_intr, 0,
 , VIRTIO_COMMON_FLAG_BITS);
 	error = virtio_alloc_vq(vsc, &sc->sc_vq, 0, VIORND_BUFSIZE, 1,
 	    "Entropy request");
 	if (error) {
 		aprint_error_dev(sc->sc_dev, "can't alloc virtqueue: %d\n",
 				 error);
 		goto vio_failed;
+	}
 	sc->sc_vq.vq_done = viornd_vq_done;
-	if (virtio_child_attach_finish(vsc) != 0) {
+	error = virtio_child_attach_finish(vsc, &sc->sc_vq, 1,
 	    NULL, virtio_vq_intr, 0);
 	if (error) {
 		virtio_free_vq(vsc, &sc->sc_vq);
 		goto vio_failed;
+	}
 	rndsource_setcb(&sc->sc_rndsource, viornd_get, sc);
 	rnd_attach_source(&sc->sc_rndsource, device_xname(sc->sc_dev),
 			  RND_TYPE_RNG,
 			  RND_FLAG_COLLECT_VALUE|RND_FLAG_HASCB);
 	return;
 vio_failed:
 	bus_dmamap_unload(virtio_dmat(vsc), sc->sc_dmamap);