 @@ -1,14 +1,14 @@
-/*      $NetBSD: xbd_xenbus.c,v 1.129 2020/07/13 21:21:56 jdolecek Exp $      */
+/*      $NetBSD: xbd_xenbus.c,v 1.129.20.1 2023/07/27 17:56:31 martin 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.129 2020/07/13 21:21:56 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xbd_xenbus.c,v 1.129.20.1 2023/07/27 17:56:31 martin 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>
 @@ -159,27 +159,27 @@ struct xbd_xenbus_softc {
 	vmem_addr_t sc_unalign_buffer;
 	void *sc_unalign_used;
 	int sc_backend_status; /* our status with backend */
 #define BLKIF_STATE_DISCONNECTED 0
 #define BLKIF_STATE_CONNECTED    1
 #define BLKIF_STATE_SUSPENDED    2
 	int sc_shutdown;
 #define BLKIF_SHUTDOWN_RUN    0 /* no shutdown */
 #define BLKIF_SHUTDOWN_REMOTE 1 /* backend-initiated shutdown in progress */
 #define BLKIF_SHUTDOWN_LOCAL  2 /* locally-initiated shutdown in progress */
-	uint64_t sc_sectors; /* number of sectors for this device */
+	uint64_t sc_sectors; /* number of sc_secsize sectors for this device */
 	u_long sc_secsize; /* sector size */
 	uint64_t sc_xbdsize; /* size of disk in DEV_BSIZE */
 	u_long sc_info; /* VDISK_* */
 	u_long sc_handle; /* from backend */
 	int sc_features;
 #define BLKIF_FEATURE_CACHE_FLUSH	0x1
 #define BLKIF_FEATURE_BARRIER		0x2
 #define BLKIF_FEATURE_PERSISTENT	0x4
 #define BLKIF_FEATURE_INDIRECT		0x8
 #define BLKIF_FEATURE_BITS		\
 	"\20\1CACHE-FLUSH\2BARRIER\3PERSISTENT\4INDIRECT"
 	struct evcnt sc_cnt_map_unalign;
 	struct evcnt sc_cnt_unalign_busy;
 @@ -668,45 +668,44 @@ xbd_backend_changed(void *arg, XenbusSta
 		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_secperunit = sc->sc_sectors;
-		dg->dg_secsize = DEV_BSIZE;
+		dg->dg_secsize = sc->sc_secsize;
 		dg->dg_ntracks = 1;
-		// XXX: Ok to hard-code DEV_BSIZE?
+		dg->dg_nsectors = (1024 * 1024) / dg->dg_secsize;
 		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;
 		hypervisor_unmask_event(sc->sc_evtchn);
 		format_bytes(buf, uimin(9, sizeof(buf)),
-		    sc->sc_sectors * sc->sc_secsize);
+		    sc->sc_sectors * dg->dg_secsize);
 		aprint_normal_dev(sc->sc_dksc.sc_dev,
 				"%s, %d bytes/sect x %" PRIu64 " sectors\n",
-				buf, (int)dg->dg_secsize, sc->sc_xbdsize);
+				buf, (int)dg->dg_secsize, sc->sc_sectors);
 		snprintb(buf, sizeof(buf), BLKIF_FEATURE_BITS,
 		    sc->sc_features);
 		aprint_normal_dev(sc->sc_dksc.sc_dev,
 		    "backend features %s\n", buf);
 		/* Discover wedges on this disk. */
 		dkwedge_discover(&sc->sc_dksc.sc_dkdev);
 		disk_set_info(sc->sc_dksc.sc_dev, &sc->sc_dksc.sc_dkdev, NULL);
 		/* the disk should be working now */
 		config_pending_decr(sc->sc_dksc.sc_dev);
 		break;
 @@ -729,46 +728,45 @@ xbd_connect(struct xbd_xenbus_softc *sc)
 	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);
 	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 * (uint64_t)XEN_BSIZE / sc->sc_secsize;
 	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,
 	    "feature-flush-cache", &val, 10);
 	if (err)
 @@ -829,26 +827,28 @@ again:
 		    rep->operation != BLKIF_OP_WRITE) {
 			aprint_error_dev(sc->sc_dksc.sc_dev,
 			    "bad operation %d from backend\n", rep->operation);
 			continue;
+		}
 		bp = xbdreq->req_bp;
 		xbdreq->req_bp = NULL;
 		KASSERT(bp != NULL && bp->b_data != NULL);
 		DPRINTF(("%s(%p): b_bcount = %ld\n", __func__,
 		    bp, (long)bp->b_bcount));
 		if (bp->b_error != 0 || rep->status != BLKIF_RSP_OKAY) {
 			DPRINTF(("%s: error %d status %d\n", __func__,
 			    bp->b_error, rep->status));
 			bp->b_error = EIO;
 			bp->b_resid = bp->b_bcount;
+		}
 		if (xbdreq->req_parent) {
 			struct xbd_req *req_parent = xbdreq->req_parent;
 			/* Unhook and recycle child */
 			xbdreq->req_parent = NULL;
 			req_parent->req_child = NULL;
 			SLIST_INSERT_HEAD(&sc->sc_xbdreq_head, xbdreq,
 				    req_next);
 @@ -1128,27 +1128,27 @@ xbd_diskstart(device_t self, struct buf
 	KASSERT(bp->b_bcount <= MAXPHYS);
 	DPRINTF(("xbd_diskstart(%p): b_bcount = %ld\n",
 	    bp, (long)bp->b_bcount));
 	mutex_enter(&sc->sc_lock);
 	if (sc->sc_shutdown != BLKIF_SHUTDOWN_RUN) {
 		error = EIO;
 		goto out;
+	}
-	if (bp->b_rawblkno < 0 || bp->b_rawblkno > sc->sc_xbdsize) {
+	if (bp->b_rawblkno < 0 || bp->b_rawblkno > sc->sc_sectors) {
 		/* invalid block number */
 		error = EINVAL;
 		goto out;
+	}
 	if (__predict_false(
 	    sc->sc_backend_status == BLKIF_STATE_SUSPENDED)) {
 		/* device is suspended, do not consume buffer */
 		DPRINTF(("%s: (xbd_diskstart) device suspended\n",
 		    sc->sc_dksc.sc_xname));
 		error = EAGAIN;
 		goto out;
+	}
 @@ -1164,27 +1164,27 @@ xbd_diskstart(device_t self, struct buf
 	if ((sc->sc_features & BLKIF_FEATURE_INDIRECT) == 0
 	    && bp->b_bcount > XBD_MAX_CHUNK) {
 		if (!SLIST_NEXT(xbdreq, req_next)) {
 			DPRINTF(("%s: need extra req\n", __func__));
 			error = EAGAIN;
 			goto out;
+		}
+	}
 	bp->b_resid = bp->b_bcount;
 	xbdreq->req_bp = bp;
 	xbdreq->req_data = bp->b_data;
-	if (__predict_false((vaddr_t)bp->b_data & (XEN_BSIZE - 1))) {
+	if (__predict_false((vaddr_t)bp->b_data & (sc->sc_secsize - 1))) {
 		if (__predict_false(xbd_map_align(sc, xbdreq) != 0)) {
 			DPRINTF(("xbd_diskstart: no align\n"));
 			error = EAGAIN;
 			goto out;
+		}
+	}
 	if (__predict_false(bus_dmamap_load(sc->sc_xbusd->xbusd_dmat,
 	    xbdreq->req_dmamap, xbdreq->req_data, bp->b_bcount, NULL,
 	    BUS_DMA_NOWAIT) != 0)) {
 		printf("%s: %s: bus_dmamap_load failed\n",
 		    device_xname(sc->sc_dksc.sc_dev), __func__);
 		if (__predict_false(bp->b_data != xbdreq->req_data))
 @@ -1265,125 +1265,133 @@ xbd_diskstart_submit(struct xbd_xenbus_s
     grant_ref_t *gntref)
+{
 	blkif_request_t *req;
 	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->sector_number = (bp->b_rawblkno * sc->sc_secsize / XEN_BSIZE) +
 	    (start >> XEN_BSHIFT);
 	req->handle = sc->sc_handle;
 	DPRINTF(("%s: id %" PRIu64 " op %d sn %" PRIu64 " handle %d\n",
 	    __func__, req->id, req->operation, req->sector_number,
 	    req->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;
 			start = 0;
+		}
 		size -= nbytes;
-		KASSERT(((ma & PAGE_MASK) & (XEN_BSIZE - 1)) == 0);
+		KASSERT(((ma & PAGE_MASK) & (sc->sc_secsize - 1)) == 0);
-		KASSERT((nbytes & (XEN_BSIZE - 1)) == 0);
+		KASSERT((nbytes & (sc->sc_secsize - 1)) == 0);
-		KASSERT((size & (XEN_BSIZE - 1)) == 0);
+		KASSERT((size & (sc->sc_secsize - 1)) == 0);
 		first_sect = (ma & PAGE_MASK) >> XEN_BSHIFT;
 		nsects = nbytes >> XEN_BSHIFT;
 		reqseg = &req->seg[segidx++];
 		reqseg->first_sect = first_sect;
 		reqseg->last_sect = first_sect + nsects - 1;
 		KASSERT(reqseg->first_sect <= reqseg->last_sect);
 		KASSERT(reqseg->last_sect < (PAGE_SIZE / XEN_BSIZE));
 		DPRINTF(("%s: seg %d fs %d ls %d\n", __func__, segidx,
 		    reqseg->first_sect, reqseg->last_sect));
 		reqseg->gref = gntref[dmaseg];
+	}
 	KASSERT(segidx > 0);
 	req->nr_segments = segidx;
 	sc->sc_ring.req_prod_pvt++;
+}
 static void
 xbd_diskstart_submit_indirect(struct xbd_xenbus_softc *sc,
     struct xbd_req *xbdreq, struct buf *bp)
+{
 	blkif_request_indirect_t *req;
 	paddr_t ma;
 	int nsects, nbytes, dmaseg, first_sect;
 	struct blkif_request_segment *reqseg;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	req = (blkif_request_indirect_t *)RING_GET_REQUEST(&sc->sc_ring,
 	    sc->sc_ring.req_prod_pvt);
 	req->id = xbdreq->req_id;
 	req->operation = BLKIF_OP_INDIRECT;
 	req->indirect_op =
 	    bp->b_flags & B_READ ? BLKIF_OP_READ : BLKIF_OP_WRITE;
-	req->sector_number = bp->b_rawblkno;
+	req->sector_number = bp->b_rawblkno * sc->sc_secsize / XEN_BSIZE;
 	req->handle = sc->sc_handle;
 	DPRINTF(("%s: id %" PRIu64 " op %d sn %" PRIu64 " handle %d\n",
 	    __func__, req->id, req->indirect_op, req->sector_number,
 	    req->handle));
 	xbdreq->req_indirect = SLIST_FIRST(&sc->sc_indirect_head);
 	KASSERT(xbdreq->req_indirect != NULL);	/* always as many as reqs */
 	SLIST_REMOVE_HEAD(&sc->sc_indirect_head, in_next);
 	req->indirect_grefs[0] = xbdreq->req_indirect->in_gntref;
 	reqseg = xbdreq->req_indirect->in_addr;
 	for (dmaseg = 0; dmaseg < xbdreq->req_dmamap->dm_nsegs; dmaseg++) {
 		bus_dma_segment_t *ds = &xbdreq->req_dmamap->dm_segs[dmaseg];
 		ma = ds->ds_addr;
 		nbytes = ds->ds_len;
 		KASSERT(((ma & PAGE_MASK) & (sc->sc_secsize - 1)) == 0);
 		KASSERT((nbytes & (sc->sc_secsize - 1)) == 0);
 		first_sect = (ma & PAGE_MASK) >> XEN_BSHIFT;
 		nsects = nbytes >> XEN_BSHIFT;
 		reqseg->first_sect = first_sect;
 		reqseg->last_sect = first_sect + nsects - 1;
 		reqseg->gref = xbdreq->req_gntref[dmaseg];
 		DPRINTF(("%s: seg %d fs %d ls %d\n", __func__, dmaseg,
 		    reqseg->first_sect, reqseg->last_sect));
 		KASSERT(reqseg->first_sect <= reqseg->last_sect);
 		KASSERT(reqseg->last_sect < (PAGE_SIZE / XEN_BSIZE));
 		reqseg++;
+	}
 	req->nr_segments = dmaseg;
 	sc->sc_ring.req_prod_pvt++;
 	sc->sc_cnt_indirect.ev_count++;
+}
 static int
 xbd_map_align(struct xbd_xenbus_softc *sc, struct xbd_req *req)
+{
 	/*
 	 * Only can get here if this is physio() request, block I/O
 	 * uses DEV_BSIZE-aligned buffers.
 	 */
 	KASSERT((req->req_bp->b_flags & B_PHYS) != 0);
 	sc->sc_cnt_map_unalign.ev_count++;
 	if (sc->sc_unalign_used) {
 		sc->sc_cnt_unalign_busy.ev_count++;
 		return EAGAIN;
+	}
 	sc->sc_unalign_used = req->req_bp;
 	KASSERT(req->req_bp->b_bcount <= MAXPHYS);
 	req->req_data = (void *)sc->sc_unalign_buffer;
 	if ((req->req_bp->b_flags & B_READ) == 0)
 		memcpy(req->req_data, req->req_bp->b_data,
 		    req->req_bp->b_bcount);