 @@ -1,14 +1,14 @@
-/*      $NetBSD: xbdback_xenbus.c,v 1.89 2020/04/23 08:09:25 jdolecek Exp $      */
+/*      $NetBSD: xbdback_xenbus.c,v 1.90 2020/04/23 09:16:21 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,29 +16,28 @@
  * 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.89 2020/04/23 08:09:25 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xbdback_xenbus.c,v 1.90 2020/04/23 09:16:21 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>
 #include <sys/param.h>
 #include <sys/queue.h>
 @@ -217,31 +216,31 @@ struct xbdback_instance {
 	 */
 	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;
 	/* other state */
 	uint xbdi_pendingreqs; /* number of I/O in fly */
 	struct timeval xbdi_lasterr_time;    /* error time tracking */
 };
 /* Manipulation of the above reference count. */
-#define xbdi_get(xbdip) atomic_inc_uint(&(xbdip)->xbdi_refcnt)
+#define xbdi_get(xbdip) (xbdip)->xbdi_refcnt++
-#define xbdi_put(xbdip)                                      \
+#define xbdi_put(xbdip)						\
-do {                                                         \
+do {								\
-	if (atomic_dec_uint_nv(&(xbdip)->xbdi_refcnt) == 0)  \
+	if (--((xbdip)->xbdi_refcnt) == 0)  			\
-               xbdback_finish_disconnect(xbdip);             \
+               xbdback_finish_disconnect(xbdip);		\
 } while (/* CONSTCOND */ 0)
 static SLIST_HEAD(, xbdback_instance) xbdback_instances;
 static kmutex_t xbdback_lock;
 /* Interval between reports of I/O errors from frontend */
 static const struct timeval xbdback_err_intvl = { 1, 0 };
        void xbdbackattach(int);
 static int  xbdback_xenbus_create(struct xenbus_device *);
 static int  xbdback_xenbus_destroy(void *);
 static void xbdback_frontend_changed(void *, XenbusState);
 static void xbdback_backend_changed(struct xenbus_watch *,
 @@ -259,26 +258,28 @@ static void *xbdback_co_main_loop(struct
 static void *xbdback_co_main_incr(struct xbdback_instance *, void *);
 static void *xbdback_co_main_done2(struct xbdback_instance *, void *);
 static void *xbdback_co_cache_flush(struct xbdback_instance *, void *);
 static void *xbdback_co_cache_doflush(struct xbdback_instance *, void *);
 static void *xbdback_co_io(struct xbdback_instance *, void *);
 static void *xbdback_co_io_gotio(struct xbdback_instance *, void *);
 static void *xbdback_co_do_io(struct xbdback_instance *, void *);
 static void xbdback_io_error(struct xbdback_io *, int);
 static void xbdback_iodone(struct buf *);
 static void xbdback_iodone_locked(struct xbdback_instance *,
 		struct xbdback_io *, struct buf *);
 static void xbdback_send_reply(struct xbdback_instance *, uint64_t , int , int);
 static void *xbdback_map_shm(struct xbdback_io *);
 static void xbdback_unmap_shm(struct xbdback_io *);
 static struct xbdback_io *xbdback_io_get(struct xbdback_instance *);
 static void xbdback_io_put(struct xbdback_instance *, struct xbdback_io *);
 static void xbdback_thread(void *);
 static void xbdback_wakeup_thread(struct xbdback_instance *);
 static void xbdback_trampoline(struct xbdback_instance *, void *);
 static struct xenbus_backend_driver xbd_backend_driver = {
 	.xbakd_create = xbdback_xenbus_create,
 @@ -326,46 +327,48 @@ xbdback_xenbus_create(struct xenbus_devi
+	}
 	if (i == 0) {
 		aprint_error("xbdback: can't parse %s\n",
 		    xbusd->xbusd_path);
 		return EFTYPE;
+	}
 	handle = strtoul(&xbusd->xbusd_path[i+1], &ep, 10);
 	if (*ep != '\0') {
 		aprint_error("xbdback: can't parse %s\n",
 		    xbusd->xbusd_path);
 		return EFTYPE;
+	}
 	/* XXXSMP unlocked search */
 	if (xbdif_lookup(domid, handle)) {
 		return EEXIST;
 	xbdi = kmem_zalloc(sizeof(*xbdi), KM_SLEEP);
 	xbdi->xbdi_domid = domid;
 	xbdi->xbdi_handle = handle;
 	snprintf(xbdi->xbdi_name, sizeof(xbdi->xbdi_name), "xbdb%di%d",
 	    xbdi->xbdi_domid, xbdi->xbdi_handle);
 	mutex_enter(&xbdback_lock);
 	if (xbdif_lookup(domid, handle)) {
 		mutex_exit(&xbdback_lock);
 		kmem_free(xbdi, sizeof(*xbdi));
 		return EEXIST;
+	}
 	SLIST_INSERT_HEAD(&xbdback_instances, xbdi, next);
 	mutex_exit(&xbdback_lock);
 	/* initialize status and reference counter */
 	xbdi->xbdi_status = DISCONNECTED;
 	xbdi_get(xbdi);
 	mutex_init(&xbdi->xbdi_lock, MUTEX_DEFAULT, IPL_BIO);
 	cv_init(&xbdi->xbdi_cv, xbdi->xbdi_name);
 	mutex_enter(&xbdback_lock);
 	SLIST_INSERT_HEAD(&xbdback_instances, xbdi, next);
 	mutex_exit(&xbdback_lock);
 	xbusd->xbusd_u.b.b_cookie = xbdi;
 	xbusd->xbusd_u.b.b_detach = xbdback_xenbus_destroy;
 	xbusd->xbusd_otherend_changed = xbdback_frontend_changed;
 	xbdi->xbdi_xbusd = xbusd;
 	if (bus_dmamap_create(xbdi->xbdi_xbusd->xbusd_dmat, PAGE_SIZE,
 , PAGE_SIZE, PAGE_SIZE, BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW,
 	    &xbdi->xbdi_seg_dmamap) != 0) {
 		printf("%s: can't create dma map for indirect segments\n",
 		    xbdi->xbdi_name);
 		goto fail;
+	}
 @@ -842,106 +845,108 @@ abort:
+}
 /*
  * Used by a xbdi thread to signal that it is now disconnected.
  */
 static void
 xbdback_finish_disconnect(struct xbdback_instance *xbdi)
+{
 	KASSERT(mutex_owned(&xbdi->xbdi_lock));
 	KASSERT(xbdi->xbdi_status == DISCONNECTING);
 	xbdi->xbdi_status = DISCONNECTED;
-	cv_signal(&xbdi->xbdi_cv);
+	cv_broadcast(&xbdi->xbdi_cv);
+}
 static bool
 xbdif_lookup(domid_t dom , uint32_t handle)
+{
 	struct xbdback_instance *xbdi;
 	bool found = false;
-	mutex_enter(&xbdback_lock);
+	KASSERT(mutex_owned(&xbdback_lock));
 	SLIST_FOREACH(xbdi, &xbdback_instances, next) {
 		if (xbdi->xbdi_domid == dom && xbdi->xbdi_handle == handle) {
 			found = true;
 			break;
+		}
+	}
 	mutex_exit(&xbdback_lock);
 	return found;
+}
 static int
 xbdback_evthandler(void *arg)
+{
 	struct xbdback_instance *xbdi = arg;
 	XENPRINTF(("xbdback_evthandler domain %d: cont %p\n",
 	    xbdi->xbdi_domid, xbdi->xbdi_cont));
 	mutex_enter(&xbdi->xbdi_lock);
 	xbdback_wakeup_thread(xbdi);
 	mutex_exit(&xbdi->xbdi_lock);
 	return 1;
+}
 /*
  * Main thread routine for one xbdback instance. Woken up by
  * xbdback_evthandler when a domain has I/O work scheduled in a I/O ring.
  */
 static void
 xbdback_thread(void *arg)
+{
 	struct xbdback_instance *xbdi = arg;
 	mutex_enter(&xbdi->xbdi_lock);
 	for (;;) {
 		mutex_enter(&xbdi->xbdi_lock);
 		switch (xbdi->xbdi_status) {
 		case WAITING:
 			cv_wait(&xbdi->xbdi_cv, &xbdi->xbdi_lock);
 			mutex_exit(&xbdi->xbdi_lock);
 			break;
 		case RUN:
 			xbdi->xbdi_status = WAITING; /* reset state */
 			mutex_exit(&xbdi->xbdi_lock);
 			if (xbdi->xbdi_cont == NULL) {
 				xbdi->xbdi_cont = xbdback_co_main;
+			}
 			xbdback_trampoline(xbdi, xbdi);
 			break;
 		case DISCONNECTING:
 			if (xbdi->xbdi_pendingreqs > 0) {
 				/* there are pending I/Os. Wait for them. */
 				cv_wait(&xbdi->xbdi_cv, &xbdi->xbdi_lock);
-				mutex_exit(&xbdi->xbdi_lock);
+				continue;
 				break;
+			}
 			/* All I/Os should have been processed by now,
 			 * xbdi_refcnt should drop to 0 */
 			xbdi_put(xbdi);
 			KASSERT(xbdi->xbdi_refcnt == 0);
-			mutex_exit(&xbdi->xbdi_lock);
+			goto out;
-			kthread_exit(0);
+			/* NOTREACHED */
 			break;
 		default:
 			panic("%s: invalid state %d",
 			    xbdi->xbdi_name, xbdi->xbdi_status);
+		}
+	}
 out:
 	mutex_exit(&xbdi->xbdi_lock);
 	kthread_exit(0);
+}
 static void *
 xbdback_co_main(struct xbdback_instance *xbdi, void *obj)
+{
 	(void)obj;
 	xbdi->xbdi_req_prod = xbdi->xbdi_ring.ring_n.sring->req_prod;
 	xen_rmb(); /* ensure we see all requests up to req_prod */
 	/*
 	 * note that we'll eventually get a full ring of request.
 	 * in this case, MASK_BLKIF_IDX(req_cons) == MASK_BLKIF_IDX(req_prod)
 	 */
 @@ -1032,50 +1037,39 @@ fail:
 			break;
+		}
 	} else {
 		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)
+xbdback_co_main_incr(struct xbdback_instance *xbdi, void *obj __unused)
+{
-	(void)obj;
+	KASSERT(mutex_owned(&xbdi->xbdi_lock));
 	blkif_back_ring_t *ring = &xbdi->xbdi_ring.ring_n;
 	ring->req_cons++;
 	/*
 	 * Do not bother with locking here when checking for xbdi_status: if
 	 * we get a transient state, we will get the right value at
 	 * the next increment.
 	 */
 	if (xbdi->xbdi_status == DISCONNECTING)
 		xbdi->xbdi_cont = NULL;
 	else
 		xbdi->xbdi_cont = xbdback_co_main_loop;
 	/*
 	 * Each time the thread processes a full ring of requests, give
 	 * a chance to other threads to process I/Os too
 	 */
 	if ((ring->req_cons % BLKIF_RING_SIZE) == 0)
 		yield();
 	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;
 	RING_FINAL_CHECK_FOR_REQUESTS(&xbdi->xbdi_ring.ring_n, work_to_do);
 @@ -1240,28 +1234,30 @@ xbdback_co_io(struct xbdback_instance *x
 	xbdi->xbdi_cont = xbdback_co_main_incr;
 	return xbdi;
+}
 /* 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;
 	KASSERT(mutex_owned(&xbdi->xbdi_lock));
 	xbdi_get(xbdi);
-	atomic_inc_uint(&xbdi->xbdi_pendingreqs);
+	xbdi->xbdi_pendingreqs++;
 	req = &xbdi->xbdi_xen_req;
 	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;
 @@ -1321,47 +1317,54 @@ xbdback_co_io_gotio(struct xbdback_insta
 	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(xbd_io);
+}
 static void
 xbdback_io_error(struct xbdback_io *xbd_io, int error)
+{
-	xbd_io->xio_buf.b_error = error;
+	KASSERT(mutex_owned(&xbd_io->xio_xbdi->xbdi_lock));
 	xbdback_iodone(&xbd_io->xio_buf);
 	struct buf *bp = &xbd_io->xio_buf;
 	bp->b_error = error;
 	xbdback_iodone_locked(xbd_io->xio_xbdi, xbd_io, bp);
+}
 /*
  * 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 = obj;
 	switch (xbd_io->xio_operation) {
 	case BLKIF_OP_FLUSH_DISKCACHE:
+	{
 		int error;
 		int force = 1;
 		KASSERT(mutex_owned(&xbdi->xbdi_lock));
 		mutex_exit(&xbdi->xbdi_lock);
 		error = VOP_IOCTL(xbdi->xbdi_vp, DIOCCACHESYNC, &force, FWRITE,
 		    kauth_cred_get());
 		mutex_enter(&xbdi->xbdi_lock);
 		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_io_put(xbdi, xbd_io);
 		xbdi_put(xbdi);
 @@ -1382,157 +1385,168 @@ xbdback_co_do_io(struct xbdback_instance
 		bdev_strategy(&xbd_io->xio_buf);
 		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.
  * This gets reused by xbdback_io_error to report errors from other sources.
  */
 static void
 xbdback_iodone(struct buf *bp)
+{
 	struct xbdback_io *xbd_io;
 	struct xbdback_instance *xbdi;
 	int status;
 	KERNEL_LOCK(1, NULL);		/* XXXSMP */
 	xbd_io = bp->b_private;
 	KASSERT(bp == &xbd_io->xio_buf);
 	xbdi = xbd_io->xio_xbdi;
 	mutex_enter(&xbdi->xbdi_lock);
 	xbdback_iodone_locked(xbdi, xbd_io, bp);
 	mutex_exit(&xbdi->xbdi_lock);
+}
 /*
  * This gets reused by xbdback_io_error to report errors from other sources.
  */
 static void
 xbdback_iodone_locked(struct xbdback_instance *xbdi, struct xbdback_io *xbd_io,
     struct buf *bp)
+{
 	int status;
 	XENPRINTF(("xbdback_io domain %d: iodone ptr 0x%lx\n",
 		   xbdi->xbdi_domid, (long)xbd_io));
 	KASSERT(mutex_owned(&xbdi->xbdi_lock));
 	KASSERT(bp->b_error != 0 || xbd_io->xio_xv != NULL);
 	if (xbd_io->xio_xv != NULL)
 		xbdback_unmap_shm(xbd_io);
 	if (bp->b_error != 0) {
 		printf("xbd IO domain %d: error %d\n",
 		       xbdi->xbdi_domid, bp->b_error);
 		status = BLKIF_RSP_ERROR;
 	} else
 		status = BLKIF_RSP_OKAY;
 	xbdback_send_reply(xbdi, xbd_io->xio_id, xbd_io->xio_operation, status);
 	xbdi_put(xbdi);
-	atomic_dec_uint(&xbdi->xbdi_pendingreqs);
+	KASSERT(xbdi->xbdi_pendingreqs > 0);
 	xbdi->xbdi_pendingreqs--;
 	buf_destroy(&xbd_io->xio_buf);
 	xbdback_io_put(xbdi, xbd_io);
 	xbdback_wakeup_thread(xbdi);
 	KERNEL_UNLOCK_ONE(NULL);	/* XXXSMP */
+}
 /*
  * Wake up the per xbdback instance thread.
  */
 static void
 xbdback_wakeup_thread(struct xbdback_instance *xbdi)
+{
 	KASSERT(mutex_owned(&xbdi->xbdi_lock));
 	mutex_enter(&xbdi->xbdi_lock);
 	/* only set RUN state when we are WAITING for work */
 	if (xbdi->xbdi_status == WAITING)
 	       xbdi->xbdi_status = RUN;
-	cv_broadcast(&xbdi->xbdi_cv);
+	cv_signal(&xbdi->xbdi_cv);
 	mutex_exit(&xbdi->xbdi_lock);
+}
 /*
  * called once a request has completed. Place the reply in the ring and
  * notify the guest OS.
  */
 static void
 xbdback_send_reply(struct xbdback_instance *xbdi, uint64_t id,
     int op, int status)
+{
 	blkif_response_t *resp_n;
 	blkif_x86_32_response_t *resp32;
 	blkif_x86_64_response_t *resp64;
 	int notify;
 	KASSERT(mutex_owned(&xbdi->xbdi_lock));
 	/*
 	 * The ring can be accessed by the xbdback thread, xbdback_iodone()
 	 * handler, or any handler that triggered the shm callback. So
 	 * protect ring access via the xbdi_lock mutex.
 	 */
 	mutex_enter(&xbdi->xbdi_lock);
 	switch (xbdi->xbdi_proto) {
 	case XBDIP_NATIVE:
 		resp_n = RING_GET_RESPONSE(&xbdi->xbdi_ring.ring_n,
 		    xbdi->xbdi_ring.ring_n.rsp_prod_pvt);
 		resp_n->id        = id;
 		resp_n->operation = op;
 		resp_n->status    = status;
 		break;
 	case XBDIP_32:
 		resp32 = RING_GET_RESPONSE(&xbdi->xbdi_ring.ring_32,
 		    xbdi->xbdi_ring.ring_n.rsp_prod_pvt);
 		resp32->id        = id;
 		resp32->operation = op;
 		resp32->status    = status;
 		break;
 	case XBDIP_64:
 		resp64 = RING_GET_RESPONSE(&xbdi->xbdi_ring.ring_64,
 		    xbdi->xbdi_ring.ring_n.rsp_prod_pvt);
 		resp64->id        = id;
 		resp64->operation = op;
 		resp64->status    = status;
 		break;
+	}
 	xbdi->xbdi_ring.ring_n.rsp_prod_pvt++;
 	RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&xbdi->xbdi_ring.ring_n, notify);
 	mutex_exit(&xbdi->xbdi_lock);
 	if (notify) {
 		XENPRINTF(("xbdback_send_reply notify %d\n", xbdi->xbdi_domid));
 		hypervisor_notify_via_evtchn(xbdi->xbdi_evtchn);
+	}
+}
 /*
  * Map multiple entries of an I/O request into backend's VA space.
  * The xbd_io->xio_gref array has to be filled out by the caller.
  */
 static void *
 xbdback_map_shm(struct xbdback_io *xbd_io)
+{
 	struct xbdback_instance *xbdi = xbd_io->xio_xbdi;
-	int error, s;
+	int error;
 #ifdef XENDEBUG_VBD
 	int i;
 	printf("xbdback_map_shm map grant ");
 	for (i = 0; i < xbd_io->xio_nrma; i++) {
 		printf("%u ", (u_int)xbd_io->xio_gref[i]);
+	}
 #endif
-	s = splvm();	/* XXXSMP */
+	KASSERT(mutex_owned(&xbdi->xbdi_lock));
 	xbd_io->xio_xv = SLIST_FIRST(&xbdi->xbdi_va_free);
 	KASSERT(xbd_io->xio_xv != NULL);
 	SLIST_REMOVE_HEAD(&xbdi->xbdi_va_free, xv_next);
 	xbd_io->xio_vaddr = xbd_io->xio_xv->xv_vaddr;
 	splx(s);
 	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");