 @@ -1,14 +1,14 @@
-/*      $NetBSD: xbd_xenbus.c,v 1.130 2023/02/25 00:33:03 riastradh Exp $      */
+/*      $NetBSD: xbd_xenbus.c,v 1.131 2023/02/25 00:35:15 riastradh 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.
+ *
 @@ -40,27 +40,27 @@
  * - initiate request: xbdread/write/open/ioctl/..
  * - depending on operation, it is handled directly by disk(9) subsystem or
  *   goes through physio(9) first.
  * - the request is ultimately processed by xbd_diskstart() that prepares the
  *   xbd requests, post them in the ring I/O queue, then signal the backend.
+ *
  * When a response is available in the queue, the backend signals the frontend
  * via its event channel. This triggers xbd_handler(), which will link back
  * the response to its request through the request ID, and mark the I/O as
  * completed.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: xbd_xenbus.c,v 1.130 2023/02/25 00:33:03 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xbd_xenbus.c,v 1.131 2023/02/25 00:35:15 riastradh Exp $");
 #include "opt_xen.h"
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/device.h>
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <sys/conf.h>
 #include <sys/fcntl.h>
 #include <sys/kernel.h>
 @@ -89,27 +89,27 @@ __KERNEL_RCSID(0, "$NetBSD: xbd_xenbus.c
 #define DPRINTF(x) printf x;
 #else
 #define DPRINTF(x)
 #endif
 #define GRANT_INVALID_REF -1
 #define XBD_RING_SIZE __CONST_RING_SIZE(blkif, PAGE_SIZE)
 #define XBD_MAX_XFER (PAGE_SIZE * BLKIF_MAX_SEGMENTS_PER_REQUEST)
 #define XBD_MAX_CHUNK	32*1024		/* max I/O size we process in 1 req */
 #define XBD_XFER_LIMIT	(2*XBD_MAX_XFER)
 #define XEN_BSHIFT      9               /* log2(XEN_BSIZE) */
 #define XEN_BSIZE       (1 << XEN_BSHIFT)
 CTASSERT((MAXPHYS <= 2*XBD_MAX_CHUNK));
 CTASSERT(XEN_BSIZE == DEV_BSIZE);
 struct xbd_indirect {
 	SLIST_ENTRY(xbd_indirect) in_next;
 	struct blkif_request_segment *in_addr;
 	grant_ref_t in_gntref;
 };
 struct xbd_req {
 	SLIST_ENTRY(xbd_req) req_next;
 	uint16_t req_id; /* ID passed to backend */
 @@ -666,27 +666,27 @@ xbd_backend_changed(void *arg, XenbusSta
 		 * the xenbus thread.
 		 */
 		if (sc->sc_backend_status == BLKIF_STATE_CONNECTED ||
 		    sc->sc_backend_status == BLKIF_STATE_SUSPENDED)
 			/* already connected */
 			return;
 		xbd_connect(sc);
 		sc->sc_shutdown = BLKIF_SHUTDOWN_RUN;
 		sc->sc_xbdsize =
 		    sc->sc_sectors * (uint64_t)sc->sc_secsize / DEV_BSIZE;
 		dg = &sc->sc_dksc.sc_dkdev.dk_geom;
 		memset(dg, 0, sizeof(*dg));
 		dg->dg_secperunit = sc->sc_xbdsize;
 		dg->dg_secsize = DEV_BSIZE;
 		dg->dg_ntracks = 1;
 		// XXX: Ok to hard-code DEV_BSIZE?
 		dg->dg_nsectors = 1024 * (1024 / dg->dg_secsize);
 		dg->dg_ncylinders = dg->dg_secperunit / dg->dg_nsectors;
 		bufq_alloc(&sc->sc_dksc.sc_bufq, "fcfs", 0);
 		dk_attach(&sc->sc_dksc);
 		disk_attach(&sc->sc_dksc.sc_dkdev);
 		sc->sc_backend_status = BLKIF_STATE_CONNECTED;
 @@ -726,47 +726,47 @@ xbd_connect(struct xbd_xenbus_softc *sc)
 	 * Must read feature-persistent later, e.g. Linux Dom0 writes
 	 * this together with the device info.
 	 */
 	err = xenbus_read_ul(NULL, sc->sc_xbusd->xbusd_otherend,
 	    "feature-persistent", &val, 10);
 	if (err)
 		val = 0;
 	if (val > 0)
 		sc->sc_features |= BLKIF_FEATURE_PERSISTENT;
 	err = xenbus_read_ul(NULL,
 	    sc->sc_xbusd->xbusd_path, "virtual-device", &sc->sc_handle, 10);
 	if (err)
 		panic("%s: can't read number from %s/virtual-device\n",
 		    device_xname(sc->sc_dksc.sc_dev),
 		    sc->sc_xbusd->xbusd_otherend);
 	err = xenbus_read_ull(NULL,
 	    sc->sc_xbusd->xbusd_otherend, "sectors", &sectors, 10);
 	if (err)
 		panic("%s: can't read number from %s/sectors\n",
 		    device_xname(sc->sc_dksc.sc_dev),
 		    sc->sc_xbusd->xbusd_otherend);
 	sc->sc_sectors = sectors;
 	err = xenbus_read_ul(NULL,
 	    sc->sc_xbusd->xbusd_otherend, "info", &sc->sc_info, 10);
 	if (err)
 		panic("%s: can't read number from %s/info\n",
 		    device_xname(sc->sc_dksc.sc_dev),
 		    sc->sc_xbusd->xbusd_otherend);
 	err = xenbus_read_ul(NULL,
 	    sc->sc_xbusd->xbusd_otherend, "sector-size", &sc->sc_secsize, 10);
 	if (err)
 		panic("%s: can't read number from %s/sector-size\n",
 		    device_xname(sc->sc_dksc.sc_dev),
 		    sc->sc_xbusd->xbusd_otherend);
 	xenbus_switch_state(sc->sc_xbusd, NULL, XenbusStateConnected);
+}
 static void
 xbd_features(struct xbd_xenbus_softc *sc)
+{
 	int err;
 	u_long val;
 	err = xenbus_read_ul(NULL, sc->sc_xbusd->xbusd_otherend,
 @@ -924,27 +924,27 @@ static void
 xbdminphys(struct buf *bp)
+{
 	if (bp->b_bcount > XBD_XFER_LIMIT) {
 		bp->b_bcount = XBD_XFER_LIMIT;
+	}
 	minphys(bp);
+}
 static void
 xbd_iosize(device_t dev, int *maxxfer)
+{
 	/*
 	 * Always restrict dumps to XBD_MAX_XFER to avoid indirect segments,
 	 * so that it uses as little memory as possible.
 	 */
 	if (*maxxfer > XBD_MAX_XFER)
 		*maxxfer = XBD_MAX_XFER;
+}
 static int
 xbdopen(dev_t dev, int flags, int fmt, struct lwp *l)
+{
 	struct	xbd_xenbus_softc *sc;
 	sc = device_lookup_private(&xbd_cd, DISKUNIT(dev));
 	if (sc == NULL)
 		return (ENXIO);
 @@ -998,27 +998,27 @@ xbdsize(dev_t dev)
 	struct	xbd_xenbus_softc *sc;
 	DPRINTF(("xbdsize(%" PRIx64 ")\n", dev));
 	sc = device_lookup_private(&xbd_cd, DISKUNIT(dev));
 	if (sc == NULL || sc->sc_shutdown != BLKIF_SHUTDOWN_RUN)
 		return -1;
 	return dk_size(&sc->sc_dksc, dev);
+}
 static int
 xbdread(dev_t dev, struct uio *uio, int flags)
+{
 	struct xbd_xenbus_softc *sc =
 	    device_lookup_private(&xbd_cd, DISKUNIT(dev));
 	struct  dk_softc *dksc = &sc->sc_dksc;
 	if (!DK_ATTACHED(dksc))
 		return ENXIO;
 	return physio(xbdstrategy, NULL, dev, B_READ, xbdminphys, uio);
+}
 static int
 xbdwrite(dev_t dev, struct uio *uio, int flags)
+{
 	struct xbd_xenbus_softc *sc =
 	    device_lookup_private(&xbd_cd, DISKUNIT(dev));
 @@ -1267,27 +1267,27 @@ xbd_diskstart_submit(struct xbd_xenbus_s
 	paddr_t ma;
 	int nsects, nbytes, dmaseg, first_sect, size, segidx = 0;
 	struct blkif_request_segment *reqseg;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	req = RING_GET_REQUEST(&sc->sc_ring, sc->sc_ring.req_prod_pvt);
 	req->id = req_id;
 	req->operation =
 	    bp->b_flags & B_READ ? BLKIF_OP_READ : BLKIF_OP_WRITE;
 	req->sector_number = bp->b_rawblkno + (start >> XEN_BSHIFT);
 	req->handle = sc->sc_handle;
 	size = uimin(bp->b_bcount - start, XBD_MAX_CHUNK);
 	for (dmaseg = 0; dmaseg < dmamap->dm_nsegs && size > 0; dmaseg++) {
 		bus_dma_segment_t *ds = &dmamap->dm_segs[dmaseg];
 		ma = ds->ds_addr;
 		nbytes = ds->ds_len;
 		if (start > 0) {
 			if (start >= nbytes) {
 				start -= nbytes;
 				continue;
+			}
 			ma += start;
 			nbytes -= start;