 @@ -1,14 +1,14 @@
-/*	$NetBSD: ld_ataraid.c,v 1.44 2016/09/27 08:05:34 pgoyette Exp $	*/
+/*	$NetBSD: ld_ataraid.c,v 1.45 2018/06/03 10:20:54 martin Exp $ */
 /*
  * Copyright (c) 2003 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
+ *
  * 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
 @@ -32,32 +32,32 @@
  * 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.
  */
 /*
  * Support for ATA RAID logical disks.
+ *
  * Note that all the RAID happens in software here; the ATA RAID
  * controllers we're dealing with (Promise, etc.) only support
  * configuration data on the component disks, with the BIOS supporting
  * booting from the RAID volumes.
+ *
  * bio(4) support was written by Juan Romero Pardines <xtraeme@gmail.com>.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ld_ataraid.c,v 1.44 2016/09/27 08:05:34 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ld_ataraid.c,v 1.45 2018/06/03 10:20:54 martin Exp $");
 #if defined(_KERNEL_OPT)
 #include "bio.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/conf.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/dkio.h>
 @@ -82,31 +82,31 @@ __KERNEL_RCSID(0, "$NetBSD: ld_ataraid.c
 #include <dev/ata/ata_raidvar.h>
 #include "ioconf.h"
 struct ld_ataraid_softc {
 	struct ld_softc sc_ld;
 	struct ataraid_array_info *sc_aai;
 	struct vnode *sc_vnodes[ATA_RAID_MAX_DISKS];
 	void	(*sc_iodone)(struct buf *);
-       pool_cache_t sc_cbufpool;
+	pool_cache_t sc_cbufpool;
-       SIMPLEQ_HEAD(, cbuf) sc_cbufq;
+	SIMPLEQ_HEAD(, cbuf) sc_cbufq;
-       void    *sc_sih_cookie;
+	void	*sc_sih_cookie;
 };
 static int	ld_ataraid_match(device_t, cfdata_t, void *);
 static void	ld_ataraid_attach(device_t, device_t, void *);
 static int	ld_ataraid_dump(struct ld_softc *, void *, int, int);
 static int     cbufpool_ctor(void *, void *, int);
 static void    cbufpool_dtor(void *, void *);
 static void    ld_ataraid_start_vstrategy(void *);
 static int	ld_ataraid_start_span(struct ld_softc *, struct buf *);
 @@ -115,64 +115,64 @@ static void	ld_ataraid_iodone_raid0(stru
 #if NBIO > 0
 static int	ld_ataraid_bioctl(device_t, u_long, void *);
 static int	ld_ataraid_bioinq(struct ld_ataraid_softc *, struct bioc_inq *);
 static int	ld_ataraid_biovol(struct ld_ataraid_softc *, struct bioc_vol *);
 static int	ld_ataraid_biodisk(struct ld_ataraid_softc *,
 				   struct bioc_disk *);
 #endif
 CFATTACH_DECL_NEW(ld_ataraid, sizeof(struct ld_ataraid_softc),
     ld_ataraid_match, ld_ataraid_attach, NULL, NULL);
 struct cbuf {
-	struct buf	cb_buf;		/* new I/O buf */
+	struct buf	cb_buf; 	/* new I/O buf */
 	struct buf	*cb_obp;	/* ptr. to original I/O buf */
-	struct ld_ataraid_softc *cb_sc;	/* pointer to ld softc */
+	struct ld_ataraid_softc *cb_sc; /* pointer to ld softc */
 	u_int		cb_comp;	/* target component */
 	SIMPLEQ_ENTRY(cbuf) cb_q;	/* fifo of component buffers */
 	struct cbuf	*cb_other;	/* other cbuf in case of mirror */
 	int		cb_flags;
-#define	CBUF_IODONE	0x00000001	/* I/O is already successfully done */
+#define CBUF_IODONE	0x00000001	/* I/O is already successfully done */
 };
 #define        CBUF_GET()      pool_cache_get(sc->sc_cbufpool, PR_NOWAIT);
 #define        CBUF_PUT(cbp)   pool_cache_put(sc->sc_cbufpool, (cbp))
 static int
 ld_ataraid_match(device_t parent, cfdata_t match, void *aux)
+{
 	return (1);
+}
 static void
 ld_ataraid_attach(device_t parent, device_t self, void *aux)
+{
 	struct ld_ataraid_softc *sc = device_private(self);
 	struct ld_softc *ld = &sc->sc_ld;
 	struct ataraid_array_info *aai = aux;
 	struct ataraid_disk_info *adi = NULL;
 	const char *level;
 	struct vnode *vp;
 	char unklev[32];
 	u_int i;
 	ld->sc_dv = self;
-       sc->sc_cbufpool = pool_cache_init(sizeof(struct cbuf), 0,
+	sc->sc_cbufpool = pool_cache_init(sizeof(struct cbuf), 0,
 , 0, "ldcbuf", NULL, IPL_BIO, cbufpool_ctor, cbufpool_dtor, sc);
-       sc->sc_sih_cookie = softint_establish(SOFTINT_BIO,
+	sc->sc_sih_cookie = softint_establish(SOFTINT_BIO,
-           ld_ataraid_start_vstrategy, sc);
+	    ld_ataraid_start_vstrategy, sc);
 	sc->sc_aai = aai;	/* this data persists */
 	ld->sc_maxxfer = MAXPHYS * aai->aai_width;	/* XXX */
 	ld->sc_secperunit = aai->aai_capacity;
 	ld->sc_secsize = 512;				/* XXX */
 	ld->sc_maxqueuecnt = 128;			/* XXX */
 	ld->sc_dump = ld_ataraid_dump;
 	switch (aai->aai_level) {
 	case AAI_L_SPAN:
 		level = "SPAN";
 		ld->sc_start = ld_ataraid_start_span;
 @@ -250,91 +250,91 @@ ld_ataraid_attach(device_t parent, devic
  finish:
 #if NBIO > 0
 	if (bio_register(self, ld_ataraid_bioctl) != 0)
 		panic("%s: bioctl registration failed\n",
 		    device_xname(ld->sc_dv));
 #endif
 	SIMPLEQ_INIT(&sc->sc_cbufq);
 	ldattach(ld, BUFQ_DISK_DEFAULT_STRAT);
+}
 static int
 cbufpool_ctor(void *arg, void *obj, int flags)
+{
-       struct ld_ataraid_softc *sc = arg;
+	struct ld_ataraid_softc *sc = arg;
-       struct ld_softc *ld = &sc->sc_ld;
+	struct ld_softc *ld = &sc->sc_ld;
-       struct cbuf *cbp = obj;
+	struct cbuf *cbp = obj;
-       /* We release/reacquire the spinlock before calling buf_init() */
+	/* We release/reacquire the spinlock before calling buf_init() */
-       mutex_exit(&ld->sc_mutex);
+	mutex_exit(&ld->sc_mutex);
-       buf_init(&cbp->cb_buf);
+	buf_init(&cbp->cb_buf);
-       mutex_enter(&ld->sc_mutex);
+	mutex_enter(&ld->sc_mutex);
-       return 0;
+	return 0;
+}
 static void
 cbufpool_dtor(void *arg, void *obj)
+{
-       struct cbuf *cbp = obj;
+	struct cbuf *cbp = obj;
-       buf_destroy(&cbp->cb_buf);
+	buf_destroy(&cbp->cb_buf);
+}
 static struct cbuf *
 ld_ataraid_make_cbuf(struct ld_ataraid_softc *sc, struct buf *bp,
     u_int comp, daddr_t bn, void *addr, long bcount)
+{
 	struct cbuf *cbp;
 	cbp = CBUF_GET();
 	if (cbp == NULL)
-               return NULL;
+		return NULL;
 	cbp->cb_buf.b_flags = bp->b_flags;
 	cbp->cb_buf.b_oflags = bp->b_oflags;
 	cbp->cb_buf.b_cflags = bp->b_cflags;
 	cbp->cb_buf.b_iodone = sc->sc_iodone;
 	cbp->cb_buf.b_proc = bp->b_proc;
 	cbp->cb_buf.b_vp = sc->sc_vnodes[comp];
 	cbp->cb_buf.b_objlock = sc->sc_vnodes[comp]->v_interlock;
 	cbp->cb_buf.b_blkno = bn + sc->sc_aai->aai_offset;
 	cbp->cb_buf.b_data = addr;
 	cbp->cb_buf.b_bcount = bcount;
 	/* Context for iodone */
 	cbp->cb_obp = bp;
 	cbp->cb_sc = sc;
 	cbp->cb_comp = comp;
 	cbp->cb_other = NULL;
 	cbp->cb_flags = 0;
-       return cbp;
+	return cbp;
+}
 static void
 ld_ataraid_start_vstrategy(void *arg)
+{
-       struct ld_ataraid_softc *sc = arg;
+	struct ld_ataraid_softc *sc = arg;
-       struct cbuf *cbp;
+	struct cbuf *cbp;
-       while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
+	while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
-               SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
+	    SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
-               if ((cbp->cb_buf.b_flags & B_READ) == 0) {
+		if ((cbp->cb_buf.b_flags & B_READ) == 0) {
-                       mutex_enter(cbp->cb_buf.b_vp->v_interlock);
+			mutex_enter(cbp->cb_buf.b_vp->v_interlock);
-                       cbp->cb_buf.b_vp->v_numoutput++;
+			cbp->cb_buf.b_vp->v_numoutput++;
-                       mutex_exit(cbp->cb_buf.b_vp->v_interlock);
+			mutex_exit(cbp->cb_buf.b_vp->v_interlock);
+		}
-               VOP_STRATEGY(cbp->cb_buf.b_vp, &cbp->cb_buf);
+		VOP_STRATEGY(cbp->cb_buf.b_vp, &cbp->cb_buf);
+	}
+}
 static int
 ld_ataraid_start_span(struct ld_softc *ld, struct buf *bp)
+{
 	struct ld_ataraid_softc *sc = (void *) ld;
 	struct ataraid_array_info *aai = sc->sc_aai;
 	struct ataraid_disk_info *adi;
 	struct cbuf *cbp;
 	char *addr;
 	daddr_t bn;
 	long bcount, rcount;
 	u_int comp;
 @@ -351,64 +351,64 @@ ld_ataraid_start_span(struct ld_softc *l
 		adi = &aai->aai_disks[++comp];
+	}
 	bp->b_resid = bp->b_bcount;
 	for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
 		rcount = bp->b_bcount;
 		if ((adi->adi_compsize - bn) < btodb(rcount))
 			rcount = dbtob(adi->adi_compsize - bn);
 		cbp = ld_ataraid_make_cbuf(sc, bp, comp, bn, addr, rcount);
 		if (cbp == NULL) {
 			/* Free the already allocated component buffers. */
-                       while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
+		       while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
-                               SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
+			       SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
 				CBUF_PUT(cbp);
+			}
-                       return EAGAIN;
+		       return EAGAIN;
+		}
 		/*
 		 * For a span, we always know we advance to the next disk,
 		 * and always start at offset 0 on that disk.
 		 */
 		adi = &aai->aai_disks[++comp];
 		bn = 0;
-               SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq, cbp, cb_q);
+	       SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq, cbp, cb_q);
 		addr += rcount;
+	}
 	/* Now fire off the requests. */
-       softint_schedule(sc->sc_sih_cookie);
+	softint_schedule(sc->sc_sih_cookie);
-       return 0;
+	return 0;
+}
 static int
 ld_ataraid_start_raid0(struct ld_softc *ld, struct buf *bp)
+{
-       struct ld_ataraid_softc *sc = (void *)ld;
+	struct ld_ataraid_softc *sc = (void *)ld;
 	struct ataraid_array_info *aai = sc->sc_aai;
 	struct ataraid_disk_info *adi;
 	struct cbuf *cbp, *other_cbp;
 	char *addr;
 	daddr_t bn, cbn, tbn, off;
 	long bcount, rcount;
 	u_int comp;
 	const int read = bp->b_flags & B_READ;
 	const int mirror = aai->aai_level & AAI_L_RAID1;
-       int error = 0;
+	int error = 0;
 	/* Allocate component buffers. */
 	addr = bp->b_data;
 	bn = bp->b_rawblkno;
 	bp->b_resid = bp->b_bcount;
 	for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
 		tbn = bn / aai->aai_interleave;
 		off = bn % aai->aai_interleave;
 		if (__predict_false(tbn == aai->aai_capacity /
 					   aai->aai_interleave)) {
 @@ -441,55 +441,55 @@ try_mirror:
 			/*
 			 * No component available.
 			 */
 			error = EIO;
 			goto free_and_exit;
+		}
 		cbp = ld_ataraid_make_cbuf(sc, bp, comp, cbn, addr, rcount);
 		if (cbp == NULL) {
 resource_shortage:
 			error = EAGAIN;
 free_and_exit:
 			/* Free the already allocated component buffers. */
-                       while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
+		       while ((cbp = SIMPLEQ_FIRST(&sc->sc_cbufq)) != NULL) {
-                               SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
+			       SIMPLEQ_REMOVE_HEAD(&sc->sc_cbufq, cb_q);
 				CBUF_PUT(cbp);
+			}
-                       return error;
+		       return error;
+		}
-               SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq, cbp, cb_q);
+	       SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq, cbp, cb_q);
 		if (mirror && !read && comp < aai->aai_width) {
 			comp += aai->aai_width;
 			adi = &aai->aai_disks[comp];
 			if (adi->adi_status & ADI_S_ONLINE) {
 				other_cbp = ld_ataraid_make_cbuf(sc, bp,
 				    comp, cbn, addr, rcount);
 				if (other_cbp == NULL)
 					goto resource_shortage;
-                               SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq,
+			       SIMPLEQ_INSERT_TAIL(&sc->sc_cbufq,
-                                   other_cbp, cb_q);
+				   other_cbp, cb_q);
 				other_cbp->cb_other = cbp;
 				cbp->cb_other = other_cbp;
+			}
+		}
 		bn += btodb(rcount);
 		addr += rcount;
+	}
 	/* Now fire off the requests. */
-       softint_schedule(sc->sc_sih_cookie);
+	softint_schedule(sc->sc_sih_cookie);
-       return error;
+	return error;
+}
 /*
  * Called at interrupt time.  Mark the component as done and if all
  * components are done, take an "interrupt".
  */
 static void
 ld_ataraid_iodone_raid0(struct buf *vbp)
+{
 	struct cbuf *cbp = (struct cbuf *) vbp, *other_cbp;
 	struct buf *bp = cbp->cb_obp;
 	struct ld_ataraid_softc *sc = cbp->cb_sc;
 	struct ataraid_array_info *aai = sc->sc_aai;
 @@ -612,27 +612,27 @@ ld_ataraid_bioinq(struct ld_ataraid_soft
 	/* there's always one volume per ld device */
 	bi->bi_novol = 1;
 	bi->bi_nodisk = aai->aai_ndisks;
 	return 0;
+}
 static int
 ld_ataraid_biovol(struct ld_ataraid_softc *sc, struct bioc_vol *bv)
+{
 	struct ataraid_array_info *aai = sc->sc_aai;
 	struct ld_softc *ld = &sc->sc_ld;
-#define	to_kibytes(ld,s)	(ld->sc_secsize*(s)/1024)
+#define to_kibytes(ld,s)	(ld->sc_secsize*(s)/1024)
 	/* Fill in data for _this_ volume */
 	bv->bv_percent = -1;
 	bv->bv_seconds = 0;
 	switch (aai->aai_status) {
 	case AAI_S_READY:
 		bv->bv_status = BIOC_SVONLINE;
 		break;
 	case AAI_S_DEGRADED:
 		bv->bv_status = BIOC_SVDEGRADED;
 		break;
+	}
 @@ -713,27 +713,27 @@ ld_ataraid_biodisk(struct ld_ataraid_sof
 	strlcpy(bd->bd_serial, serial, sizeof(bd->bd_serial));
 	return 0;
+}
 #endif /* NBIO > 0 */
 MODULE(MODULE_CLASS_DRIVER, ld_ataraid, "ld,ataraid");
 #ifdef _MODULE
 /*
  * XXX Don't allow ioconf.c to redefine the "struct cfdriver ld_ataraid"
  * XXX it will be defined in the common-code module
  */
-#undef  CFDRIVER_DECL
+#undef	CFDRIVER_DECL
 #define CFDRIVER_DECL(name, class, attr)
 #include "ioconf.c"
 #endif
 static int
 ld_ataraid_modcmd(modcmd_t cmd, void *opaque)
+{
 #ifdef _MODULE
 	/*
 	 * We ignore the cfdriver_vec[] that ioconf provides, since
 	 * the cfdrivers are attached already.
 	 */
 	static struct cfdriver * const no_cfdriver_vec[] = { NULL };