 @@ -1,14 +1,14 @@
-/*      $NetBSD: xbd_xenbus.c,v 1.56 2012/02/22 16:53:46 jakllsch Exp $      */
+/*      $NetBSD: xbd_xenbus.c,v 1.57 2012/05/25 15:03:38 elric 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 xbdstart() 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.56 2012/02/22 16:53:46 jakllsch Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xbd_xenbus.c,v 1.57 2012/05/25 15:03:38 elric 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>
 @@ -112,29 +112,27 @@ struct xbd_req {
 	    struct {
 		int s_error;
 		volatile int s_done;
 	    } req_sync;
 	} u;
 };
 #define req_gntref	u.req_rw.req_gntref
 #define req_nr_segments	u.req_rw.req_nr_segments
 #define req_bp		u.req_rw.req_bp
 #define req_data	u.req_rw.req_data
 #define req_sync	u.req_sync
 struct xbd_xenbus_softc {
-	device_t sc_dev;
+	struct dk_softc sc_dksc;	/* Must be first in this struct */
 	struct dk_softc sc_dksc;
 	struct dk_intf *sc_di;
 	struct xenbus_device *sc_xbusd;
 	blkif_front_ring_t sc_ring;
 	unsigned int sc_evtchn;
 	grant_ref_t sc_ring_gntref;
 	struct xbd_req sc_reqs[XBD_RING_SIZE];
 	SLIST_HEAD(,xbd_req) sc_xbdreq_head; /* list of free requests */
 	bool sc_xbdreq_wait; /* special waiting on xbd_req */
 	int sc_backend_status; /* our status with backend */
 @@ -202,27 +200,27 @@ const struct cdevsw xbd_cdevsw = {
 	nostop, notty, nopoll, nommap, nokqfilter, D_DISK
 };
 extern struct cfdriver xbd_cd;
 /* Pseudo-disk Interface */
 static struct dk_intf dkintf_esdi = {
         DTYPE_ESDI,
 	"Xen Virtual ESDI",
 	xbdopen,
 	xbdclose,
 	xbdstrategy,
 	xbdstart,
-};
+}, *di = &dkintf_esdi;
 static struct dkdriver xbddkdriver = {
         .d_strategy = xbdstrategy,
 	.d_minphys = xbdminphys,
 };
 static int
 xbd_xenbus_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct xenbusdev_attach_args *xa = aux;
 	if (strcmp(xa->xa_type, "vbd") != 0)
 		return 0;
 @@ -241,56 +239,55 @@ xbd_xenbus_attach(device_t parent, devic
 	struct xenbusdev_attach_args *xa = aux;
 	blkif_sring_t *ring;
 	RING_IDX i;
 #ifdef XBD_DEBUG
 	char **dir, *val;
 	int dir_n = 0;
 	char id_str[20];
 	int err;
 #endif
 	config_pending_incr();
 	aprint_normal(": Xen Virtual Block Device Interface\n");
-	sc->sc_dev = self;
+	dk_sc_init(&sc->sc_dksc, device_xname(self));
 	sc->sc_dksc.sc_dev = self;
 #ifdef XBD_DEBUG
 	printf("path: %s\n", xa->xa_xbusd->xbusd_path);
 	snprintf(id_str, sizeof(id_str), "%d", xa->xa_id);
 	err = xenbus_directory(NULL, "device/vbd", id_str, &dir_n, &dir);
 	if (err) {
 		aprint_error_dev(self, "xenbus_directory err %d\n", err);
 	} else {
 		printf("%s/\n", xa->xa_xbusd->xbusd_path);
 		for (i = 0; i < dir_n; i++) {
 			printf("\t/%s", dir[i]);
 			err = xenbus_read(NULL, xa->xa_xbusd->xbusd_path,
 					  dir[i], NULL, &val);
 			if (err) {
 				aprint_error_dev(self, "xenbus_read err %d\n",
 						 err);
 			} else {
 				printf(" = %s\n", val);
 				free(val, M_DEVBUF);
+			}
+		}
+	}
 #endif /* XBD_DEBUG */
 	sc->sc_xbusd = xa->xa_xbusd;
 	sc->sc_xbusd->xbusd_otherend_changed = xbd_backend_changed;
 	dk_sc_init(&sc->sc_dksc, sc, device_xname(self));
 	disk_init(&sc->sc_dksc.sc_dkdev, device_xname(self), &xbddkdriver);
 	sc->sc_di = &dkintf_esdi;
 	/* initialize free requests list */
 	SLIST_INIT(&sc->sc_xbdreq_head);
 	for (i = 0; i < XBD_RING_SIZE; i++) {
 		sc->sc_reqs[i].req_id = i;
 		SLIST_INSERT_HEAD(&sc->sc_xbdreq_head, &sc->sc_reqs[i],
 		    req_next);
+	}
 	sc->sc_backend_status = BLKIF_STATE_DISCONNECTED;
 	sc->sc_shutdown = BLKIF_SHUTDOWN_REMOTE;
 	ring = (void *)uvm_km_alloc(kernel_map, PAGE_SIZE, 0, UVM_KMF_WIRED);
 	if (ring == NULL)
 @@ -511,27 +508,27 @@ abort_transaction:
 	xenbus_dev_fatal(sc->sc_xbusd, error, "%s", errmsg);
 	return false;
+}
 static void xbd_backend_changed(void *arg, XenbusState new_state)
+{
 	struct xbd_xenbus_softc *sc = device_private((device_t)arg);
 	struct dk_geom *pdg;
 	prop_dictionary_t disk_info, odisk_info, geom;
 	char buf[9];
 	int s;
 	DPRINTF(("%s: new backend state %d\n",
-	    device_xname(sc->sc_dev), new_state));
+	    device_xname(sc->sc_dksc.sc_dev), new_state));
 	switch (new_state) {
 	case XenbusStateUnknown:
 	case XenbusStateInitialising:
 	case XenbusStateInitWait:
 	case XenbusStateInitialised:
 		break;
 	case XenbusStateClosing:
 		s = splbio();
 		if (sc->sc_shutdown == BLKIF_SHUTDOWN_RUN)
 			sc->sc_shutdown = BLKIF_SHUTDOWN_REMOTE;
 		/* wait for requests to complete */
 		while (sc->sc_backend_status == BLKIF_STATE_CONNECTED &&
 @@ -561,49 +558,49 @@ static void xbd_backend_changed(void *ar
 		pdg = &sc->sc_dksc.sc_geom;
 		pdg->pdg_secsize = DEV_BSIZE;
 		pdg->pdg_ntracks = 1;
 		pdg->pdg_nsectors = 1024 * (1024 / pdg->pdg_secsize);
 		pdg->pdg_ncylinders = sc->sc_dksc.sc_size / pdg->pdg_nsectors;
 		bufq_alloc(&sc->sc_dksc.sc_bufq, "fcfs", 0);
 		sc->sc_dksc.sc_flags |= DKF_INITED;
 		disk_attach(&sc->sc_dksc.sc_dkdev);
 		sc->sc_backend_status = BLKIF_STATE_CONNECTED;
 		/* try to read the disklabel */
-		dk_getdisklabel(sc->sc_di, &sc->sc_dksc, 0 /* XXX ? */);
+		dk_getdisklabel(di, &sc->sc_dksc, 0 /* XXX ? */);
 		format_bytes(buf, sizeof(buf), sc->sc_sectors * sc->sc_secsize);
-		aprint_verbose_dev(sc->sc_dev,
+		aprint_verbose_dev(sc->sc_dksc.sc_dev,
 				"%s, %d bytes/sect x %" PRIu64 " sectors\n",
 				buf, (int)pdg->pdg_secsize, sc->sc_xbdsize);
 		/* Discover wedges on this disk. */
 		dkwedge_discover(&sc->sc_dksc.sc_dkdev);
 		disk_info = prop_dictionary_create();
 		geom = prop_dictionary_create();
 		prop_dictionary_set_uint64(geom, "sectors-per-unit",
 		    sc->sc_dksc.sc_size);
 		prop_dictionary_set_uint32(geom, "sector-size",
 		    pdg->pdg_secsize);
 		prop_dictionary_set_uint16(geom, "sectors-per-track",
 		    pdg->pdg_nsectors);
 		prop_dictionary_set_uint16(geom, "tracks-per-cylinder",
 		    pdg->pdg_ntracks);
 		prop_dictionary_set_uint64(geom, "cylinders-per-unit",
 		    pdg->pdg_ncylinders);
 		prop_dictionary_set(disk_info, "geometry", geom);
 		prop_object_release(geom);
-		prop_dictionary_set(device_properties(sc->sc_dev),
+		prop_dictionary_set(device_properties(sc->sc_dksc.sc_dev),
 		    "disk-info", disk_info);
 		/*
 		 * Don't release disk_info here; we keep a reference to it.
 		 * disk_detach() will release it when we go away.
 		 */
 		odisk_info = sc->sc_dksc.sc_dkdev.dk_info;
 		sc->sc_dksc.sc_dkdev.dk_info = disk_info;
 		if (odisk_info)
 			prop_object_release(odisk_info);
 		/* the disk should be working now */
 		config_pending_decr();
 		break;
 @@ -613,101 +610,105 @@ static void xbd_backend_changed(void *ar
+}
 static void
 xbd_connect(struct xbd_xenbus_softc *sc)
+{
 	int err;
 	unsigned long long sectors;
 	u_long cache_flush;
 	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_dev), sc->sc_xbusd->xbusd_otherend);
+		    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_dev), sc->sc_xbusd->xbusd_otherend);
+		    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_dev), sc->sc_xbusd->xbusd_otherend);
+		    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_dev), sc->sc_xbusd->xbusd_otherend);
+		    device_xname(sc->sc_dksc.sc_dev),
 		    sc->sc_xbusd->xbusd_otherend);
 	err = xenbus_read_ul(NULL, sc->sc_xbusd->xbusd_otherend,
 	    "feature-flush-cache", &cache_flush, 10);
 	if (err)
 		cache_flush = 0;
 	if (cache_flush > 0)
 		sc->sc_cache_flush = 1;
 	else
 		sc->sc_cache_flush = 0;
 	xenbus_switch_state(sc->sc_xbusd, NULL, XenbusStateConnected);
+}
 static int
 xbd_handler(void *arg)
+{
 	struct xbd_xenbus_softc *sc = arg;
 	struct buf *bp;
 	RING_IDX resp_prod, i;
 	int more_to_do;
 	int seg;
-	DPRINTF(("xbd_handler(%s)\n", device_xname(sc->sc_dev)));
+	DPRINTF(("xbd_handler(%s)\n", device_xname(sc->sc_dksc.sc_dev)));
 	if (__predict_false(sc->sc_backend_status != BLKIF_STATE_CONNECTED))
 		return 0;
 again:
 	resp_prod = sc->sc_ring.sring->rsp_prod;
 	xen_rmb(); /* ensure we see replies up to resp_prod */
 	for (i = sc->sc_ring.rsp_cons; i != resp_prod; i++) {
 		blkif_response_t *rep = RING_GET_RESPONSE(&sc->sc_ring, i);
 		struct xbd_req *xbdreq = &sc->sc_reqs[rep->id];
 		DPRINTF(("xbd_handler(%p): b_bcount = %ld\n",
 		    xbdreq->req_bp, (long)bp->b_bcount));
 		bp = xbdreq->req_bp;
 		if (rep->operation == BLKIF_OP_FLUSH_DISKCACHE) {
 			xbdreq->req_sync.s_error = rep->status;
 			xbdreq->req_sync.s_done = 1;
 			wakeup(xbdreq);
 			/* caller will free the req */
 			continue;
+		}
 		for (seg = xbdreq->req_nr_segments - 1; seg >= 0; seg--) {
 			if (__predict_false(
 			    xengnt_status(xbdreq->req_gntref[seg]))) {
-				aprint_verbose_dev(sc->sc_dev,
+				aprint_verbose_dev(sc->sc_dksc.sc_dev,
 					"grant still used by backend\n");
 				sc->sc_ring.rsp_cons = i;
 				xbdreq->req_nr_segments = seg + 1;
 				goto done;
+			}
 			xengnt_revoke_access(xbdreq->req_gntref[seg]);
 			xbdreq->req_nr_segments--;
+		}
 		if (rep->operation != BLKIF_OP_READ &&
 		    rep->operation != BLKIF_OP_WRITE) {
-			aprint_error_dev(sc->sc_dev,
+			aprint_error_dev(sc->sc_dksc.sc_dev,
 			    "bad operation %d from backend\n", rep->operation);
 			bp->b_error = EIO;
 			bp->b_resid = bp->b_bcount;
 			goto next;
+		}
 		if (rep->status != BLKIF_RSP_OKAY) {
 			bp->b_error = EIO;
 			bp->b_resid = bp->b_bcount;
 			goto next;
+		}
 		/* b_resid was set in xbdstart */
 next:
 		if (bp->b_data != xbdreq->req_data)
 @@ -718,104 +719,104 @@ next:
 		rnd_add_uint32(&sc->sc_rnd_source,
 		    bp->b_blkno);
 		biodone(bp);
 		SLIST_INSERT_HEAD(&sc->sc_xbdreq_head, xbdreq, req_next);
+	}
 done:
 	xen_rmb();
 	sc->sc_ring.rsp_cons = i;
 	RING_FINAL_CHECK_FOR_RESPONSES(&sc->sc_ring, more_to_do);
 	if (more_to_do)
 		goto again;
-	dk_iodone(sc->sc_di, &sc->sc_dksc);
+	dk_iodone(di, &sc->sc_dksc);
 	if (sc->sc_xbdreq_wait)
 		wakeup(&sc->sc_xbdreq_wait);
 	return 1;
+}
 static void
 xbdminphys(struct buf *bp)
+{
 	if (bp->b_bcount > XBD_MAX_XFER) {
 		bp->b_bcount = XBD_MAX_XFER;
+	}
 	minphys(bp);
+}
 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);
 	if ((flags & FWRITE) && (sc->sc_info & VDISK_READONLY))
 		return EROFS;
 	DPRINTF(("xbdopen(0x%04x, %d)\n", dev, flags));
-	return dk_open(sc->sc_di, &sc->sc_dksc, dev, flags, fmt, l);
+	return dk_open(di, &sc->sc_dksc, dev, flags, fmt, l);
+}
 int
 xbdclose(dev_t dev, int flags, int fmt, struct lwp *l)
+{
 	struct xbd_xenbus_softc *sc;
 	sc = device_lookup_private(&xbd_cd, DISKUNIT(dev));
 	DPRINTF(("xbdclose(%d, %d)\n", dev, flags));
-	return dk_close(sc->sc_di, &sc->sc_dksc, dev, flags, fmt, l);
+	return dk_close(di, &sc->sc_dksc, dev, flags, fmt, l);
+}
 void
 xbdstrategy(struct buf *bp)
+{
 	struct xbd_xenbus_softc *sc;
 	sc = device_lookup_private(&xbd_cd, DISKUNIT(bp->b_dev));
 	DPRINTF(("xbdstrategy(%p): b_bcount = %ld\n", bp,
 	    (long)bp->b_bcount));
 	if (sc == NULL || sc->sc_shutdown != BLKIF_SHUTDOWN_RUN) {
 		bp->b_error = EIO;
 		biodone(bp);
 		return;
+	}
 	if (__predict_false((sc->sc_info & VDISK_READONLY) &&
 	    (bp->b_flags & B_READ) == 0)) {
 		bp->b_error = EROFS;
 		biodone(bp);
 		return;
+	}
-	dk_strategy(sc->sc_di, &sc->sc_dksc, bp);
+	dk_strategy(di, &sc->sc_dksc, bp);
 	return;
+}
 int
 xbdsize(dev_t dev)
+{
 	struct	xbd_xenbus_softc *sc;
 	DPRINTF(("xbdsize(%d)\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_di, &sc->sc_dksc, dev);
+	return dk_size(di, &sc->sc_dksc, dev);
+}
 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 ((dksc->sc_flags & DKF_INITED) == 0)
 		return ENXIO;
 	return physio(xbdstrategy, NULL, dev, B_READ, xbdminphys, uio);
+}
 @@ -853,27 +854,27 @@ xbdioctl(dev_t dev, u_long cmd, void *da
 	dk = &dksc->sc_dkdev;
 	error = disk_ioctl(&sc->sc_dksc.sc_dkdev, cmd, data, flag, l);
 	if (error != EPASSTHROUGH)
 		return (error);
 	switch (cmd) {
 	case DIOCSSTRATEGY:
 		error = EOPNOTSUPP;
 		break;
 	case DIOCCACHESYNC:
 		if (sc->sc_cache_flush <= 0) {
 			if (sc->sc_cache_flush == 0) {
-				aprint_error_dev(sc->sc_dev,
+				aprint_error_dev(sc->sc_dksc.sc_dev,
 				    "WARNING: cache flush not supported "
 				    "by backend\n");
 				sc->sc_cache_flush = -1;
+			}
 			return EOPNOTSUPP;
+		}
 		s = splbio();
 		while (RING_FULL(&sc->sc_ring)) {
 			sc->sc_xbdreq_wait = 1;
 			tsleep(&sc->sc_xbdreq_wait, PRIBIO, "xbdreq", 0);
+		}
 @@ -903,97 +904,94 @@ xbdioctl(dev_t dev, u_long cmd, void *da
 			if (xbdreq->req_sync.s_error == BLKIF_RSP_EOPNOTSUPP)
 				error = EOPNOTSUPP;
 			else if (xbdreq->req_sync.s_error == BLKIF_RSP_OKAY)
 				error = 0;
 			else
 				error = EIO;
 			SLIST_INSERT_HEAD(&sc->sc_xbdreq_head, xbdreq,
 			    req_next);
+		}
 		splx(s);
 		break;
 	default:
-		error = dk_ioctl(sc->sc_di, dksc, dev, cmd, data, flag, l);
+		error = dk_ioctl(di, dksc, dev, cmd, data, flag, l);
 		break;
+	}
 	return error;
+}
 int
 xbddump(dev_t dev, daddr_t blkno, void *va, size_t size)
+{
 	struct xbd_xenbus_softc *sc;
 	sc  = device_lookup_private(&xbd_cd, DISKUNIT(dev));
 	if (sc == NULL)
 		return (ENXIO);
 	DPRINTF(("xbddump(%d, %" PRId64 ", %p, %lu)\n", dev, blkno, va,
 	    (unsigned long)size));
-	return dk_dump(sc->sc_di, &sc->sc_dksc, dev, blkno, va, size);
+	return dk_dump(di, &sc->sc_dksc, dev, blkno, va, size);
+}
 static int
 xbdstart(struct dk_softc *dksc, struct buf *bp)
+{
-	struct xbd_xenbus_softc *sc;
+	struct xbd_xenbus_softc *sc = (struct xbd_xenbus_softc *)dksc;
 	struct xbd_req *xbdreq;
 	blkif_request_t *req;
 	int ret = 0, runqueue = 1;
 	size_t bcount, off;
 	paddr_t ma;
 	vaddr_t va;
 	int nsects, nbytes, seg;
 	int notify;
 	DPRINTF(("xbdstart(%p): b_bcount = %ld\n", bp, (long)bp->b_bcount));
-	sc = device_lookup_private(&xbd_cd, DISKUNIT(bp->b_dev));
+	if (sc->sc_shutdown != BLKIF_SHUTDOWN_RUN) {
 	if (sc == NULL || sc->sc_shutdown != BLKIF_SHUTDOWN_RUN) {
 		bp->b_error = EIO;
 		goto err;
+	}
 	if (bp->b_rawblkno < 0 || bp->b_rawblkno > sc->sc_xbdsize) {
 		/* invalid block number */
 		bp->b_error = EINVAL;
 		goto err;
+	}
 	if (bp->b_rawblkno == sc->sc_xbdsize) {
 		/* at end of disk; return short read */
 		bp->b_resid = bp->b_bcount;
 		biodone(bp);
 		return 0;
+	}
 	if (__predict_false(sc->sc_backend_status == BLKIF_STATE_SUSPENDED)) {
 		/* device is suspended, do not consume buffer */
 		DPRINTF(("%s: (xbdstart) device suspended\n",
-		    device_xname(sc->sc_dev)));
+		    device_xname(sc->sc_dksc.sc_dev)));
 		ret = -1;
 		goto out;
+	}
 	if (RING_FULL(&sc->sc_ring) || sc->sc_xbdreq_wait) {
 		DPRINTF(("xbdstart: ring_full\n"));
 		ret = -1;
 		goto out;
+	}
 	dksc = &sc->sc_dksc;
 	xbdreq = SLIST_FIRST(&sc->sc_xbdreq_head);
 	if (__predict_false(xbdreq == NULL)) {
 		DPRINTF(("xbdstart: no req\n"));
 		ret = -1; /* dk_start should not remove bp from queue */
 		goto out;
+	}
 	xbdreq->req_bp = bp;
 	xbdreq->req_data = bp->b_data;
 	if ((vaddr_t)bp->b_data & (XEN_BSIZE - 1)) {
 		if (__predict_false(xbd_map_align(xbdreq) != 0)) {
 			ret = -1;
 			goto out;