 @@ -1,14 +1,14 @@
-/*      $NetBSD: xbdback_xenbus.c,v 1.86 2020/04/21 13:56:18 jdolecek Exp $      */
+/*      $NetBSD: xbdback_xenbus.c,v 1.87 2020/04/23 07:24:40 jdolecek 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.
+ *
 @@ -16,27 +16,27 @@
  * 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: xbdback_xenbus.c,v 1.86 2020/04/21 13:56:18 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xbdback_xenbus.c,v 1.87 2020/04/23 07:24:40 jdolecek Exp $");
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/condvar.h>
 #include <sys/conf.h>
 #include <sys/disk.h>
 #include <sys/device.h>
 #include <sys/fcntl.h>
 #include <sys/kauth.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/kthread.h>
 #include <sys/mutex.h>
 @@ -67,27 +67,26 @@ __KERNEL_RCSID(0, "$NetBSD: xbdback_xenb
  * Backend block device driver for Xen
  */
 /* Values are expressed in 512-byte sectors */
 #define VBD_BSIZE 512
 #define VBD_MAXSECT ((PAGE_SIZE / VBD_BSIZE) - 1)
 /* Need to alloc one extra page to account for possible mapping offset */
 #define VBD_VA_SIZE	(MAXPHYS + PAGE_SIZE)
 #define VBD_MAX_INDIRECT_SEGMENTS	VBD_VA_SIZE >> PAGE_SHIFT
 CTASSERT(XENSHM_MAX_PAGES_PER_REQUEST >= VBD_MAX_INDIRECT_SEGMENTS);
 struct xbdback_io;
 struct xbdback_instance;
 /*
  * status of a xbdback instance:
  * WAITING: xbdback instance is connected, waiting for requests
  * RUN: xbdi thread must be woken up, I/Os have to be processed
  * DISCONNECTING: the instance is closing, no more I/Os can be scheduled
  * DISCONNECTED: no I/Os, no ring, the thread should terminate.
  */
 typedef enum {WAITING, RUN, DISCONNECTING, DISCONNECTED} xbdback_state_t;
 /*
  * Each xbdback instance is managed by a single thread that handles all
 @@ -176,28 +175,26 @@ struct xbdback_instance {
 	int xbdi_refcnt;
 	/*
 	 * State for I/O processing/coalescing follows; this has to
 	 * live here instead of on the stack because of the
 	 * continuation-ness (see above).
 	 */
 	RING_IDX xbdi_req_prod; /* limit on request indices */
 	xbdback_cont_t xbdi_cont;
 	/* _request state: track requests fetched from ring */
 	blkif_request_t xbdi_xen_req;
 	struct blkif_request_segment xbdi_seg[VBD_MAX_INDIRECT_SEGMENTS];
 	bus_dmamap_t xbdi_seg_dmamap;
 	grant_ref_t xbdi_in_gntref;
 	/* _io state: I/O associated to this instance */
 	struct xbdback_io *xbdi_io;
 	/* other state */
 	int xbdi_same_page; /* are we merging two segments on the same page? */
 	uint xbdi_pendingreqs; /* number of I/O in fly */
 	struct timeval xbdi_lasterr_time;    /* error time tracking */
 #ifdef DEBUG
 	struct timeval xbdi_lastfragio_time; /* fragmented I/O tracking */
 #endif
 };
 /* Manipulation of the above reference count. */
 #define xbdi_get(xbdip) atomic_inc_uint(&(xbdip)->xbdi_refcnt)
 #define xbdi_put(xbdip)                                      \
 do {                                                         \
 	if (atomic_dec_uint_nv(&(xbdip)->xbdi_refcnt) == 0)  \
 @@ -1033,27 +1030,26 @@ xbdback_co_main_loop(struct xbdback_inst
 		default:
 			if (ratecheck(&xbdi->xbdi_lasterr_time,
 			    &xbdback_err_intvl)) {
 				printf("%s: unknown operation %d\n",
 				    xbdi->xbdi_name, req->operation);
+			}
 fail:
 			xbdback_send_reply(xbdi, req->id, req->operation,
 			    BLKIF_RSP_ERROR);
 			xbdi->xbdi_cont = xbdback_co_main_incr;
 			break;
+		}
 	} else {
 		KASSERT(xbdi->xbdi_io == NULL);
 		xbdi->xbdi_cont = xbdback_co_main_done2;
+	}
 	return xbdi;
+}
 /*
  * Increment consumer index and move on to the next request. In case
  * we want to disconnect, leave continuation now.
  */
 static void *
 xbdback_co_main_incr(struct xbdback_instance *xbdi, void *obj)
+{
 	(void)obj;
 @@ -1080,27 +1076,26 @@ xbdback_co_main_incr(struct xbdback_inst
 	return xbdi;
+}
 /*
  * Check for requests in the instance's ring. In case there are, start again
  * from the beginning. If not, stall.
  */
 static void *
 xbdback_co_main_done2(struct xbdback_instance *xbdi, void *obj)
+{
 	int work_to_do;
 	KASSERT(xbdi->xbdi_io == NULL);
 	RING_FINAL_CHECK_FOR_REQUESTS(&xbdi->xbdi_ring.ring_n, work_to_do);
 	if (work_to_do)
 		xbdi->xbdi_cont = xbdback_co_main;
 	else
 		xbdi->xbdi_cont = NULL;
 	return xbdi;
+}
 /*
  * Frontend requested a cache flush operation.
  */
 static void *
 @@ -1116,32 +1111,32 @@ xbdback_co_cache_flush(struct xbdback_in
 		return NULL;
+	}
 	xbdi->xbdi_cont = xbdback_co_cache_doflush;
 	return xbdback_pool_get(&xbdback_io_pool, xbdi);
+}
 /* Start the flush work */
 static void *
 xbdback_co_cache_doflush(struct xbdback_instance *xbdi, void *obj)
+{
 	struct xbdback_io *xbd_io;
 	XENPRINTF(("xbdback_co_cache_doflush %p %p\n", xbdi, obj));
-	xbd_io = xbdi->xbdi_io = obj;
+	xbd_io = obj;
 	xbd_io->xio_xbdi = xbdi;
 	xbd_io->xio_operation = xbdi->xbdi_xen_req.operation;
 	xbd_io->xio_id = xbdi->xbdi_xen_req.id;
 	xbdi->xbdi_cont = xbdback_co_do_io;
-	return xbdi;
+	return xbd_io;
+}
 /*
  * A read or write I/O request must be processed. Do some checks first,
  * then get the segment information directly from the ring request.
  */
 static void *
 xbdback_co_io(struct xbdback_instance *xbdi, void *obj __unused)
+{
 	int i, error;
 	blkif_request_t *req, *reqn;
 	blkif_x86_32_request_t *req32;
 	blkif_x86_64_request_t *req64;
 @@ -1225,27 +1220,26 @@ xbdback_co_io(struct xbdback_instance *x
 			if (req->nr_segments > BLKIF_MAX_SEGMENTS_PER_REQUEST)
 				goto bad_nr_segments;
 			for (i = 0; i < req->nr_segments; i++)
 				xbdi->xbdi_seg[i] = req64->seg[i];
 			xbdi->xbdi_in_gntref = 0;
+		}
 		break;
+	}
 	/* Max value checked already earlier */
 	if (req->nr_segments < 1)
 		goto bad_nr_segments;
 	KASSERT(xbdi->xbdi_io == NULL);
 	xbdi->xbdi_cont = xbdback_co_io_gotio;
 	return xbdback_pool_get(&xbdback_io_pool, xbdi);
  bad_nr_segments:
 	if (ratecheck(&xbdi->xbdi_lasterr_time, &xbdback_err_intvl)) {
 		printf("%s: invalid number of segments: %d\n",
 		       xbdi->xbdi_name, req->nr_segments);
+	}
 	error = EINVAL;
 	/* FALLTHROUGH */
  end:
 	xbdback_send_reply(xbdi, xbdi->xbdi_xen_req.id,
 @@ -1258,27 +1252,27 @@ xbdback_co_io(struct xbdback_instance *x
 /* Prepare an I/O buffer for a xbdback instance */
 static void *
 xbdback_co_io_gotio(struct xbdback_instance *xbdi, void *obj)
+{
 	struct xbdback_io *xbd_io;
 	int buf_flags;
 	size_t bcount;
 	blkif_request_t *req;
 	xbdi_get(xbdi);
 	atomic_inc_uint(&xbdi->xbdi_pendingreqs);
 	req = &xbdi->xbdi_xen_req;
-	xbd_io = xbdi->xbdi_io = obj;
+	xbd_io = obj;
 	memset(xbd_io, 0, sizeof(*xbd_io));
 	buf_init(&xbd_io->xio_buf);
 	xbd_io->xio_xbdi = xbdi;
 	xbd_io->xio_operation = req->operation;
 	xbd_io->xio_id = req->id;
 	/* If segments are on an indirect page, copy them now */
 	if (xbdi->xbdi_in_gntref) {
 		gnttab_copy_t gop;
 		paddr_t ma;
 		gop.flags = GNTCOPY_source_gref;
 		gop.len = req->nr_segments
 @@ -1329,83 +1323,81 @@ xbdback_co_io_gotio(struct xbdback_insta
 	xbd_io->xio_buf.b_cflags = 0;
 	xbd_io->xio_buf.b_oflags = 0;
 	xbd_io->xio_buf.b_iodone = xbdback_iodone;
 	xbd_io->xio_buf.b_proc = NULL;
 	xbd_io->xio_buf.b_vp = xbdi->xbdi_vp;
 	xbd_io->xio_buf.b_objlock = xbdi->xbdi_vp->v_interlock;
 	xbd_io->xio_buf.b_dev = xbdi->xbdi_dev;
 	xbd_io->xio_buf.b_blkno = req->sector_number;
 	xbd_io->xio_buf.b_bcount = bcount;
 	xbd_io->xio_buf.b_data = NULL;
 	xbd_io->xio_buf.b_private = xbd_io;
 	xbdi->xbdi_cont = xbdback_co_do_io;
-	return xbdback_map_shm(xbdi->xbdi_io);
+	return xbdback_map_shm(xbd_io);
+}
 static void
 xbdback_io_error(struct xbdback_io *xbd_io, int error)
+{
 	xbd_io->xio_buf.b_error = error;
 	xbdback_iodone(&xbd_io->xio_buf);
+}
 /*
  * Main xbdback I/O routine. It can either perform a flush operation or
  * schedule a read/write operation.
  */
 static void *
 xbdback_co_do_io(struct xbdback_instance *xbdi, void *obj)
+{
-	struct xbdback_io *xbd_io = xbdi->xbdi_io;
+	struct xbdback_io *xbd_io = obj;
 	switch (xbd_io->xio_operation) {
 	case BLKIF_OP_FLUSH_DISKCACHE:
+	{
 		int error;
 		int force = 1;
 		error = VOP_IOCTL(xbdi->xbdi_vp, DIOCCACHESYNC, &force, FWRITE,
 		    kauth_cred_get());
 		if (error) {
 			aprint_error("xbdback %s: DIOCCACHESYNC returned %d\n",
 			    xbdi->xbdi_xbusd->xbusd_path, error);
 			 if (error == EOPNOTSUPP || error == ENOTTY)
 				error = BLKIF_RSP_EOPNOTSUPP;
 			 else
 				error = BLKIF_RSP_ERROR;
 		} else
 			error = BLKIF_RSP_OKAY;
 		xbdback_send_reply(xbdi, xbd_io->xio_id,
 		    xbd_io->xio_operation, error);
 		xbdback_pool_put(&xbdback_io_pool, xbd_io);
 		xbdi_put(xbdi);
 		xbdi->xbdi_io = NULL;
 		xbdi->xbdi_cont = xbdback_co_main_incr;
 		return xbdi;
+	}
 	case BLKIF_OP_READ:
 	case BLKIF_OP_WRITE:
 		xbd_io->xio_buf.b_data = (void *)
 		    (xbd_io->xio_vaddr + xbd_io->xio_start_offset);
 		if ((xbd_io->xio_buf.b_flags & B_READ) == 0) {
 			mutex_enter(xbd_io->xio_buf.b_vp->v_interlock);
 			xbd_io->xio_buf.b_vp->v_numoutput++;
 			mutex_exit(xbd_io->xio_buf.b_vp->v_interlock);
+		}
 		/* will call xbdback_iodone() asynchronously when done */
 		bdev_strategy(&xbd_io->xio_buf);
 		xbdi->xbdi_io = NULL;
 		xbdi->xbdi_cont = xbdback_co_main_incr;
 		return xbdi;
 	default:
 		/* Should never happen */
 		panic("xbdback_co_do_io: unsupported operation %d",
 		    xbd_io->xio_operation);
+	}
+}
 /*
  * Called from softint(9) context when an I/O is done: for each request, send
  * back the associated reply to the domain.
+ *
 @@ -1543,36 +1535,36 @@ xbdback_map_shm(struct xbdback_io *xbd_i
 	error = xen_shm_map(xbd_io->xio_nrma, xbdi->xbdi_domid,
 	    xbd_io->xio_gref, xbd_io->xio_vaddr, xbd_io->xio_gh,
 	    (xbd_io->xio_operation == BLKIF_OP_WRITE) ? XSHM_RO : 0);
 	switch(error) {
 	case 0:
 #ifdef XENDEBUG_VBD
 		printf("handle ");
 		for (i = 0; i < xbd_io->xio_nrma; i++) {
 			printf("%u ", (u_int)xbd_io->xio_gh[i]);
+		}
 		printf("\n");
 #endif
-		return xbdi;
+		return xbd_io;
 	default:
 		if (ratecheck(&xbdi->xbdi_lasterr_time, &xbdback_err_intvl)) {
 			printf("xbdback_map_shm: xen_shm error %d ", error);
+		}
-		xbdback_io_error(xbdi->xbdi_io, error);
+		/* this will also free xbd_io via xbdback_iodone() */
 		xbdback_io_error(xbd_io, error);
 		SLIST_INSERT_HEAD(&xbdi->xbdi_va_free, xbd_io->xio_xv, xv_next);
 		xbd_io->xio_xv = NULL;
-		xbdi->xbdi_io = NULL;
+		/* do not retry */
 		// do not retry
 		xbdi->xbdi_cont = xbdback_co_main_incr;
 		return xbdi;
+	}
+}
 /* unmap a request from our virtual address space (request is done) */
 static void
 xbdback_unmap_shm(struct xbdback_io *xbd_io)
+{
 	struct xbdback_instance *xbdi = xbd_io->xio_xbdi;
 #ifdef XENDEBUG_VBD
 	int i;