 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_desc.h,v 1.21 2019/10/10 03:43:59 christos Exp $	*/
+/*	$NetBSD: rf_desc.h,v 1.22 2021/07/23 02:35:14 oster Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Mark Holland
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 @@ -81,17 +81,16 @@ struct RF_RaidAccessDesc_s {
 	RF_VoidPointerListElem_t *iobufs; /* iobufs that need to be cleaned
 					     up at the end of this IO */
 	RF_VoidPointerListElem_t *stripebufs; /* stripe buffers that need to
 						 be cleaned up at the end of
 						 this IO */
 	RF_AccessStripeMapHeader_t *asmap;	/* the asm for this I/O */
 	struct buf *bp;		/* buf pointer for this RAID acc */
 	RF_AccTraceEntry_t tracerec;	/* perf monitoring information for a
 					 * user access (not for dag stats) */
 	void    (*callbackFunc) (void *);	/* callback function for this
 						 * I/O */
 	void   *callbackArg;	/* arg to give to callback func */
 	RF_RaidAccessDesc_t *next;
 	int     async_flag;
 	RF_Etimer_t timer;	/* used for timing this access */
 };
 #endif				/* !_RF__RF_DESC_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_driver.c,v 1.138 2021/07/23 00:54:45 oster Exp $	*/
+/*	$NetBSD: rf_driver.c,v 1.139 2021/07/23 02:35:14 oster Exp $	*/
 /*-
  * Copyright (c) 1999 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster
+ *
  * 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
 @@ -56,27 +56,27 @@
  * rights to redistribute these changes.
  */
 /******************************************************************************
+ *
  * rf_driver.c -- main setup, teardown, and access routines for the RAID driver
+ *
  * all routines are prefixed with rf_ (raidframe), to avoid conficts.
+ *
  ******************************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.138 2021/07/23 00:54:45 oster Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.139 2021/07/23 02:35:14 oster Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_raid_diagnostic.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include "rf_archs.h"
 @@ -655,33 +655,31 @@ rf_FreeRaidAccDesc(RF_RaidAccessDesc_t *
 	rf_lock_mutex2(raidPtr->rad_lock);
 	raidPtr->nAccOutstanding--;
 	if (raidPtr->waitShutdown) {
 		rf_signal_cond2(raidPtr->outstandingCond);
+	}
 	rf_unlock_mutex2(raidPtr->rad_lock);
+}
 /*********************************************************************
  * Main routine for performing an access.
  * Accesses are retried until a DAG can not be selected.  This occurs
  * when either the DAG library is incomplete or there are too many
  * failures in a parity group.
+ *
- * type should be read or write async_flag should be RF_TRUE or
+ * type should be read or write.  bp_in is a buf pointer.  void *to
- * RF_FALSE bp_in is a buf pointer.  void *to facilitate ignoring it
+ * facilitate ignoring it outside the kernel
  * outside the kernel
  ********************************************************************/
 int
-rf_DoAccess(RF_Raid_t * raidPtr, RF_IoType_t type, int async_flag,
+rf_DoAccess(RF_Raid_t * raidPtr, RF_IoType_t type, RF_RaidAddr_t raidAddress, RF_SectorCount_t numBlocks,
 	    RF_RaidAddr_t raidAddress, RF_SectorCount_t numBlocks,
 	    void *bufPtr, struct buf *bp, RF_RaidAccessFlags_t flags)
+{
 	RF_RaidAccessDesc_t *desc;
 	void *lbufPtr = bufPtr;
 	raidAddress += rf_raidSectorOffset;
 #if RF_ACCESS_DEBUG
 	if (rf_accessDebug) {
 		printf("logBytes is: %d %d %d\n", raidPtr->raidid,
 		    raidPtr->logBytesPerSector,
 		    (int) rf_RaidAddressToByte(raidPtr, numBlocks));
 @@ -694,27 +692,26 @@ rf_DoAccess(RF_Raid_t * raidPtr, RF_IoTy
 		    (long) bufPtr);
+	}
 #endif
 	desc = rf_AllocRaidAccDesc(raidPtr, type, raidAddress,
 	    numBlocks, lbufPtr, bp, flags, raidPtr->Layout.map->states);
 	if (desc == NULL) {
 		return (ENOMEM);
+	}
 #if RF_ACC_TRACE > 0
 	RF_ETIMER_START(desc->tracerec.tot_timer);
 #endif
 	desc->async_flag = async_flag;
 	if (raidPtr->parity_map != NULL &&
 	    type == RF_IO_TYPE_WRITE)
 		rf_paritymap_begin(raidPtr->parity_map, raidAddress,
 		    numBlocks);
 	rf_ContinueRaidAccess(desc);
 	return (0);
+}
 #if 0
 /* force the array into reconfigured mode without doing reconstruction */
 int

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_driver.h,v 1.20 2015/12/26 00:58:45 pgoyette Exp $	*/
+/*	$NetBSD: rf_driver.h,v 1.21 2021/07/23 02:35:14 oster Exp $	*/
 /*
  * rf_driver.h
  */
 /*
  * Copyright (c) 1996 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Jim Zelenka
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
 @@ -42,25 +42,25 @@
 #endif
 extern rf_declare_mutex2(rf_printf_mutex);
 int rf_BootRaidframe(bool);
 int rf_UnbootRaidframe(void);
 int rf_Shutdown(RF_Raid_t *);
 int rf_Configure(RF_Raid_t *, RF_Config_t *, RF_AutoConfig_t *);
 RF_RaidAccessDesc_t *rf_AllocRaidAccDesc(RF_Raid_t *, RF_IoType_t,
 					 RF_RaidAddr_t, RF_SectorCount_t,
 					 void *, void *,
 					 RF_RaidAccessFlags_t,
 					 const RF_AccessState_t *);
 void rf_FreeRaidAccDesc(RF_RaidAccessDesc_t *);
-int rf_DoAccess(RF_Raid_t *, RF_IoType_t, int, RF_RaidAddr_t,
+int rf_DoAccess(RF_Raid_t *, RF_IoType_t, RF_RaidAddr_t,
 		RF_SectorCount_t, void *, struct buf *,
 		RF_RaidAccessFlags_t);
 #if 0
 int rf_SetReconfiguredMode(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
 #endif
 int rf_FailDisk(RF_Raid_t *, RF_RowCol_t, int);
 void rf_SignalQuiescenceLock(RF_Raid_t *);
 int rf_SuspendNewRequestsAndWait(RF_Raid_t *);
 void rf_ResumeNewRequests(RF_Raid_t *);
 #endif				/* !_RF__RF_DRIVER_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_netbsdkintf.c,v 1.395 2021/07/23 00:54:45 oster Exp $	*/
+/*	$NetBSD: rf_netbsdkintf.c,v 1.396 2021/07/23 02:35:14 oster Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998, 2008-2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster; Jason R. Thorpe.
+ *
  * 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.
 @@ -91,27 +91,27 @@
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /***********************************************************
+ *
  * rf_kintf.c -- the kernel interface routines for RAIDframe
+ *
  ***********************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.395 2021/07/23 00:54:45 oster Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.396 2021/07/23 02:35:14 oster Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_raid_autoconfig.h"
 #include "opt_compat_netbsd32.h"
 #endif
 #include <sys/param.h>
 #include <sys/errno.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/disk.h>
 #include <sys/device.h>
 @@ -1894,27 +1894,26 @@ raidstart(RF_Raid_t *raidPtr)
 		printf("raid%d: raidstart not ready\n", raidPtr->raidid);
 		return;
+	}
 	dk_start(dksc, NULL);
+}
 static int
 raiddoaccess(RF_Raid_t *raidPtr, struct buf *bp)
+{
 	RF_SectorCount_t num_blocks, pb, sum;
 	RF_RaidAddr_t raid_addr;
 	daddr_t blocknum;
 	int     do_async;
 	int rc;
 	rf_lock_mutex2(raidPtr->mutex);
 	if (raidPtr->openings == 0) {
 		rf_unlock_mutex2(raidPtr->mutex);
 		return EAGAIN;
+	}
 	rf_unlock_mutex2(raidPtr->mutex);
 	blocknum = bp->b_rawblkno;
 	db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno,
 		    (int) blocknum));
 @@ -1944,37 +1943,32 @@ raiddoaccess(RF_Raid_t *raidPtr, struct
 	 */
 	if (bp->b_bcount & raidPtr->sectorMask) {
 		rc = ENOSPC;
 		goto done;
+	}
 	db1_printf(("Calling DoAccess..\n"));
 	rf_lock_mutex2(raidPtr->mutex);
 	raidPtr->openings--;
 	rf_unlock_mutex2(raidPtr->mutex);
 	/*
 	 * Everything is async.
 	 */
 	do_async = 1;
 	/* don't ever condition on bp->b_flags & B_WRITE.
 	 * always condition on B_READ instead */
 	rc = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ?
 			 RF_IO_TYPE_READ : RF_IO_TYPE_WRITE,
-			 do_async, raid_addr, num_blocks,
+			 raid_addr, num_blocks,
 			 bp->b_data, bp, RF_DAG_NONBLOCKING_IO);
 done:
 	return rc;
+}
 /* invoke an I/O from kernel mode.  Disk queue should be locked upon entry */
 int
 rf_DispatchKernelIO(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req)
+{
 	int     op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE;
 	struct buf *bp;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_states.c,v 1.52 2021/07/23 00:54:45 oster Exp $	*/
+/*	$NetBSD: rf_states.c,v 1.53 2021/07/23 02:35:14 oster Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Mark Holland, William V. Courtright II, Robby Findler
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 @@ -17,27 +17,27 @@
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_states.c,v 1.52 2021/07/23 00:54:45 oster Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_states.c,v 1.53 2021/07/23 02:35:14 oster Exp $");
 #include <sys/errno.h>
 #include "rf_archs.h"
 #include "rf_threadstuff.h"
 #include "rf_raid.h"
 #include "rf_dag.h"
 #include "rf_desc.h"
 #include "rf_aselect.h"
 #include "rf_general.h"
 #include "rf_states.h"
 #include "rf_dagutils.h"
 #include "rf_driver.h"
 @@ -206,31 +206,26 @@ rf_ContinueDagAccess(RF_DagList_t *dagLi
 #endif
+	}
 	dagList->numDagsDone++;
 	rf_ContinueRaidAccess(desc);
+}
 int
 rf_State_LastState(RF_RaidAccessDesc_t *desc)
+{
 	void    (*callbackFunc) (void *) = desc->callbackFunc;
 	void * callbackArg = desc->callbackArg;
 	/*
 	 * We don't support non-async IO.
 	 */
 	KASSERT(desc->async_flag);
 	/*
 	 * The parity_map hook has to go here, because the iodone
 	 * callback goes straight into the kintf layer.
 	 */
 	if (desc->raidPtr->parity_map != NULL &&
 	    desc->type == RF_IO_TYPE_WRITE)
 		rf_paritymap_end(desc->raidPtr->parity_map,
 		    desc->raidAddress, desc->numBlocks);
 	/* printf("Calling raiddone on 0x%x\n",desc->bp); */
 	raiddone(desc->raidPtr, desc->bp); /* access came through ioctl */
 	if (callbackFunc)
 		callbackFunc(callbackArg);