Merge from NetBSD, mostly indentation

1 files changed, 345 insertions, 413 deletions

diff --git a/sys/dev/raidframe/rf_reconbuffer.c b/sys/dev/raidframe/rf_reconbuffer.c
index 2c24e47c111..011060ef6db 100644
--- a/sys/dev/raidframe/rf_reconbuffer.c
+++ b/sys/dev/raidframe/rf_reconbuffer.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: rf_reconbuffer.c,v 1.1 1999/01/11 14:29:45 niklas Exp $	*/
-/*	$NetBSD: rf_reconbuffer.c,v 1.1 1998/11/13 04:20:33 oster Exp $	*/
+/*	$OpenBSD: rf_reconbuffer.c,v 1.2 1999/02/16 00:03:20 niklas Exp $	*/
+/*	$NetBSD: rf_reconbuffer.c,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -33,85 +33,6 @@
  *
  ***************************************************/
 
-/* :  
- * Log: rf_reconbuffer.c,v 
- * Revision 1.33  1996/07/27 23:36:08  jimz
- * Solaris port of simulator
- *
- * Revision 1.32  1996/07/17  21:00:58  jimz
- * clean up timer interface, tracing
- *
- * Revision 1.31  1996/07/13  00:00:59  jimz
- * sanitized generalized reconstruction architecture
- * cleaned up head sep, rbuf problems
- *
- * Revision 1.30  1996/06/07  21:33:04  jimz
- * begin using consistent types for sector numbers,
- * stripe numbers, row+col numbers, recon unit numbers
- *
- * Revision 1.29  1996/06/06  01:23:58  jimz
- * don't free reconCtrlPtr until after all fields have been used out of it
- *
- * Revision 1.28  1996/06/05  18:06:02  jimz
- * Major code cleanup. The Great Renaming is now done.
- * Better modularity. Better typing. Fixed a bunch of
- * synchronization bugs. Made a lot of global stuff
- * per-desc or per-array. Removed dead code.
- *
- * Revision 1.27  1996/06/03  23:28:26  jimz
- * more bugfixes
- * check in tree to sync for IPDS runs with current bugfixes
- * there still may be a problem with threads in the script test
- * getting I/Os stuck- not trivially reproducible (runs ~50 times
- * in a row without getting stuck)
- *
- * Revision 1.26  1996/06/02  17:31:48  jimz
- * Moved a lot of global stuff into array structure, where it belongs.
- * Fixed up paritylogging, pss modules in this manner. Some general
- * code cleanup. Removed lots of dead code, some dead files.
- *
- * Revision 1.25  1996/05/31  22:26:54  jimz
- * fix a lot of mapping problems, memory allocation problems
- * found some weird lock issues, fixed 'em
- * more code cleanup
- *
- * Revision 1.24  1996/05/30  12:59:18  jimz
- * make etimer happier, more portable
- *
- * Revision 1.23  1996/05/27  18:56:37  jimz
- * more code cleanup
- * better typing
- * compiles in all 3 environments
- *
- * Revision 1.22  1996/05/24  22:17:04  jimz
- * continue code + namespace cleanup
- * typed a bunch of flags
- *
- * Revision 1.21  1996/05/23  21:46:35  jimz
- * checkpoint in code cleanup (release prep)
- * lots of types, function names have been fixed
- *
- * Revision 1.20  1996/05/23  00:33:23  jimz
- * code cleanup: move all debug decls to rf_options.c, all extern
- * debug decls to rf_options.h, all debug vars preceded by rf_
- *
- * Revision 1.19  1996/05/18  19:51:34  jimz
- * major code cleanup- fix syntax, make some types consistent,
- * add prototypes, clean out dead code, et cetera
- *
- * Revision 1.18  1995/12/12  18:10:06  jimz
- * MIN -> RF_MIN, MAX -> RF_MAX, ASSERT -> RF_ASSERT
- * fix 80-column brain damage in comments
- *
- * Revision 1.17  1995/12/06  15:03:24  root
- * added copyright info
- *
- */
-
-#ifdef _KERNEL
-#define KERNEL
-#endif
-
 #include "rf_raid.h"
 #include "rf_reconbuffer.h"
 #include "rf_acctrace.h"
@@ -122,33 +43,11 @@
 #include "rf_reconutil.h"
 #include "rf_nwayxor.h"
 
-#ifdef KERNEL
 #define Dprintf1(s,a) if (rf_reconbufferDebug) printf(s,a)
 #define Dprintf2(s,a,b) if (rf_reconbufferDebug) printf(s,a,b)
 #define Dprintf3(s,a,b,c) if (rf_reconbufferDebug) printf(s,a,b,c)
 #define Dprintf4(s,a,b,c,d) if (rf_reconbufferDebug) printf(s,a,b,c,d)
 #define Dprintf5(s,a,b,c,d,e) if (rf_reconbufferDebug) printf(s,a,b,c,d,e)
-#else /* KERNEL */
-#define Dprintf1(s,a)         if (rf_reconbufferDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf2(s,a,b)       if (rf_reconbufferDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf3(s,a,b,c)     if (rf_reconbufferDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL)
-#define Dprintf4(s,a,b,c,d)   if (rf_reconbufferDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),NULL,NULL,NULL,NULL)
-#define Dprintf5(s,a,b,c,d,e) if (rf_reconbufferDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),NULL,NULL,NULL)
-#endif /* KERNEL */
-
-#if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
-
-/* XXX XXX XXX This is wrong, for a number of reasons:
-  a) thread_block doesn't exist with UVM
-  b) The prototype begin used here is wrong for the regular VM 
-  (regular VM expects a (char *) as an argument.  I don't put 
-  that in here as this code uses thread_block with no arguments.. :-/ 
-
-*/
-#if 0
-void thread_block(void); 
-#endif
-#endif
 
 /*****************************************************************************************
  *
@@ -174,246 +73,271 @@ void thread_block(void);
  * bufs into the accumulating sum.
  */
 static RF_VoidFuncPtr nWayXorFuncs[] = {
-  NULL, 
-  (RF_VoidFuncPtr)rf_nWayXor1, 
-  (RF_VoidFuncPtr)rf_nWayXor2, 
-  (RF_VoidFuncPtr)rf_nWayXor3, 
-  (RF_VoidFuncPtr)rf_nWayXor4,
-  (RF_VoidFuncPtr)rf_nWayXor5, 
-  (RF_VoidFuncPtr)rf_nWayXor6, 
-  (RF_VoidFuncPtr)rf_nWayXor7, 
-  (RF_VoidFuncPtr)rf_nWayXor8, 
-  (RF_VoidFuncPtr)rf_nWayXor9
+	NULL,
+	(RF_VoidFuncPtr) rf_nWayXor1,
+	(RF_VoidFuncPtr) rf_nWayXor2,
+	(RF_VoidFuncPtr) rf_nWayXor3,
+	(RF_VoidFuncPtr) rf_nWayXor4,
+	(RF_VoidFuncPtr) rf_nWayXor5,
+	(RF_VoidFuncPtr) rf_nWayXor6,
+	(RF_VoidFuncPtr) rf_nWayXor7,
+	(RF_VoidFuncPtr) rf_nWayXor8,
+	(RF_VoidFuncPtr) rf_nWayXor9
 };
-    
-int rf_SubmitReconBuffer(rbuf, keep_it, use_committed)
-  RF_ReconBuffer_t  *rbuf;          /* the recon buffer to submit */
-  int                keep_it;       /* whether we can keep this buffer or we have to return it */
-  int                use_committed; /* whether to use a committed or an available recon buffer */
+
+int 
+rf_SubmitReconBuffer(rbuf, keep_it, use_committed)
+	RF_ReconBuffer_t *rbuf;	/* the recon buffer to submit */
+	int     keep_it;	/* whether we can keep this buffer or we have
+				 * to return it */
+	int     use_committed;	/* whether to use a committed or an available
+				 * recon buffer */
 {
-  RF_LayoutSW_t *lp;
-  int rc;
+	RF_LayoutSW_t *lp;
+	int     rc;
 
-  lp = rbuf->raidPtr->Layout.map;
-  rc = lp->SubmitReconBuffer(rbuf, keep_it, use_committed);
-  return(rc);
+	lp = rbuf->raidPtr->Layout.map;
+	rc = lp->SubmitReconBuffer(rbuf, keep_it, use_committed);
+	return (rc);
 }
 
-int rf_SubmitReconBufferBasic(rbuf, keep_it, use_committed)
-  RF_ReconBuffer_t  *rbuf;          /* the recon buffer to submit */
-  int                keep_it;       /* whether we can keep this buffer or we have to return it */
-  int                use_committed; /* whether to use a committed or an available recon buffer */
+int 
+rf_SubmitReconBufferBasic(rbuf, keep_it, use_committed)
+	RF_ReconBuffer_t *rbuf;	/* the recon buffer to submit */
+	int     keep_it;	/* whether we can keep this buffer or we have
+				 * to return it */
+	int     use_committed;	/* whether to use a committed or an available
+				 * recon buffer */
 {
-  RF_Raid_t *raidPtr                = rbuf->raidPtr;
-  RF_RaidLayout_t *layoutPtr        = &raidPtr->Layout;
-  RF_ReconCtrl_t *reconCtrlPtr      = raidPtr->reconControl[rbuf->row];
-  RF_ReconParityStripeStatus_t *pssPtr;
-  RF_ReconBuffer_t *targetRbuf, *t = NULL;        /* temporary rbuf pointers */
-  caddr_t ta;                                     /* temporary data buffer pointer */
-  RF_CallbackDesc_t *cb, *p;
-  int retcode = 0, created = 0;
-  
-  RF_Etimer_t timer;
-
-  /* makes no sense to have a submission from the failed disk */
-  RF_ASSERT(rbuf);
-  RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
-  
-  Dprintf5("RECON: submission by row %d col %d for psid %ld ru %d (failed offset %ld)\n",
-			       rbuf->row, rbuf->col, (long)rbuf->parityStripeID, rbuf->which_ru, (long)rbuf->failedDiskSectorOffset);
-
-  RF_LOCK_PSS_MUTEX(raidPtr,rbuf->row,rbuf->parityStripeID);
-
-  RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
-
-  pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable, rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
-  RF_ASSERT(pssPtr);  /* if it didn't exist, we wouldn't have gotten an rbuf for it */
-
-  /* check to see if enough buffers have accumulated to do an XOR.  If so, there's no need to
-   * acquire a floating rbuf.  Before we can do any XORing, we must have acquired a destination
-   * buffer.  If we have, then we can go ahead and do the XOR if (1) including this buffer, enough
-   * bufs have accumulated, or (2) this is the last submission for this stripe.
-   * Otherwise, we have to go acquire a floating rbuf.
-   */
-
-  targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
-  if (  (targetRbuf != NULL) && 
-       ((pssPtr->xorBufCount == rf_numBufsToAccumulate-1) || (targetRbuf->count + pssPtr->xorBufCount + 1 == layoutPtr->numDataCol)) ) {
-    pssPtr->rbufsForXor[ pssPtr->xorBufCount++ ] = rbuf;          /* install this buffer */
-    Dprintf3("RECON: row %d col %d invoking a %d-way XOR\n",rbuf->row, rbuf->col,pssPtr->xorBufCount);
-    RF_ETIMER_START(timer);
-    rf_MultiWayReconXor(raidPtr, pssPtr);
-    RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer);
-    raidPtr->accumXorTimeUs += RF_ETIMER_VAL_US(timer);
-    if (!keep_it) {
-      raidPtr->recon_tracerecs[rbuf->col].xor_us = RF_ETIMER_VAL_US(timer);
-      RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-      RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-      raidPtr->recon_tracerecs[rbuf->col].specific.recon.recon_return_to_submit_us +=
-        RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-      RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-  
-      rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
-    }
-    rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);
-
-    /* if use_committed is on, we _must_ consume a buffer off the committed list. */
-    if (use_committed) {
-      t = reconCtrlPtr->committedRbufs;
-      RF_ASSERT(t);
-      reconCtrlPtr->committedRbufs = t->next;
-      rf_ReleaseFloatingReconBuffer(raidPtr, rbuf->row, t);
-    }
-    if (keep_it) {
-      RF_UNLOCK_PSS_MUTEX( raidPtr,rbuf->row,rbuf->parityStripeID);
-      RF_UNLOCK_MUTEX( reconCtrlPtr->rb_mutex );
-      rf_FreeReconBuffer(rbuf);
-      return(retcode);
-    }
-    goto out;
-  }
-
-  /* set the value of "t", which we'll use as the rbuf from here on */
-  if (keep_it) {
-    t = rbuf;
-  }
-  else {
-    if (use_committed) {      /* if a buffer has been committed to us, use it */
-      t = reconCtrlPtr->committedRbufs;
-      RF_ASSERT(t);
-      reconCtrlPtr->committedRbufs = t->next;
-      t->next = NULL;
-    } else if (reconCtrlPtr->floatingRbufs) {
-      t = reconCtrlPtr->floatingRbufs;
-      reconCtrlPtr->floatingRbufs = t->next;
-      t->next = NULL;
-    }
-  }
-
-  /* If we weren't able to acquire a buffer, 
-   * append to the end of the buf list in the recon ctrl struct.
-   */
-  if (!t) {
-    RF_ASSERT(!keep_it && !use_committed);
-    Dprintf2("RECON: row %d col %d failed to acquire floating rbuf\n",rbuf->row, rbuf->col);
-
-    raidPtr->procsInBufWait++;
-    if ( (raidPtr->procsInBufWait == raidPtr->numCol -1) && (raidPtr->numFullReconBuffers == 0)) {
-      printf("Buffer wait deadlock detected.  Exiting.\n");
-      rf_PrintPSStatusTable(raidPtr, rbuf->row);
-      RF_PANIC();
-    }
-    pssPtr->flags |= RF_PSS_BUFFERWAIT;
-    cb = rf_AllocCallbackDesc();                      /* append to buf wait list in recon ctrl structure */
-    cb->row = rbuf->row; cb->col = rbuf->col;
-    cb->callbackArg.v  = rbuf->parityStripeID;
-    cb->callbackArg2.v = rbuf->which_ru;
-    cb->next = NULL;
-    if (!reconCtrlPtr->bufferWaitList) reconCtrlPtr->bufferWaitList = cb;
-    else {       /* might want to maintain head/tail pointers here rather than search for end of list */
-      for (p = reconCtrlPtr->bufferWaitList; p->next; p=p->next);
-      p->next = cb;
-    }
-    retcode = 1;
-    goto out;
-  }
-  Dprintf2("RECON: row %d col %d acquired rbuf\n",rbuf->row, rbuf->col);
-  RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-  RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-  raidPtr->recon_tracerecs[rbuf->col].specific.recon.recon_return_to_submit_us +=
-    RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-  RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-  
-  rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
-
-  /* initialize the buffer */
-  if (t!=rbuf) {
-    t->row = rbuf->row; t->col = reconCtrlPtr->fcol;
-    t->parityStripeID = rbuf->parityStripeID;
-    t->which_ru = rbuf->which_ru;
-    t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
-    t->spRow=rbuf->spRow;
-    t->spCol=rbuf->spCol;
-    t->spOffset=rbuf->spOffset;
-    
-    ta = t->buffer; t->buffer = rbuf->buffer; rbuf->buffer = ta;      /* swap buffers */
-  }
-
-  /* the first installation always gets installed as the destination buffer.
-   * subsequent installations get stacked up to allow for multi-way XOR
-   */
-  if (!pssPtr->rbuf) {pssPtr->rbuf = t; t->count = 1;}
-  else pssPtr->rbufsForXor[ pssPtr->xorBufCount++ ] = t;          /* install this buffer */
-
-  rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);      /* the buffer is full if G=2 */
-
-out:  
-  RF_UNLOCK_PSS_MUTEX( raidPtr,rbuf->row,rbuf->parityStripeID);
-  RF_UNLOCK_MUTEX( reconCtrlPtr->rb_mutex );
-  return(retcode);
+	RF_Raid_t *raidPtr = rbuf->raidPtr;
+	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
+	RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[rbuf->row];
+	RF_ReconParityStripeStatus_t *pssPtr;
+	RF_ReconBuffer_t *targetRbuf, *t = NULL;	/* temporary rbuf
+							 * pointers */
+	caddr_t ta;		/* temporary data buffer pointer */
+	RF_CallbackDesc_t *cb, *p;
+	int     retcode = 0, created = 0;
+
+	RF_Etimer_t timer;
+
+	/* makes no sense to have a submission from the failed disk */
+	RF_ASSERT(rbuf);
+	RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
+
+	Dprintf5("RECON: submission by row %d col %d for psid %ld ru %d (failed offset %ld)\n",
+	    rbuf->row, rbuf->col, (long) rbuf->parityStripeID, rbuf->which_ru, (long) rbuf->failedDiskSectorOffset);
+
+	RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
+
+	RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
+
+	pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable, rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
+	RF_ASSERT(pssPtr);	/* if it didn't exist, we wouldn't have gotten
+				 * an rbuf for it */
+
+	/* check to see if enough buffers have accumulated to do an XOR.  If
+	 * so, there's no need to acquire a floating rbuf.  Before we can do
+	 * any XORing, we must have acquired a destination buffer.  If we
+	 * have, then we can go ahead and do the XOR if (1) including this
+	 * buffer, enough bufs have accumulated, or (2) this is the last
+	 * submission for this stripe. Otherwise, we have to go acquire a
+	 * floating rbuf. */
+
+	targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
+	if ((targetRbuf != NULL) &&
+	    ((pssPtr->xorBufCount == rf_numBufsToAccumulate - 1) || (targetRbuf->count + pssPtr->xorBufCount + 1 == layoutPtr->numDataCol))) {
+		pssPtr->rbufsForXor[pssPtr->xorBufCount++] = rbuf;	/* install this buffer */
+		Dprintf3("RECON: row %d col %d invoking a %d-way XOR\n", rbuf->row, rbuf->col, pssPtr->xorBufCount);
+		RF_ETIMER_START(timer);
+		rf_MultiWayReconXor(raidPtr, pssPtr);
+		RF_ETIMER_STOP(timer);
+		RF_ETIMER_EVAL(timer);
+		raidPtr->accumXorTimeUs += RF_ETIMER_VAL_US(timer);
+		if (!keep_it) {
+			raidPtr->recon_tracerecs[rbuf->col].xor_us = RF_ETIMER_VAL_US(timer);
+			RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+			RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+			raidPtr->recon_tracerecs[rbuf->col].specific.recon.recon_return_to_submit_us +=
+			    RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+			RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+
+			rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
+		}
+		rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);
+
+		/* if use_committed is on, we _must_ consume a buffer off the
+		 * committed list. */
+		if (use_committed) {
+			t = reconCtrlPtr->committedRbufs;
+			RF_ASSERT(t);
+			reconCtrlPtr->committedRbufs = t->next;
+			rf_ReleaseFloatingReconBuffer(raidPtr, rbuf->row, t);
+		}
+		if (keep_it) {
+			RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
+			RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
+			rf_FreeReconBuffer(rbuf);
+			return (retcode);
+		}
+		goto out;
+	}
+	/* set the value of "t", which we'll use as the rbuf from here on */
+	if (keep_it) {
+		t = rbuf;
+	} else {
+		if (use_committed) {	/* if a buffer has been committed to
+					 * us, use it */
+			t = reconCtrlPtr->committedRbufs;
+			RF_ASSERT(t);
+			reconCtrlPtr->committedRbufs = t->next;
+			t->next = NULL;
+		} else
+			if (reconCtrlPtr->floatingRbufs) {
+				t = reconCtrlPtr->floatingRbufs;
+				reconCtrlPtr->floatingRbufs = t->next;
+				t->next = NULL;
+			}
+	}
+
+	/* If we weren't able to acquire a buffer, append to the end of the
+	 * buf list in the recon ctrl struct. */
+	if (!t) {
+		RF_ASSERT(!keep_it && !use_committed);
+		Dprintf2("RECON: row %d col %d failed to acquire floating rbuf\n", rbuf->row, rbuf->col);
+
+		raidPtr->procsInBufWait++;
+		if ((raidPtr->procsInBufWait == raidPtr->numCol - 1) && (raidPtr->numFullReconBuffers == 0)) {
+			printf("Buffer wait deadlock detected.  Exiting.\n");
+			rf_PrintPSStatusTable(raidPtr, rbuf->row);
+			RF_PANIC();
+		}
+		pssPtr->flags |= RF_PSS_BUFFERWAIT;
+		cb = rf_AllocCallbackDesc();	/* append to buf wait list in
+						 * recon ctrl structure */
+		cb->row = rbuf->row;
+		cb->col = rbuf->col;
+		cb->callbackArg.v = rbuf->parityStripeID;
+		cb->callbackArg2.v = rbuf->which_ru;
+		cb->next = NULL;
+		if (!reconCtrlPtr->bufferWaitList)
+			reconCtrlPtr->bufferWaitList = cb;
+		else {		/* might want to maintain head/tail pointers
+				 * here rather than search for end of list */
+			for (p = reconCtrlPtr->bufferWaitList; p->next; p = p->next);
+			p->next = cb;
+		}
+		retcode = 1;
+		goto out;
+	}
+	Dprintf2("RECON: row %d col %d acquired rbuf\n", rbuf->row, rbuf->col);
+	RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+	RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+	raidPtr->recon_tracerecs[rbuf->col].specific.recon.recon_return_to_submit_us +=
+	    RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+	RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+
+	rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
+
+	/* initialize the buffer */
+	if (t != rbuf) {
+		t->row = rbuf->row;
+		t->col = reconCtrlPtr->fcol;
+		t->parityStripeID = rbuf->parityStripeID;
+		t->which_ru = rbuf->which_ru;
+		t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
+		t->spRow = rbuf->spRow;
+		t->spCol = rbuf->spCol;
+		t->spOffset = rbuf->spOffset;
+
+		ta = t->buffer;
+		t->buffer = rbuf->buffer;
+		rbuf->buffer = ta;	/* swap buffers */
+	}
+	/* the first installation always gets installed as the destination
+	 * buffer. subsequent installations get stacked up to allow for
+	 * multi-way XOR */
+	if (!pssPtr->rbuf) {
+		pssPtr->rbuf = t;
+		t->count = 1;
+	} else
+		pssPtr->rbufsForXor[pssPtr->xorBufCount++] = t;	/* install this buffer */
+
+	rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);	/* the buffer is full if
+											 * G=2 */
+
+out:
+	RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
+	RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
+	return (retcode);
 }
 
-int rf_MultiWayReconXor(raidPtr, pssPtr)
-  RF_Raid_t                     *raidPtr;
-  RF_ReconParityStripeStatus_t  *pssPtr;   /* the pss descriptor for this parity stripe */
+int 
+rf_MultiWayReconXor(raidPtr, pssPtr)
+	RF_Raid_t *raidPtr;
+	RF_ReconParityStripeStatus_t *pssPtr;	/* the pss descriptor for this
+						 * parity stripe */
 {
-  int i, numBufs = pssPtr->xorBufCount;
-  int numBytes = rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU);
-  RF_ReconBuffer_t **rbufs = (RF_ReconBuffer_t **) pssPtr->rbufsForXor;
-  RF_ReconBuffer_t *targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
-  
-  RF_ASSERT(pssPtr->rbuf != NULL);
-  RF_ASSERT(numBufs > 0 && numBufs < RF_PS_MAX_BUFS);
-#ifdef KERNEL
+	int     i, numBufs = pssPtr->xorBufCount;
+	int     numBytes = rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU);
+	RF_ReconBuffer_t **rbufs = (RF_ReconBuffer_t **) pssPtr->rbufsForXor;
+	RF_ReconBuffer_t *targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
+
+	RF_ASSERT(pssPtr->rbuf != NULL);
+	RF_ASSERT(numBufs > 0 && numBufs < RF_PS_MAX_BUFS);
+#ifdef _KERNEL
 #if !defined(__NetBSD__) && !defined(__OpenBSD__)
-  thread_block(); /* yield the processor before doing a big XOR */
+	thread_block();		/* yield the processor before doing a big XOR */
 #endif
-#endif /* KERNEL */
-  /*
-   * XXX
-   *
-   * What if more than 9 bufs?
-   */
-  nWayXorFuncs[numBufs](pssPtr->rbufsForXor, targetRbuf, numBytes/sizeof(long));
-
-  /* release all the reconstruction buffers except the last one, which belongs to the
-   * the disk who's submission caused this XOR to take place
-   */
-  for (i=0; i < numBufs-1; i++) {
-    if (rbufs[i]->type == RF_RBUF_TYPE_FLOATING) rf_ReleaseFloatingReconBuffer(raidPtr, rbufs[i]->row, rbufs[i]);
-    else if (rbufs[i]->type == RF_RBUF_TYPE_FORCED) rf_FreeReconBuffer(rbufs[i]);
-    else RF_ASSERT(0);
-  }
-  targetRbuf->count += pssPtr->xorBufCount;
-  pssPtr->xorBufCount = 0;
-  return(0);
+#endif				/* _KERNEL */
+	/*
+         * XXX
+         *
+         * What if more than 9 bufs?
+         */
+	nWayXorFuncs[numBufs] (pssPtr->rbufsForXor, targetRbuf, numBytes / sizeof(long));
+
+	/* release all the reconstruction buffers except the last one, which
+	 * belongs to the the disk who's submission caused this XOR to take
+	 * place */
+	for (i = 0; i < numBufs - 1; i++) {
+		if (rbufs[i]->type == RF_RBUF_TYPE_FLOATING)
+			rf_ReleaseFloatingReconBuffer(raidPtr, rbufs[i]->row, rbufs[i]);
+		else
+			if (rbufs[i]->type == RF_RBUF_TYPE_FORCED)
+				rf_FreeReconBuffer(rbufs[i]);
+			else
+				RF_ASSERT(0);
+	}
+	targetRbuf->count += pssPtr->xorBufCount;
+	pssPtr->xorBufCount = 0;
+	return (0);
 }
-
 /* removes one full buffer from one of the full-buffer lists and returns it.
  *
  * ASSUMES THE RB_MUTEX IS UNLOCKED AT ENTRY.
  */
-RF_ReconBuffer_t *rf_GetFullReconBuffer(reconCtrlPtr)
-  RF_ReconCtrl_t  *reconCtrlPtr;
+RF_ReconBuffer_t *
+rf_GetFullReconBuffer(reconCtrlPtr)
+	RF_ReconCtrl_t *reconCtrlPtr;
 {
-  RF_ReconBuffer_t *p;
-
-  RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
-
-  if ( (p=reconCtrlPtr->priorityList) != NULL) {
-    reconCtrlPtr->priorityList = p->next;
-    p->next = NULL;
-    goto out;
-  }
-  if ( (p=reconCtrlPtr->fullBufferList) != NULL) {
-    reconCtrlPtr->fullBufferList = p->next;
-    p->next = NULL;
-    goto out;
-  }
-
+	RF_ReconBuffer_t *p;
+
+	RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
+
+	if ((p = reconCtrlPtr->priorityList) != NULL) {
+		reconCtrlPtr->priorityList = p->next;
+		p->next = NULL;
+		goto out;
+	}
+	if ((p = reconCtrlPtr->fullBufferList) != NULL) {
+		reconCtrlPtr->fullBufferList = p->next;
+		p->next = NULL;
+		goto out;
+	}
 out:
-  RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
-  return(p);
+	RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
+	return (p);
 }
 
 
@@ -422,96 +346,100 @@ out:
  *
  * ASSUMES THE RB_MUTEX IS LOCKED AT ENTRY.
  */
-int rf_CheckForFullRbuf(raidPtr, reconCtrl, pssPtr, numDataCol)
-  RF_Raid_t                     *raidPtr;
-  RF_ReconCtrl_t                *reconCtrl;
-  RF_ReconParityStripeStatus_t  *pssPtr;
-  int                            numDataCol;
+int 
+rf_CheckForFullRbuf(raidPtr, reconCtrl, pssPtr, numDataCol)
+	RF_Raid_t *raidPtr;
+	RF_ReconCtrl_t *reconCtrl;
+	RF_ReconParityStripeStatus_t *pssPtr;
+	int     numDataCol;
 {
-  RF_ReconBuffer_t *p, *pt, *rbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
-
-  if (rbuf->count == numDataCol) {
-    raidPtr->numFullReconBuffers++;
-    Dprintf2("RECON: rbuf for psid %ld ru %d has filled\n",
-	     (long)rbuf->parityStripeID, rbuf->which_ru);
-    if (!reconCtrl->fullBufferList || (rbuf->failedDiskSectorOffset < reconCtrl->fullBufferList->failedDiskSectorOffset)) {
-      Dprintf2("RECON: rbuf for psid %ld ru %d is head of list\n", 
-	       (long)rbuf->parityStripeID, rbuf->which_ru);
-      rbuf->next = reconCtrl->fullBufferList;
-      reconCtrl->fullBufferList = rbuf;
-    }
-    else {
-      for (pt = reconCtrl->fullBufferList, p = pt->next; p && p->failedDiskSectorOffset < rbuf->failedDiskSectorOffset; pt=p, p=p->next);
-      rbuf->next = p;
-      pt->next = rbuf;
-      Dprintf2("RECON: rbuf for psid %ld ru %d is in list\n", 
-	       (long)rbuf->parityStripeID, rbuf->which_ru);
-    }
+	RF_ReconBuffer_t *p, *pt, *rbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
+
+	if (rbuf->count == numDataCol) {
+		raidPtr->numFullReconBuffers++;
+		Dprintf2("RECON: rbuf for psid %ld ru %d has filled\n",
+		    (long) rbuf->parityStripeID, rbuf->which_ru);
+		if (!reconCtrl->fullBufferList || (rbuf->failedDiskSectorOffset < reconCtrl->fullBufferList->failedDiskSectorOffset)) {
+			Dprintf2("RECON: rbuf for psid %ld ru %d is head of list\n",
+			    (long) rbuf->parityStripeID, rbuf->which_ru);
+			rbuf->next = reconCtrl->fullBufferList;
+			reconCtrl->fullBufferList = rbuf;
+		} else {
+			for (pt = reconCtrl->fullBufferList, p = pt->next; p && p->failedDiskSectorOffset < rbuf->failedDiskSectorOffset; pt = p, p = p->next);
+			rbuf->next = p;
+			pt->next = rbuf;
+			Dprintf2("RECON: rbuf for psid %ld ru %d is in list\n",
+			    (long) rbuf->parityStripeID, rbuf->which_ru);
+		}
 #if 0
-    pssPtr->writeRbuf = pssPtr->rbuf;        /* DEBUG ONLY:  we like to be able to find this rbuf while it's awaiting write */
+		pssPtr->writeRbuf = pssPtr->rbuf;	/* DEBUG ONLY:  we like
+							 * to be able to find
+							 * this rbuf while it's
+							 * awaiting write */
 #else
-    rbuf->pssPtr = pssPtr;
+		rbuf->pssPtr = pssPtr;
 #endif
-    pssPtr->rbuf = NULL;
-    rf_CauseReconEvent(raidPtr, rbuf->row, rbuf->col, NULL, RF_REVENT_BUFREADY);
-  }
-  return(0);
+		pssPtr->rbuf = NULL;
+		rf_CauseReconEvent(raidPtr, rbuf->row, rbuf->col, NULL, RF_REVENT_BUFREADY);
+	}
+	return (0);
 }
 
 
 /* release a floating recon buffer for someone else to use.
  * assumes the rb_mutex is LOCKED at entry
  */
-void rf_ReleaseFloatingReconBuffer(raidPtr, row, rbuf)
-  RF_Raid_t         *raidPtr;
-  RF_RowCol_t        row;
-  RF_ReconBuffer_t  *rbuf;
+void 
+rf_ReleaseFloatingReconBuffer(raidPtr, row, rbuf)
+	RF_Raid_t *raidPtr;
+	RF_RowCol_t row;
+	RF_ReconBuffer_t *rbuf;
 {
-  RF_ReconCtrl_t *rcPtr = raidPtr->reconControl[row];
-  RF_CallbackDesc_t *cb;
-
-  Dprintf2("RECON: releasing rbuf for psid %ld ru %d\n",
-	   (long)rbuf->parityStripeID, rbuf->which_ru);
-  
-  /* if anyone is waiting on buffers, wake one of them up.  They will subsequently wake up anyone
-   * else waiting on their RU
-   */
-  if (rcPtr->bufferWaitList) {
-    rbuf->next = rcPtr->committedRbufs;
-    rcPtr->committedRbufs = rbuf;
-    cb = rcPtr->bufferWaitList;
-    rcPtr->bufferWaitList = cb->next;
-    rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 1, RF_REVENT_BUFCLEAR);  /* arg==1 => we've committed a buffer */
-    rf_FreeCallbackDesc(cb);
-    raidPtr->procsInBufWait--;
-  } else {
-    rbuf->next = rcPtr->floatingRbufs;
-    rcPtr->floatingRbufs = rbuf;
-  }
+	RF_ReconCtrl_t *rcPtr = raidPtr->reconControl[row];
+	RF_CallbackDesc_t *cb;
+
+	Dprintf2("RECON: releasing rbuf for psid %ld ru %d\n",
+	    (long) rbuf->parityStripeID, rbuf->which_ru);
+
+	/* if anyone is waiting on buffers, wake one of them up.  They will
+	 * subsequently wake up anyone else waiting on their RU */
+	if (rcPtr->bufferWaitList) {
+		rbuf->next = rcPtr->committedRbufs;
+		rcPtr->committedRbufs = rbuf;
+		cb = rcPtr->bufferWaitList;
+		rcPtr->bufferWaitList = cb->next;
+		rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 1, RF_REVENT_BUFCLEAR);	/* arg==1 => we've
+												 * committed a buffer */
+		rf_FreeCallbackDesc(cb);
+		raidPtr->procsInBufWait--;
+	} else {
+		rbuf->next = rcPtr->floatingRbufs;
+		rcPtr->floatingRbufs = rbuf;
+	}
 }
-
 /* release any disk that is waiting on a buffer for the indicated RU.
  * assumes the rb_mutex is LOCKED at entry
  */
-void rf_ReleaseBufferWaiters(raidPtr, pssPtr)
-  RF_Raid_t                     *raidPtr;
-  RF_ReconParityStripeStatus_t  *pssPtr;
+void 
+rf_ReleaseBufferWaiters(raidPtr, pssPtr)
+	RF_Raid_t *raidPtr;
+	RF_ReconParityStripeStatus_t *pssPtr;
 {
-  RF_CallbackDesc_t *cb1, *cb = pssPtr->bufWaitList;
-
-  Dprintf2("RECON: releasing buf waiters for psid %ld ru %d\n",
-	   (long)pssPtr->parityStripeID, pssPtr->which_ru);
-  pssPtr->flags &= ~RF_PSS_BUFFERWAIT;
-  while (cb) {
-    cb1 = cb->next;
-    cb->next = NULL;
-    rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 0, RF_REVENT_BUFCLEAR);  /* arg==0 => we haven't committed a buffer */
-    rf_FreeCallbackDesc(cb);
-    cb = cb1;
-  }
-  pssPtr->bufWaitList = NULL;
+	RF_CallbackDesc_t *cb1, *cb = pssPtr->bufWaitList;
+
+	Dprintf2("RECON: releasing buf waiters for psid %ld ru %d\n",
+	    (long) pssPtr->parityStripeID, pssPtr->which_ru);
+	pssPtr->flags &= ~RF_PSS_BUFFERWAIT;
+	while (cb) {
+		cb1 = cb->next;
+		cb->next = NULL;
+		rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 0, RF_REVENT_BUFCLEAR);	/* arg==0 => we haven't
+												 * committed a buffer */
+		rf_FreeCallbackDesc(cb);
+		cb = cb1;
+	}
+	pssPtr->bufWaitList = NULL;
 }
-
 /* when reconstruction is forced on an RU, there may be some disks waiting to
  * acquire a buffer for that RU.  Since we allocate a new buffer as part of
  * the forced-reconstruction process, we no longer have to wait for any
@@ -519,20 +447,24 @@ void rf_ReleaseBufferWaiters(raidPtr, pssPtr)
  *
  * assumes the rb_mutex is LOCKED at entry
  */
-void rf_ReleaseBufferWaiter(rcPtr, rbuf)
-  RF_ReconCtrl_t    *rcPtr;
-  RF_ReconBuffer_t  *rbuf;
+void 
+rf_ReleaseBufferWaiter(rcPtr, rbuf)
+	RF_ReconCtrl_t *rcPtr;
+	RF_ReconBuffer_t *rbuf;
 {
-  RF_CallbackDesc_t *cb, *cbt;
-
-  for (cbt = NULL, cb = rcPtr->bufferWaitList; cb; cbt = cb, cb=cb->next) {
-    if ( (cb->callbackArg.v == rbuf->parityStripeID) && ( cb->callbackArg2.v == rbuf->which_ru)) {
-      Dprintf2("RECON: Dropping row %d col %d from buffer wait list\n", cb->row, cb->col);
-      if (cbt) cbt->next = cb->next;
-      else rcPtr->bufferWaitList = cb->next;
-      rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, cb->row, cb->col, (void *) 0, RF_REVENT_BUFREADY);  /* arg==0 => no committed buffer */
-      rf_FreeCallbackDesc(cb);
-      return;
-    }
-  }
+	RF_CallbackDesc_t *cb, *cbt;
+
+	for (cbt = NULL, cb = rcPtr->bufferWaitList; cb; cbt = cb, cb = cb->next) {
+		if ((cb->callbackArg.v == rbuf->parityStripeID) && (cb->callbackArg2.v == rbuf->which_ru)) {
+			Dprintf2("RECON: Dropping row %d col %d from buffer wait list\n", cb->row, cb->col);
+			if (cbt)
+				cbt->next = cb->next;
+			else
+				rcPtr->bufferWaitList = cb->next;
+			rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, cb->row, cb->col, (void *) 0, RF_REVENT_BUFREADY);	/* arg==0 => no
+																 * committed buffer */
+			rf_FreeCallbackDesc(cb);
+			return;
+		}
+	}
 }