A few more daddr_t fixes. Rename 'phys_off' variables to 'offset'

since they are now relative to chunks. Use 'blkno' as normal variable
name for daddr_t items rather than mix of 'blkno, blk, offset.
Change field name ssd_data_offset to ssd_data_blkno since it is a
block and not byte quantity.

No intentional functional change.

10 files changed, 115 insertions, 116 deletions

diff --git a/sys/arch/amd64/stand/libsa/softraid.c b/sys/arch/amd64/stand/libsa/softraid.c
index 89fea751496..f43d46056d8 100644
--- a/sys/arch/amd64/stand/libsa/softraid.c
+++ b/sys/arch/amd64/stand/libsa/softraid.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: softraid.c,v 1.10 2015/07/19 16:12:10 krw Exp $	*/
+/*	$OpenBSD: softraid.c,v 1.11 2015/07/21 03:30:51 krw Exp $	*/
 
 /*
  * Copyright (c) 2012 Joel Sing <jsing@openbsd.org>
@@ -222,7 +222,7 @@ srprobe(void)
 				bv->sbv_chunk_no = md->ssdi.ssd_chunk_no;
 				bv->sbv_flags = md->ssdi.ssd_vol_flags;
 				bv->sbv_size = md->ssdi.ssd_size;
-				bv->sbv_data_offset = md->ssd_data_offset;
+				bv->sbv_data_blkno = md->ssd_data_blkno;
 				bcopy(&md->ssdi.ssd_uuid, &bv->sbv_uuid,
 				    sizeof(md->ssdi.ssd_uuid));
 				SLIST_INIT(&bv->sbv_chunks);
@@ -353,7 +353,7 @@ sr_strategy(struct sr_boot_volume *bv, int rw, daddr32_t blk, size_t size,
 
 		dip = (struct diskinfo *)bc->sbc_diskinfo;
 		dip->bsddev = bc->sbc_mm;
-		blk += bv->sbv_data_offset;
+		blk += bv->sbv_data_blkno;
 
 		/* XXX - If I/O failed we should try another chunk... */
 		return biosstrategy(dip, rw, blk, size, buf, rsize);
@@ -377,7 +377,7 @@ sr_strategy(struct sr_boot_volume *bv, int rw, daddr32_t blk, size_t size,
 		for (i = 0; i < nsect; i++) {
 			blkno = blk + i;
 			bp = ((u_char *)buf) + i * DEV_BSIZE;
-			err = biosstrategy(dip, rw, bv->sbv_data_offset + blkno,
+			err = biosstrategy(dip, rw, bv->sbv_data_blkno + blkno,
 			    DEV_BSIZE, bp, NULL);
 			if (err != 0)
 				return err;
diff --git a/sys/arch/i386/stand/libsa/softraid.c b/sys/arch/i386/stand/libsa/softraid.c
index 89fea751496..f43d46056d8 100644
--- a/sys/arch/i386/stand/libsa/softraid.c
+++ b/sys/arch/i386/stand/libsa/softraid.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: softraid.c,v 1.10 2015/07/19 16:12:10 krw Exp $	*/
+/*	$OpenBSD: softraid.c,v 1.11 2015/07/21 03:30:51 krw Exp $	*/
 
 /*
  * Copyright (c) 2012 Joel Sing <jsing@openbsd.org>
@@ -222,7 +222,7 @@ srprobe(void)
 				bv->sbv_chunk_no = md->ssdi.ssd_chunk_no;
 				bv->sbv_flags = md->ssdi.ssd_vol_flags;
 				bv->sbv_size = md->ssdi.ssd_size;
-				bv->sbv_data_offset = md->ssd_data_offset;
+				bv->sbv_data_blkno = md->ssd_data_blkno;
 				bcopy(&md->ssdi.ssd_uuid, &bv->sbv_uuid,
 				    sizeof(md->ssdi.ssd_uuid));
 				SLIST_INIT(&bv->sbv_chunks);
@@ -353,7 +353,7 @@ sr_strategy(struct sr_boot_volume *bv, int rw, daddr32_t blk, size_t size,
 
 		dip = (struct diskinfo *)bc->sbc_diskinfo;
 		dip->bsddev = bc->sbc_mm;
-		blk += bv->sbv_data_offset;
+		blk += bv->sbv_data_blkno;
 
 		/* XXX - If I/O failed we should try another chunk... */
 		return biosstrategy(dip, rw, blk, size, buf, rsize);
@@ -377,7 +377,7 @@ sr_strategy(struct sr_boot_volume *bv, int rw, daddr32_t blk, size_t size,
 		for (i = 0; i < nsect; i++) {
 			blkno = blk + i;
 			bp = ((u_char *)buf) + i * DEV_BSIZE;
-			err = biosstrategy(dip, rw, bv->sbv_data_offset + blkno,
+			err = biosstrategy(dip, rw, bv->sbv_data_blkno + blkno,
 			    DEV_BSIZE, bp, NULL);
 			if (err != 0)
 				return err;
diff --git a/sys/dev/softraid.c b/sys/dev/softraid.c
index fc7f07e5d34..d2c8e7a8331 100644
--- a/sys/dev/softraid.c
+++ b/sys/dev/softraid.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraid.c,v 1.359 2015/07/20 18:27:36 mlarkin Exp $ */
+/* $OpenBSD: softraid.c,v 1.360 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2007, 2008, 2009 Marco Peereboom <marco@peereboom.us>
  * Copyright (c) 2008 Chris Kuethe <ckuethe@openbsd.org>
@@ -401,7 +401,7 @@ sr_meta_getdevname(struct sr_softc *sc, dev_t dev, char *buf, int size)
 }
 
 int
-sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t offset,
+sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t blkno,
     long flags)
 {
 	struct vnode		*vp;
@@ -411,7 +411,7 @@ sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t offset,
 	char			*dma_buf;
 
 	DNPRINTF(SR_D_MISC, "%s: sr_rw(0x%x, %p, %zu, %lld 0x%lx)\n",
-	    DEVNAME(sc), dev, buf, size, (long long)offset, flags);
+	    DEVNAME(sc), dev, buf, size, (long long)blkno, flags);
 
 	dma_bufsize = (size > MAXPHYS) ? MAXPHYS : size;
 	dma_buf = dma_alloc(dma_bufsize, PR_WAITOK);
@@ -422,8 +422,8 @@ sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t offset,
 	}
 
 	while (size > 0) {
-		DNPRINTF(SR_D_MISC, "%s: dma_buf %p, size %zu, offset %llu)\n",
-		    DEVNAME(sc), dma_buf, size, offset);
+		DNPRINTF(SR_D_MISC, "%s: dma_buf %p, size %zu, blkno %lld)\n",
+		    DEVNAME(sc), dma_buf, size, (long long)blkno);
 
 		bufsize = (size > MAXPHYS) ? MAXPHYS : size;
 		if (flags == B_WRITE)
@@ -435,7 +435,7 @@ sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t offset,
 		b.b_dev = dev;
 		b.b_iodone = NULL;
 		b.b_error = 0;
-		b.b_blkno = offset;
+		b.b_blkno = blkno;
 		b.b_data = dma_buf;
 		b.b_bcount = bufsize;
 		b.b_bufsize = bufsize;
@@ -460,7 +460,7 @@ sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t offset,
 
 		size -= bufsize;
 		buf += bufsize;
-		offset += howmany(bufsize, DEV_BSIZE);
+		blkno += howmany(bufsize, DEV_BSIZE);
 	}
 
 	rv = 0;
@@ -476,12 +476,12 @@ done:
 
 int
 sr_meta_rw(struct sr_discipline *sd, dev_t dev, void *md, size_t size,
-    daddr_t offset, long flags)
+    daddr_t blkno, long flags)
 {
 	int			rv = 1;
 
 	DNPRINTF(SR_D_META, "%s: sr_meta_rw(0x%x, %p, %zu, %lld 0x%lx)\n",
-	    DEVNAME(sd->sd_sc), dev, md, size, (long long)offset, flags);
+	    DEVNAME(sd->sd_sc), dev, md, size, (long long)blkno, flags);
 
 	if (md == NULL) {
 		printf("%s: sr_meta_rw: invalid metadata pointer\n",
@@ -489,7 +489,7 @@ sr_meta_rw(struct sr_discipline *sd, dev_t dev, void *md, size_t size,
 		goto done;
 	}
 
-	rv = sr_rw(sd->sd_sc, dev, md, size, offset, flags);
+	rv = sr_rw(sd->sd_sc, dev, md, size, blkno, flags);
 
 done:
 	return (rv);
@@ -555,7 +555,7 @@ sr_meta_init(struct sr_discipline *sd, int level, int no_chunk)
 	sm->ssdi.ssd_chunk_no = no_chunk;
 	sm->ssdi.ssd_level = level;
 
-	sm->ssd_data_offset = SR_DATA_OFFSET;
+	sm->ssd_data_blkno = SR_DATA_OFFSET;
 	sm->ssd_ondisk = 0;
 
 	sr_uuid_generate(&sm->ssdi.ssd_uuid);
@@ -939,20 +939,20 @@ sr_meta_validate(struct sr_discipline *sd, dev_t dev, struct sr_metadata *sm,
 	if (sm->ssdi.ssd_version == 3) {
 
 		/*
-		 * Version 3 - update metadata version and fix up data offset
+		 * Version 3 - update metadata version and fix up data blkno
 		 * value since this did not exist in version 3.
 		 */
-		if (sm->ssd_data_offset == 0)
-			sm->ssd_data_offset = SR_META_V3_DATA_OFFSET;
+		if (sm->ssd_data_blkno == 0)
+			sm->ssd_data_blkno = SR_META_V3_DATA_OFFSET;
 
 	} else if (sm->ssdi.ssd_version == 4) {
 
 		/*
 		 * Version 4 - original metadata format did not store
-		 * data offset so fix this up if necessary.
+		 * data blkno so fix this up if necessary.
 		 */
-		if (sm->ssd_data_offset == 0)
-			sm->ssd_data_offset = SR_DATA_OFFSET;
+		if (sm->ssd_data_blkno == 0)
+			sm->ssd_data_blkno = SR_DATA_OFFSET;
 
 	} else if (sm->ssdi.ssd_version == SR_META_VERSION) {
 
@@ -2031,7 +2031,7 @@ sr_ccb_rw(struct sr_discipline *sd, int chunk, daddr_t blkno,
 	else
 		ccb->ccb_buf.b_flags |= B_WRITE;
 
-	ccb->ccb_buf.b_blkno = blkno + sd->sd_meta->ssd_data_offset;
+	ccb->ccb_buf.b_blkno = blkno + sd->sd_meta->ssd_data_blkno;
 	ccb->ccb_buf.b_bcount = len;
 	ccb->ccb_buf.b_bufsize = len;
 	ccb->ccb_buf.b_resid = len;
@@ -2609,8 +2609,7 @@ sr_ioctl_vol(struct sr_softc *sc, struct bioc_vol *bv)
 	int			vol = -1, rv = EINVAL;
 	struct sr_discipline	*sd;
 	struct sr_chunk		*hotspare;
-	daddr_t			rb;
-	int64_t			sz;
+	int64_t			rb, sz;
 
 	TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) {
 		vol++;
@@ -2834,7 +2833,7 @@ sr_hotspare(struct sr_softc *sc, dev_t dev)
 	struct sr_uuid		uuid;
 	struct disklabel	label;
 	struct vnode		*vn;
-	daddr_t			size;
+	u_int64_t		size;
 	char			devname[32];
 	int			rv = EINVAL;
 	int			c, part, open = 0;
@@ -3207,12 +3206,12 @@ sr_rebuild_init(struct sr_discipline *sd, dev_t dev, int hotspare)
 
 	/* Is the partition large enough? */
 	size = DL_SECTOBLK(&label, DL_GETPSIZE(&label.d_partitions[part]));
-	if (size <= sd->sd_meta->ssd_data_offset) {
+	if (size <= sd->sd_meta->ssd_data_blkno) {
 		sr_error(sc, "%s: %s partition too small\n", DEVNAME(sc),
 		    devname);
 		goto done;
 	}
-	size -= sd->sd_meta->ssd_data_offset;
+	size -= sd->sd_meta->ssd_data_blkno;
 	if (size > INT64_MAX) {
 		sr_error(sc, "%s: %s partition too large\n", DEVNAME(sc),
 		    devname);
@@ -3706,7 +3705,7 @@ sr_ioctl_installboot(struct sr_softc *sc, struct sr_discipline *sd,
 	memcpy(duid, dk->dk_label->d_uid, sizeof(duid));
 
 	/* Ensure that boot storage area is large enough. */
-	if (sd->sd_meta->ssd_data_offset < (SR_BOOT_OFFSET + SR_BOOT_SIZE)) {
+	if (sd->sd_meta->ssd_data_blkno < (SR_BOOT_OFFSET + SR_BOOT_SIZE)) {
 		sr_error(sc, "insufficient boot storage");
 		goto done;
 	}
@@ -4048,7 +4047,7 @@ sr_raid_read_cap(struct sr_workunit *wu)
 	struct scsi_xfer	*xs = wu->swu_xs;
 	struct scsi_read_cap_data rcd;
 	struct scsi_read_cap_data_16 rcd16;
-	daddr_t			addr;
+	int64_t			addr;
 	int			rv = 1;
 
 	DNPRINTF(SR_D_DIS, "%s: sr_raid_read_cap\n", DEVNAME(sd->sd_sc));
@@ -4557,7 +4556,7 @@ sr_shutdown(void)
 }
 
 int
-sr_validate_io(struct sr_workunit *wu, daddr_t *blk, char *func)
+sr_validate_io(struct sr_workunit *wu, daddr_t *blkno, char *func)
 {
 	struct sr_discipline	*sd = wu->swu_dis;
 	struct scsi_xfer	*xs = wu->swu_xs;
@@ -4566,8 +4565,8 @@ sr_validate_io(struct sr_workunit *wu, daddr_t *blk, char *func)
 	DNPRINTF(SR_D_DIS, "%s: %s 0x%02x\n", DEVNAME(sd->sd_sc), func,
 	    xs->cmd->opcode);
 
-	if (sd->sd_meta->ssd_data_offset == 0)
-		panic("invalid data offset");
+	if (sd->sd_meta->ssd_data_blkno == 0)
+		panic("invalid data blkno");
 
 	if (sd->sd_vol_status == BIOC_SVOFFLINE) {
 		DNPRINTF(SR_D_DIS, "%s: %s device offline\n",
@@ -4582,19 +4581,19 @@ sr_validate_io(struct sr_workunit *wu, daddr_t *blk, char *func)
 	}
 
 	if (xs->cmdlen == 10)
-		*blk = _4btol(((struct scsi_rw_big *)xs->cmd)->addr);
+		*blkno = _4btol(((struct scsi_rw_big *)xs->cmd)->addr);
 	else if (xs->cmdlen == 16)
-		*blk = _8btol(((struct scsi_rw_16 *)xs->cmd)->addr);
+		*blkno = _8btol(((struct scsi_rw_16 *)xs->cmd)->addr);
 	else if (xs->cmdlen == 6)
-		*blk = _3btol(((struct scsi_rw *)xs->cmd)->addr);
+		*blkno = _3btol(((struct scsi_rw *)xs->cmd)->addr);
 	else {
 		printf("%s: %s: illegal cmdlen for %s\n",
 		    DEVNAME(sd->sd_sc), func, sd->sd_meta->ssd_devname);
 		goto bad;
 	}
 
-	wu->swu_blk_start = *blk;
-	wu->swu_blk_end = *blk + (xs->datalen >> DEV_BSHIFT) - 1;
+	wu->swu_blk_start = *blkno;
+	wu->swu_blk_end = *blkno + (xs->datalen >> DEV_BSHIFT) - 1;
 
 	if (wu->swu_blk_end > sd->sd_meta->ssdi.ssd_size) {
 		DNPRINTF(SR_D_DIS, "%s: %s out of bounds start: %lld "
@@ -4651,7 +4650,8 @@ sr_rebuild(struct sr_discipline *sd)
 {
 	struct sr_softc		*sc = sd->sd_sc;
 	u_int64_t		sz, psz, whole_blk, partial_blk, blk, restart;
-	daddr_t			lba, rb;
+	daddr_t			lba;
+	int64_t			rb;
 	struct sr_workunit	*wu_r, *wu_w;
 	struct scsi_xfer	xs_r, xs_w;
 	struct scsi_rw_16	*cr, *cw;
@@ -5085,7 +5085,7 @@ sr_hibernate_io(dev_t dev, daddr_t blkno, vaddr_t addr, size_t size, int op, voi
 		my->subfn = get_hibernate_io_function(my->subdev);
 
 		/*
-		 * Find block offset where this raid partition is on
+		 * Find blkno where this raid partition starts on
 		 * the underlying disk.
 		 */
 		dl_ret = disk_readlabel(&dl, my->subdev, errstr,
@@ -5099,13 +5099,13 @@ sr_hibernate_io(dev_t dev, daddr_t blkno, vaddr_t addr, size_t size, int op, voi
 		if (pp->p_fstype != FS_RAID || DL_GETPSIZE(pp) == 0)
 			return (ENOTSUP);
 
-		/* Find the offset of the SR part in the underlying device */
-		sub_raidoff = my->srd->sd_meta->ssd_data_offset +
+		/* Find the blkno of the SR part in the underlying device */
+		sub_raidoff = my->srd->sd_meta->ssd_data_blkno +
 		    DL_SECTOBLK(&dl, DL_GETPOFFSET(pp));
 		DNPRINTF(SR_D_MISC,"sr_hibernate_io: blk trans ofs: %d blks\n",
 		    sub_raidoff);
 
-		/* Save the offset of the swap partition in the SR disk */
+		/* Save the blkno of the swap partition in the SR disk */
 		my->sr_swapoff = blkno;
 
 		/* Initialize the sub-device */
diff --git a/sys/dev/softraid_concat.c b/sys/dev/softraid_concat.c
index eeeade12cf1..b6ac55eb281 100644
--- a/sys/dev/softraid_concat.c
+++ b/sys/dev/softraid_concat.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraid_concat.c,v 1.22 2015/07/19 17:04:31 krw Exp $ */
+/* $OpenBSD: softraid_concat.c,v 1.23 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2008 Marco Peereboom <marco@peereboom.us>
  * Copyright (c) 2011 Joel Sing <jsing@openbsd.org>
@@ -98,37 +98,37 @@ sr_concat_rw(struct sr_workunit *wu)
 	struct scsi_xfer	*xs = wu->swu_xs;
 	struct sr_ccb		*ccb;
 	struct sr_chunk		*scp;
-	daddr_t			blk;
-	int64_t			lbaoffs, physoffs;
+	daddr_t			blkno;
+	int64_t			lbaoffs, offset;
 	int64_t			no_chunk, chunkend, chunk, chunksize;
 	int64_t			length, leftover;
 	u_int8_t		*data;
 
-	/* blk and scsi error will be handled by sr_validate_io */
-	if (sr_validate_io(wu, &blk, "sr_concat_rw"))
+	/* blkno and scsi error will be handled by sr_validate_io */
+	if (sr_validate_io(wu, &blkno, "sr_concat_rw"))
 		goto bad;
 
 	no_chunk = sd->sd_meta->ssdi.ssd_chunk_no;
 
-	DNPRINTF(SR_D_DIS, "%s: %s: front end io: lba %lld size %d\n",
+	DNPRINTF(SR_D_DIS, "%s: %s: front end io: blkno %lld size %d\n",
 	    DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
-	    (long long)blk, xs->datalen);
+	    (long long)blkno, xs->datalen);
 
 	/* All offsets are in bytes. */
-	lbaoffs = blk << DEV_BSHIFT;
+	lbaoffs = blkno << DEV_BSHIFT;
 	leftover = xs->datalen;
 	data = xs->data;
 	for (;;) {
 
 		chunkend = 0;
-		physoffs = lbaoffs;
+		offset = lbaoffs;
 		for (chunk = 0; chunk < no_chunk; chunk++) {
 			chunksize = sd->sd_vol.sv_chunks[chunk]->src_size <<
 			    DEV_BSHIFT;
 			chunkend += chunksize;
 			if (lbaoffs < chunkend)
 				break;
-			physoffs -= chunksize;
+			offset -= chunksize;
 		}
 		if (lbaoffs > chunkend)
 			goto bad;
@@ -141,13 +141,13 @@ sr_concat_rw(struct sr_workunit *wu)
 			goto bad;
 
 		DNPRINTF(SR_D_DIS, "%s: %s %s io lbaoffs %lld "
-		    "chunk %lld chunkend %lld physoffs %lld length %lld "
+		    "chunk %lld chunkend %lld offset %lld length %lld "
 		    "leftover %lld data %p\n",
 		    DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name,
-		    lbaoffs, chunk, chunkend, physoffs, length, leftover, data);
+		    lbaoffs, chunk, chunkend, offset, length, leftover, data);
 
-		blk = physoffs >> DEV_BSHIFT;
-		ccb = sr_ccb_rw(sd, chunk, blk, length, data, xs->flags, 0);
+		blkno = offset >> DEV_BSHIFT;
+		ccb = sr_ccb_rw(sd, chunk, blkno, length, data, xs->flags, 0);
 		if (!ccb) {
 			/* should never happen but handle more gracefully */
 			printf("%s: %s: too many ccbs queued\n",
diff --git a/sys/dev/softraid_crypto.c b/sys/dev/softraid_crypto.c
index cd650ed3ca2..b72009033a7 100644
--- a/sys/dev/softraid_crypto.c
+++ b/sys/dev/softraid_crypto.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraid_crypto.c,v 1.120 2015/07/19 17:20:15 krw Exp $ */
+/* $OpenBSD: softraid_crypto.c,v 1.121 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2007 Marco Peereboom <marco@peereboom.us>
  * Copyright (c) 2008 Hans-Joerg Hoexer <hshoexer@openbsd.org>
@@ -250,7 +250,7 @@ sr_crypto_prepare(struct sr_workunit *wu, int encrypt)
 	struct sr_crypto_wu	*crwu;
 	struct cryptodesc	*crd;
 	int			flags, i, n;
-	daddr_t			blk;
+	daddr_t			blkno;
 	u_int			keyndx;
 
 	DNPRINTF(SR_D_DIS, "%s: sr_crypto_prepare wu %p encrypt %d\n",
@@ -265,7 +265,7 @@ sr_crypto_prepare(struct sr_workunit *wu, int encrypt)
 	} else
 		crwu->cr_uio.uio_iov->iov_base = xs->data;
 
-	blk = wu->swu_blk_start;
+	blkno = wu->swu_blk_start;
 	n = xs->datalen >> DEV_BSHIFT;
 
 	/*
@@ -289,7 +289,7 @@ sr_crypto_prepare(struct sr_workunit *wu, int encrypt)
 	 * across a different key blocks (e.g. 0.5TB boundary). Currently
 	 * this is already broken by the use of scr_key[0] below.
 	 */
-	keyndx = blk >> SR_CRYPTO_KEY_BLKSHIFT;
+	keyndx = blkno >> SR_CRYPTO_KEY_BLKSHIFT;
 	crwu->cr_crp->crp_sid = sd->mds.mdd_crypto.scr_sid[keyndx];
 
 	crwu->cr_crp->crp_opaque = crwu;
@@ -297,7 +297,7 @@ sr_crypto_prepare(struct sr_workunit *wu, int encrypt)
 	crwu->cr_crp->crp_alloctype = M_DEVBUF;
 	crwu->cr_crp->crp_buf = &crwu->cr_uio;
 	for (i = 0, crd = crwu->cr_crp->crp_desc; crd;
-	    i++, blk++, crd = crd->crd_next) {
+	    i++, blkno++, crd = crd->crd_next) {
 		crd->crd_skip = i << DEV_BSHIFT;
 		crd->crd_len = DEV_BSIZE;
 		crd->crd_inject = 0;
@@ -305,7 +305,7 @@ sr_crypto_prepare(struct sr_workunit *wu, int encrypt)
 		crd->crd_alg = sd->mds.mdd_crypto.scr_alg;
 		crd->crd_klen = sd->mds.mdd_crypto.scr_klen;
 		crd->crd_key = sd->mds.mdd_crypto.scr_key[0];
-		memcpy(crd->crd_iv, &blk, sizeof(blk));
+		memcpy(crd->crd_iv, &blkno, sizeof(blkno));
 	}
 
 	return (crwu);
@@ -1099,13 +1099,13 @@ int
 sr_crypto_rw(struct sr_workunit *wu)
 {
 	struct sr_crypto_wu	*crwu;
-	daddr_t			blk;
+	daddr_t			blkno;
 	int			rv = 0;
 
 	DNPRINTF(SR_D_DIS, "%s: sr_crypto_rw wu %p\n",
 	    DEVNAME(wu->swu_dis->sd_sc), wu);
 
-	if (sr_validate_io(wu, &blk, "sr_crypto_rw"))
+	if (sr_validate_io(wu, &blkno, "sr_crypto_rw"))
 		return (1);
 
 	if (wu->swu_xs->flags & SCSI_DATA_OUT) {
@@ -1148,11 +1148,11 @@ sr_crypto_dev_rw(struct sr_workunit *wu, struct sr_crypto_wu *crwu)
 	struct scsi_xfer	*xs = wu->swu_xs;
 	struct sr_ccb		*ccb;
 	struct uio		*uio;
-	daddr_t			blk;
+	daddr_t			blkno;
 
-	blk = wu->swu_blk_start;
+	blkno = wu->swu_blk_start;
 
-	ccb = sr_ccb_rw(sd, 0, blk, xs->datalen, xs->data, xs->flags, 0);
+	ccb = sr_ccb_rw(sd, 0, blkno, xs->datalen, xs->data, xs->flags, 0);
 	if (!ccb) {
 		/* should never happen but handle more gracefully */
 		printf("%s: %s: too many ccbs queued\n",
diff --git a/sys/dev/softraid_raid0.c b/sys/dev/softraid_raid0.c
index 4a727007238..fa0c6f076b1 100644
--- a/sys/dev/softraid_raid0.c
+++ b/sys/dev/softraid_raid0.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraid_raid0.c,v 1.49 2015/07/19 21:06:04 krw Exp $ */
+/* $OpenBSD: softraid_raid0.c,v 1.50 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2008 Marco Peereboom <marco@peereboom.us>
  *
@@ -118,32 +118,32 @@ sr_raid0_rw(struct sr_workunit *wu)
 	struct scsi_xfer	*xs = wu->swu_xs;
 	struct sr_ccb		*ccb;
 	struct sr_chunk		*scp;
-	daddr_t			blk;
-	int64_t			chunkoffs, lbaoffs, physoffs, stripoffs;
+	daddr_t			blkno;
+	int64_t			chunkoffs, lbaoffs, offset, stripoffs;
 	int64_t			strip_bits, strip_no, strip_size;
 	int64_t			chunk, no_chunk;
 	int64_t			length, leftover;
 	u_int8_t		*data;
 
-	/* blk and scsi error will be handled by sr_validate_io */
-	if (sr_validate_io(wu, &blk, "sr_raid0_rw"))
+	/* blkno and scsi error will be handled by sr_validate_io */
+	if (sr_validate_io(wu, &blkno, "sr_raid0_rw"))
 		goto bad;
 
 	strip_size = sd->sd_meta->ssdi.ssd_strip_size;
 	strip_bits = sd->mds.mdd_raid0.sr0_strip_bits;
 	no_chunk = sd->sd_meta->ssdi.ssd_chunk_no;
 
-	DNPRINTF(SR_D_DIS, "%s: %s: front end io: lba %lld size %d\n",
+	DNPRINTF(SR_D_DIS, "%s: %s: front end io: blkno %lld size %d\n",
 	    DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
-	    (long long)blk, xs->datalen);
+	    (long long)blkno, xs->datalen);
 
 	/* all offs are in bytes */
-	lbaoffs = blk << DEV_BSHIFT;
+	lbaoffs = blkno << DEV_BSHIFT;
 	strip_no = lbaoffs >> strip_bits;
 	chunk = strip_no % no_chunk;
 	stripoffs = lbaoffs & (strip_size - 1);
 	chunkoffs = (strip_no / no_chunk) << strip_bits;
-	physoffs = chunkoffs + stripoffs;
+	offset = chunkoffs + stripoffs;
 	length = MIN(xs->datalen, strip_size - stripoffs);
 	leftover = xs->datalen;
 	data = xs->data;
@@ -155,14 +155,14 @@ sr_raid0_rw(struct sr_workunit *wu)
 
 		DNPRINTF(SR_D_DIS, "%s: %s %s io lbaoffs %lld "
 		    "strip_no %lld chunk %lld stripoffs %lld "
-		    "chunkoffs %lld physoffs %lld length %lld "
+		    "chunkoffs %lld offset %lld length %lld "
 		    "leftover %lld data %p\n",
 		    DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name,
-		    lbaoffs, strip_no, chunk, stripoffs, chunkoffs, physoffs,
+		    lbaoffs, strip_no, chunk, stripoffs, chunkoffs, offset,
 		    length, leftover, data);
 
-		blk = physoffs >> DEV_BSHIFT;
-		ccb = sr_ccb_rw(sd, chunk, blk, length, data, xs->flags, 0);
+		blkno = offset >> DEV_BSHIFT;
+		ccb = sr_ccb_rw(sd, chunk, blkno, length, data, xs->flags, 0);
 		if (!ccb) {
 			/* should never happen but handle more gracefully */
 			printf("%s: %s: too many ccbs queued\n",
@@ -179,9 +179,9 @@ sr_raid0_rw(struct sr_workunit *wu)
 		data += length;
 		if (++chunk > no_chunk - 1) {
 			chunk = 0;
-			physoffs += length;
+			offset += length;
 		} else if (wu->swu_io_count == 1)
-			physoffs -= stripoffs;
+			offset -= stripoffs;
 		length = MIN(leftover,strip_size);
 	}
 
diff --git a/sys/dev/softraid_raid1.c b/sys/dev/softraid_raid1.c
index 5eceea3cdc4..4bb766bf550 100644
--- a/sys/dev/softraid_raid1.c
+++ b/sys/dev/softraid_raid1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraid_raid1.c,v 1.62 2015/07/19 21:06:04 krw Exp $ */
+/* $OpenBSD: softraid_raid1.c,v 1.63 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2007 Marco Peereboom <marco@peereboom.us>
  *
@@ -329,10 +329,10 @@ sr_raid1_rw(struct sr_workunit *wu)
 	struct sr_ccb		*ccb;
 	struct sr_chunk		*scp;
 	int			ios, chunk, i, rt;
-	daddr_t			blk;
+	daddr_t			blkno;
 
-	/* blk and scsi error will be handled by sr_validate_io */
-	if (sr_validate_io(wu, &blk, "sr_raid1_rw"))
+	/* blkno and scsi error will be handled by sr_validate_io */
+	if (sr_validate_io(wu, &blkno, "sr_raid1_rw"))
 		goto bad;
 
 	if (xs->flags & SCSI_DATA_IN)
@@ -385,7 +385,7 @@ ragain:
 			}
 		}
 
-		ccb = sr_ccb_rw(sd, chunk, blk, xs->datalen, xs->data,
+		ccb = sr_ccb_rw(sd, chunk, blkno, xs->datalen, xs->data,
 		    xs->flags, 0);
 		if (!ccb) {
 			/* should never happen but handle more gracefully */
diff --git a/sys/dev/softraid_raid5.c b/sys/dev/softraid_raid5.c
index 5936c2a1db3..ee0c7fddc1b 100644
--- a/sys/dev/softraid_raid5.c
+++ b/sys/dev/softraid_raid5.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraid_raid5.c,v 1.22 2015/07/19 21:06:04 krw Exp $ */
+/* $OpenBSD: softraid_raid5.c,v 1.23 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
  * Copyright (c) 2009 Marco Peereboom <marco@peereboom.us>
@@ -372,8 +372,8 @@ sr_raid5_rw(struct sr_workunit *wu)
 	struct sr_discipline	*sd = wu->swu_dis;
 	struct scsi_xfer	*xs = wu->swu_xs;
 	struct sr_chunk		*scp;
-	daddr_t			blk, lba;
-	int64_t			chunk_offs, lbaoffs, phys_offs, strip_offs;
+	daddr_t			blkno, lba;
+	int64_t			chunk_offs, lbaoffs, offset, strip_offs;
 	int64_t			strip_bits, strip_no, strip_size;
 	int64_t			chunk, no_chunk;
 	int64_t			parity, row_size;
@@ -381,14 +381,14 @@ sr_raid5_rw(struct sr_workunit *wu)
 	void			*data;
 	int			s;
 
-	/* blk and scsi error will be handled by sr_validate_io */
-	if (sr_validate_io(wu, &blk, "sr_raid5_rw"))
+	/* blkno and scsi error will be handled by sr_validate_io */
+	if (sr_validate_io(wu, &blkno, "sr_raid5_rw"))
 		goto bad;
 
-	DNPRINTF(SR_D_DIS, "%s: %s sr_raid5_rw %s: lba %lld size %d\n",
+	DNPRINTF(SR_D_DIS, "%s: %s sr_raid5_rw %s: blkno %lld size %d\n",
 	    DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
 	    (xs->flags & SCSI_DATA_IN) ? "read" : "write",
-	    (long long)blk, xs->datalen);
+	    (long long)blkno, xs->datalen);
 
 	strip_size = sd->sd_meta->ssdi.ssd_strip_size;
 	strip_bits = sd->mds.mdd_raid5.sr5_strip_bits;
@@ -397,7 +397,7 @@ sr_raid5_rw(struct sr_workunit *wu)
 
 	data = xs->data;
 	datalen = xs->datalen;
-	lbaoffs	= blk << DEV_BSHIFT;
+	lbaoffs	= blkno << DEV_BSHIFT;
 
 	if (xs->flags & SCSI_DATA_OUT) {
 		if ((wu_r = sr_scsi_wu_get(sd, SCSI_NOSLEEP)) == NULL){
@@ -414,7 +414,7 @@ sr_raid5_rw(struct sr_workunit *wu)
 		strip_no = lbaoffs >> strip_bits;
 		strip_offs = lbaoffs & (strip_size - 1);
 		chunk_offs = (strip_no / no_chunk) << strip_bits;
-		phys_offs = chunk_offs + strip_offs;
+		offset = chunk_offs + strip_offs;
 
 		/* get size remaining in this stripe */
 		length = MIN(strip_size - strip_offs, datalen);
@@ -428,7 +428,7 @@ sr_raid5_rw(struct sr_workunit *wu)
 		if (chunk >= parity)
 			chunk++;
 
-		lba = phys_offs >> DEV_BSHIFT;
+		lba = offset >> DEV_BSHIFT;
 
 		/* XXX big hammer.. exclude I/O from entire stripe */
 		if (wu->swu_blk_start == 0)
@@ -580,7 +580,7 @@ sr_raid5_write(struct sr_workunit *wu, struct sr_workunit *wu_r, int chunk,
 	 */
 
 	DNPRINTF(SR_D_DIS, "%s: %s sr_raid5_write chunk %i parity %i "
-	    "blk %llu\n", DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
+	    "blkno %llu\n", DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname,
 	    chunk, parity, (unsigned long long)blkno);
 
 	chunk_online = sr_raid5_chunk_online(sd, chunk);
diff --git a/sys/dev/softraid_raid6.c b/sys/dev/softraid_raid6.c
index e1df6c92b25..8afa6f5662e 100644
--- a/sys/dev/softraid_raid6.c
+++ b/sys/dev/softraid_raid6.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraid_raid6.c,v 1.68 2015/07/19 21:06:04 krw Exp $ */
+/* $OpenBSD: softraid_raid6.c,v 1.69 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2009 Marco Peereboom <marco@peereboom.us>
  * Copyright (c) 2009 Jordan Hargrave <jordan@openbsd.org>
@@ -376,15 +376,15 @@ sr_raid6_rw(struct sr_workunit *wu)
 	struct scsi_xfer	*xs = wu->swu_xs;
 	struct sr_chunk		*scp;
 	int			s, fail, i, gxinv, pxinv;
-	daddr_t			blk, lba;
-	int64_t			chunk_offs, lbaoffs, phys_offs, strip_offs;
+	daddr_t			blkno, lba;
+	int64_t			chunk_offs, lbaoffs, offset, strip_offs;
 	int64_t			strip_no, strip_size, strip_bits, row_size;
 	int64_t			fchunk, no_chunk, chunk, qchunk, pchunk;
 	long			length, datalen;
 	void			*pbuf, *data, *qbuf;
 
-	/* blk and scsi error will be handled by sr_validate_io */
-	if (sr_validate_io(wu, &blk, "sr_raid6_rw"))
+	/* blkno and scsi error will be handled by sr_validate_io */
+	if (sr_validate_io(wu, &blkno, "sr_raid6_rw"))
 		goto bad;
 
 	strip_size = sd->sd_meta->ssdi.ssd_strip_size;
@@ -394,7 +394,7 @@ sr_raid6_rw(struct sr_workunit *wu)
 
 	data = xs->data;
 	datalen = xs->datalen;
-	lbaoffs	= blk << DEV_BSHIFT;
+	lbaoffs	= blkno << DEV_BSHIFT;
 
 	if (xs->flags & SCSI_DATA_OUT) {
 		if ((wu_r = sr_scsi_wu_get(sd, SCSI_NOSLEEP)) == NULL){
@@ -410,7 +410,7 @@ sr_raid6_rw(struct sr_workunit *wu)
 		strip_no = lbaoffs >> strip_bits;
 		strip_offs = lbaoffs & (strip_size - 1);
 		chunk_offs = (strip_no / no_chunk) << strip_bits;
-		phys_offs = chunk_offs + strip_offs;
+		offset = chunk_offs + strip_offs;
 
 		/* get size remaining in this stripe */
 		length = MIN(strip_size - strip_offs, datalen);
@@ -428,7 +428,7 @@ sr_raid6_rw(struct sr_workunit *wu)
 		if (chunk >= qchunk)
 			chunk++;
 
-		lba = phys_offs >> DEV_BSHIFT;
+		lba = offset >> DEV_BSHIFT;
 
 		/* XXX big hammer.. exclude I/O from entire stripe */
 		if (wu->swu_blk_start == 0)
@@ -737,10 +737,9 @@ sr_raid6_addio(struct sr_workunit *wu, int chunk, daddr_t blkno,
 	struct sr_ccb		*ccb;
 	struct sr_raid6_opaque  *pqbuf;
 
-	DNPRINTF(SR_D_DIS, "sr_raid6_addio: %s %d.%llx %llx %p:%p\n",
+	DNPRINTF(SR_D_DIS, "sr_raid6_addio: %s %d.%lld %ld %p:%p\n",
 	    (xsflags & SCSI_DATA_IN) ? "read" : "write", chunk,
-	    (long long)blkno, (long long)len,
-	    pbuf, qbuf);
+	    (long long)blkno, len, pbuf, qbuf);
 
 	/* Allocate temporary buffer. */
 	if (data == NULL) {
diff --git a/sys/dev/softraidvar.h b/sys/dev/softraidvar.h
index 721f9851bb2..86f757c344b 100644
--- a/sys/dev/softraidvar.h
+++ b/sys/dev/softraidvar.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: softraidvar.h,v 1.160 2015/07/19 18:24:16 krw Exp $ */
+/* $OpenBSD: softraidvar.h,v 1.161 2015/07/21 03:30:51 krw Exp $ */
 /*
  * Copyright (c) 2006 Marco Peereboom <marco@peereboom.us>
  * Copyright (c) 2008 Chris Kuethe <ckuethe@openbsd.org>
@@ -153,7 +153,7 @@ struct sr_metadata {
 	char			ssd_devname[32];/* /dev/XXXXX */
 	u_int32_t		ssd_meta_flags;
 #define	SR_META_DIRTY		0x1
-	u_int32_t		ssd_data_offset;
+	u_int32_t		ssd_data_blkno;
 	u_int64_t		ssd_ondisk;	/* on disk version counter */
 	int64_t			ssd_rebuild;	/* last block of rebuild */
 } __packed;
@@ -271,7 +271,7 @@ struct sr_boot_volume {
 	u_int32_t	sbv_flags;		/* Volume specific flags. */
 	u_int32_t	sbv_state;		/* Volume state. */
 	int64_t		sbv_size;		/* Virtual disk size. */
-	u_int32_t	sbv_data_offset;	/* Data offset. */
+	u_int32_t	sbv_data_blkno;		/* Data offset. */
 	u_int64_t	sbv_ondisk;		/* Ondisk version. */
 
 	u_int32_t	sbv_chunks_found;	/* Number of chunks found. */