Major KNF. Incentive from Tedu

1 files changed, 145 insertions, 122 deletions

diff --git a/sys/dev/raidframe/rf_cvscan.c b/sys/dev/raidframe/rf_cvscan.c
index 488e0501bcb..cf55ef631c9 100644
--- a/sys/dev/raidframe/rf_cvscan.c
+++ b/sys/dev/raidframe/rf_cvscan.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_cvscan.c,v 1.4 2000/01/07 14:50:20 peter Exp $	*/
+/*	$OpenBSD: rf_cvscan.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_cvscan.c,v 1.5 1999/08/13 03:41:53 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,13 +28,13 @@
  * rights to redistribute these changes.
  */
 
-/*******************************************************************************
+/*****************************************************************************
  *
  * cvscan.c --  prioritized cvscan disk queueing code.
  *
  * Nov 9, 1994, adapted from raidSim version (MCH)
  *
- ******************************************************************************/
+ *****************************************************************************/
 
 #include "rf_types.h"
 #include "rf_alloclist.h"
@@ -44,28 +45,40 @@
 #include "rf_debugMem.h"
 #include "rf_general.h"
 
-#define DO_CHECK_STATE(_hdr_) CheckCvscanState((_hdr_), __FILE__, __LINE__)
+void rf_CheckCvscanState(RF_CvscanHeader_t *, char *, int);
+void rf_PriorityInsert(RF_DiskQueueData_t **, RF_DiskQueueData_t *);
+void rf_ReqInsert(RF_DiskQueueData_t **, RF_DiskQueueData_t *,
+	RF_CvscanArmDir_t);
+RF_DiskQueueData_t *rf_ReqDequeue(RF_DiskQueueData_t **);
+void rf_ReBalance(RF_CvscanHeader_t *);
+void rf_Transfer(RF_DiskQueueData_t **, RF_DiskQueueData_t **);
+void rf_RealEnqueue(RF_CvscanHeader_t *, RF_DiskQueueData_t *);
+
+#define	DO_CHECK_STATE(_hdr_)	rf_CheckCvscanState((_hdr_), __FILE__, __LINE__)
+
+#define	pri_ok(p)	(((p) == RF_IO_NORMAL_PRIORITY) ||		\
+			 ((p) == RF_IO_LOW_PRIORITY))
 
-#define pri_ok(p)  ( ((p) == RF_IO_NORMAL_PRIORITY) || ((p) == RF_IO_LOW_PRIORITY))
 
-static void 
-CheckCvscanState(RF_CvscanHeader_t * hdr, char *file, int line)
+void
+rf_CheckCvscanState(RF_CvscanHeader_t *hdr, char *file, int line)
 {
-	long    i, key;
+	long i, key;
 	RF_DiskQueueData_t *tmp;
 
 	if (hdr->left != (RF_DiskQueueData_t *) NULL)
 		RF_ASSERT(hdr->left->sectorOffset < hdr->cur_block);
 	for (key = hdr->cur_block, i = 0, tmp = hdr->left;
-	    tmp != (RF_DiskQueueData_t *) NULL;
-	    key = tmp->sectorOffset, i++, tmp = tmp->next)
+	     tmp != (RF_DiskQueueData_t *) NULL;
+	     key = tmp->sectorOffset, i++, tmp = tmp->next)
 		RF_ASSERT(tmp->sectorOffset <= key
-		    && tmp->priority == hdr->nxt_priority && pri_ok(tmp->priority));
+		    && tmp->priority == hdr->nxt_priority && 
+		    pri_ok(tmp->priority));
 	RF_ASSERT(i == hdr->left_cnt);
 
 	for (key = hdr->cur_block, i = 0, tmp = hdr->right;
-	    tmp != (RF_DiskQueueData_t *) NULL;
-	    key = tmp->sectorOffset, i++, tmp = tmp->next) {
+	     tmp != (RF_DiskQueueData_t *) NULL;
+	     key = tmp->sectorOffset, i++, tmp = tmp->next) {
 		RF_ASSERT(key <= tmp->sectorOffset);
 		RF_ASSERT(tmp->priority == hdr->nxt_priority);
 		RF_ASSERT(pri_ok(tmp->priority));
@@ -73,8 +86,8 @@ CheckCvscanState(RF_CvscanHeader_t * hdr, char *file, int line)
 	RF_ASSERT(i == hdr->right_cnt);
 
 	for (key = hdr->nxt_priority - 1, tmp = hdr->burner;
-	    tmp != (RF_DiskQueueData_t *) NULL;
-	    key = tmp->priority, tmp = tmp->next) {
+	     tmp != (RF_DiskQueueData_t *) NULL;
+	     key = tmp->priority, tmp = tmp->next) {
 		RF_ASSERT(tmp);
 		RF_ASSERT(hdr);
 		RF_ASSERT(pri_ok(tmp->priority));
@@ -84,45 +97,47 @@ CheckCvscanState(RF_CvscanHeader_t * hdr, char *file, int line)
 }
 
 
-
-static void 
-PriorityInsert(RF_DiskQueueData_t ** list_ptr, RF_DiskQueueData_t * req)
+void
+rf_PriorityInsert(RF_DiskQueueData_t **list_ptr, RF_DiskQueueData_t *req)
 {
-	/* * insert block pointed to by req in to list whose first * entry is
-	 * pointed to by the pointer that list_ptr points to * ie., list_ptr
-	 * is a grandparent of the first entry */
+	/*
+	 * Insert block pointed to by req into list whose first entry is
+	 * pointed to by the pointer that list_ptr points to.
+	 * i.e. list_ptr is a grandparent of the first entry.
+	 */
 
 	for (; (*list_ptr) != (RF_DiskQueueData_t *) NULL &&
-	    (*list_ptr)->priority > req->priority;
-	    list_ptr = &((*list_ptr)->next)) {
+	       (*list_ptr)->priority > req->priority;
+	     list_ptr = &((*list_ptr)->next)) {
 	}
 	req->next = (*list_ptr);
 	(*list_ptr) = req;
 }
 
 
-
-static void 
-ReqInsert(RF_DiskQueueData_t ** list_ptr, RF_DiskQueueData_t * req, RF_CvscanArmDir_t order)
+void
+rf_ReqInsert(RF_DiskQueueData_t **list_ptr, RF_DiskQueueData_t *req,
+    RF_CvscanArmDir_t order)
 {
-	/* * insert block pointed to by req in to list whose first * entry is
-	 * pointed to by the pointer that list_ptr points to * ie., list_ptr
-	 * is a grandparent of the first entry */
+	/*
+	 * Insert block pointed to by req into list whose first entry is
+	 * pointed to by the pointer that list_ptr points to.
+	 * i.e. list_ptr is a grandparent of the first entry.
+	 */
 
 	for (; (*list_ptr) != (RF_DiskQueueData_t *) NULL &&
-
-	    ((order == rf_cvscan_RIGHT && (*list_ptr)->sectorOffset <= req->sectorOffset)
-		|| (order == rf_cvscan_LEFT && (*list_ptr)->sectorOffset > req->sectorOffset));
-	    list_ptr = &((*list_ptr)->next)) {
+	       ((order == rf_cvscan_RIGHT && (*list_ptr)->sectorOffset <=
+	       req->sectorOffset) || (order == rf_cvscan_LEFT &&
+	       (*list_ptr)->sectorOffset > req->sectorOffset));
+	     list_ptr = &((*list_ptr)->next)) {
 	}
 	req->next = (*list_ptr);
 	(*list_ptr) = req;
 }
 
 
-
-static RF_DiskQueueData_t *
-ReqDequeue(RF_DiskQueueData_t ** list_ptr)
+RF_DiskQueueData_t *
+rf_ReqDequeue(RF_DiskQueueData_t **list_ptr)
 {
 	RF_DiskQueueData_t *ret = (*list_ptr);
 	if ((*list_ptr) != (RF_DiskQueueData_t *) NULL) {
@@ -132,40 +147,39 @@ ReqDequeue(RF_DiskQueueData_t ** list_ptr)
 }
 
 
-
-static void 
-ReBalance(RF_CvscanHeader_t * hdr)
+void
+rf_ReBalance(RF_CvscanHeader_t *hdr)
 {
 	/* DO_CHECK_STATE(hdr); */
 	while (hdr->right != (RF_DiskQueueData_t *) NULL
 	    && hdr->right->sectorOffset < hdr->cur_block) {
 		hdr->right_cnt--;
 		hdr->left_cnt++;
-		ReqInsert(&hdr->left, ReqDequeue(&hdr->right), rf_cvscan_LEFT);
+		rf_ReqInsert(&hdr->left, rf_ReqDequeue(&hdr->right),
+		    rf_cvscan_LEFT);
 	}
 	/* DO_CHECK_STATE(hdr); */
 }
 
 
-
-static void 
-Transfer(RF_DiskQueueData_t ** to_list_ptr, RF_DiskQueueData_t ** from_list_ptr)
+void
+rf_Transfer(RF_DiskQueueData_t **to_list_ptr, RF_DiskQueueData_t **from_list_ptr)
 {
 	RF_DiskQueueData_t *gp;
 	for (gp = (*from_list_ptr); gp != (RF_DiskQueueData_t *) NULL;) {
 		RF_DiskQueueData_t *p = gp->next;
-		PriorityInsert(to_list_ptr, gp);
+		rf_PriorityInsert(to_list_ptr, gp);
 		gp = p;
 	}
 	(*from_list_ptr) = (RF_DiskQueueData_t *) NULL;
 }
 
 
-
-static void 
-RealEnqueue(RF_CvscanHeader_t * hdr, RF_DiskQueueData_t * req)
+void
+rf_RealEnqueue(RF_CvscanHeader_t *hdr, RF_DiskQueueData_t *req)
 {
-	RF_ASSERT(req->priority == RF_IO_NORMAL_PRIORITY || req->priority == RF_IO_LOW_PRIORITY);
+	RF_ASSERT(req->priority == RF_IO_NORMAL_PRIORITY ||
+	    req->priority == RF_IO_LOW_PRIORITY);
 
 	DO_CHECK_STATE(hdr);
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0) {
@@ -173,27 +187,27 @@ RealEnqueue(RF_CvscanHeader_t * hdr, RF_DiskQueueData_t * req)
 	}
 	if (req->priority > hdr->nxt_priority) {
 		/*
-		** dump all other outstanding requests on the back burner
-		*/
-		Transfer(&hdr->burner, &hdr->left);
-		Transfer(&hdr->burner, &hdr->right);
+		 * Dump all other outstanding requests on the back burner.
+		 */
+		rf_Transfer(&hdr->burner, &hdr->left);
+		rf_Transfer(&hdr->burner, &hdr->right);
 		hdr->left_cnt = 0;
 		hdr->right_cnt = 0;
 		hdr->nxt_priority = req->priority;
 	}
 	if (req->priority < hdr->nxt_priority) {
 		/*
-		** yet another low priority task!
-		*/
-		PriorityInsert(&hdr->burner, req);
+		 * Yet another low priority task !
+		 */
+		rf_PriorityInsert(&hdr->burner, req);
 	} else {
 		if (req->sectorOffset < hdr->cur_block) {
-			/* this request is to the left of the current arms */
-			ReqInsert(&hdr->left, req, rf_cvscan_LEFT);
+			/* This request is to the left of the current arms. */
+			rf_ReqInsert(&hdr->left, req, rf_cvscan_LEFT);
 			hdr->left_cnt++;
 		} else {
-			/* this request is to the right of the current arms */
-			ReqInsert(&hdr->right, req, rf_cvscan_RIGHT);
+			/* This request is to the right of the current arms. */
+			rf_ReqInsert(&hdr->right, req, rf_cvscan_RIGHT);
 			hdr->right_cnt++;
 		}
 	}
@@ -201,16 +215,14 @@ RealEnqueue(RF_CvscanHeader_t * hdr, RF_DiskQueueData_t * req)
 }
 
 
-
-void 
-rf_CvscanEnqueue(void *q_in, RF_DiskQueueData_t * elem, int priority)
+void
+rf_CvscanEnqueue(void *q_in, RF_DiskQueueData_t *elem, int priority)
 {
 	RF_CvscanHeader_t *hdr = (RF_CvscanHeader_t *) q_in;
-	RealEnqueue(hdr, elem /* req */ );
+	rf_RealEnqueue(hdr, elem /* req */ );
 }
 
 
-
 RF_DiskQueueData_t *
 rf_CvscanDequeue(void *q_in)
 {
@@ -224,17 +236,20 @@ rf_CvscanDequeue(void *q_in)
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0)
 		return ((RF_DiskQueueData_t *) NULL);
 
-	range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt, hdr->right_cnt));
+	range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt,
+	    hdr->right_cnt));
 	for (i = 0, tmp = hdr->left, sum_dist_left =
-	    ((hdr->direction == rf_cvscan_RIGHT) ? range * hdr->change_penalty : 0);
-	    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-	    tmp = tmp->next, i++) {
+	     ((hdr->direction == rf_cvscan_RIGHT) ?
+	      range * hdr->change_penalty : 0);
+	     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+	     tmp = tmp->next, i++) {
 		sum_dist_left += hdr->cur_block - tmp->sectorOffset;
 	}
 	for (i = 0, tmp = hdr->right, sum_dist_right =
-	    ((hdr->direction == rf_cvscan_LEFT) ? range * hdr->change_penalty : 0);
-	    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-	    tmp = tmp->next, i++) {
+	     ((hdr->direction == rf_cvscan_LEFT) ?
+	      range * hdr->change_penalty : 0);
+	     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+	     tmp = tmp->next, i++) {
 		sum_dist_right += tmp->sectorOffset - hdr->cur_block;
 	}
 
@@ -243,27 +258,28 @@ rf_CvscanDequeue(void *q_in)
 		hdr->cur_block = hdr->left->sectorOffset + hdr->left->numSector;
 		hdr->left_cnt = RF_MAX(hdr->left_cnt - 1, 0);
 		tmp = hdr->left;
-		ret = (ReqDequeue(&hdr->left)) /*->parent*/ ;
+		ret = (rf_ReqDequeue(&hdr->left)) /*->parent*/ ;
 	} else {
 		hdr->direction = rf_cvscan_RIGHT;
-		hdr->cur_block = hdr->right->sectorOffset + hdr->right->numSector;
+		hdr->cur_block = hdr->right->sectorOffset +
+		    hdr->right->numSector;
 		hdr->right_cnt = RF_MAX(hdr->right_cnt - 1, 0);
 		tmp = hdr->right;
-		ret = (ReqDequeue(&hdr->right)) /*->parent*/ ;
+		ret = (rf_ReqDequeue(&hdr->right)) /*->parent*/ ;
 	}
-	ReBalance(hdr);
+	rf_ReBalance(hdr);
 
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0
 	    && hdr->burner != (RF_DiskQueueData_t *) NULL) {
 		/*
-		** restore low priority requests for next dequeue
-		*/
+		 * Restore low priority requests for next dequeue.
+		 */
 		RF_DiskQueueData_t *burner = hdr->burner;
 		hdr->nxt_priority = burner->priority;
-		while (burner != (RF_DiskQueueData_t *) NULL
-		    && burner->priority == hdr->nxt_priority) {
+		while (burner != (RF_DiskQueueData_t *) NULL &&
+		    burner->priority == hdr->nxt_priority) {
 			RF_DiskQueueData_t *next = burner->next;
-			RealEnqueue(hdr, burner);
+			rf_RealEnqueue(hdr, burner);
 			burner = next;
 		}
 		hdr->burner = burner;
@@ -273,7 +289,6 @@ rf_CvscanDequeue(void *q_in)
 }
 
 
-
 RF_DiskQueueData_t *
 rf_CvscanPeek(void *q_in)
 {
@@ -286,17 +301,20 @@ rf_CvscanPeek(void *q_in)
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0)
 		headElement = NULL;
 	else {
-		range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt, hdr->right_cnt));
+		range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt,
+		    hdr->right_cnt));
 		for (i = 0, tmp = hdr->left, sum_dist_left =
-		    ((hdr->direction == rf_cvscan_RIGHT) ? range * hdr->change_penalty : 0);
-		    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-		    tmp = tmp->next, i++) {
+		     ((hdr->direction == rf_cvscan_RIGHT) ?
+		      range * hdr->change_penalty : 0);
+		     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+		     tmp = tmp->next, i++) {
 			sum_dist_left += hdr->cur_block - tmp->sectorOffset;
 		}
 		for (i = 0, tmp = hdr->right, sum_dist_right =
-		    ((hdr->direction == rf_cvscan_LEFT) ? range * hdr->change_penalty : 0);
-		    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-		    tmp = tmp->next, i++) {
+		     ((hdr->direction == rf_cvscan_LEFT) ?
+		      range * hdr->change_penalty : 0);
+		     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+		     tmp = tmp->next, i++) {
 			sum_dist_right += tmp->sectorOffset - hdr->cur_block;
 		}
 
@@ -309,33 +327,31 @@ rf_CvscanPeek(void *q_in)
 }
 
 
-
 /*
-** CVSCAN( 1, 0 ) is Shortest Seek Time First (SSTF)
-**				lowest average response time
-** CVSCAN( 1, infinity ) is SCAN
-**				lowest response time standard deviation
-*/
+ * CVSCAN( 1, 0 ) is Shortest Seek Time First (SSTF)
+ *				lowest average response time
+ * CVSCAN( 1, infinity ) is SCAN
+ *				lowest response time standard deviation
+ */
 
 
-int 
-rf_CvscanConfigure()
+int
+rf_CvscanConfigure(void)
 {
 	return (0);
 }
 
 
-
 void   *
-rf_CvscanCreate(RF_SectorCount_t sectPerDisk,
-    RF_AllocListElem_t * clList,
-    RF_ShutdownList_t ** listp)
+rf_CvscanCreate(RF_SectorCount_t sectPerDisk, RF_AllocListElem_t *clList,
+    RF_ShutdownList_t **listp)
 {
 	RF_CvscanHeader_t *hdr;
-	long    range = 2;	/* Currently no mechanism to change these */
-	long    penalty = sectPerDisk / 5;
+	long range = 2;		/* Currently no mechanism to change these. */
+	long penalty = sectPerDisk / 5;
 
-	RF_MallocAndAdd(hdr, sizeof(RF_CvscanHeader_t), (RF_CvscanHeader_t *), clList);
+	RF_MallocAndAdd(hdr, sizeof(RF_CvscanHeader_t), (RF_CvscanHeader_t *),
+	    clList);
 	bzero((char *) hdr, sizeof(RF_CvscanHeader_t));
 	hdr->range_for_avg = RF_MAX(range, 1);
 	hdr->change_penalty = RF_MAX(penalty, 0);
@@ -351,10 +367,10 @@ rf_CvscanCreate(RF_SectorCount_t sectPerDisk,
 
 
 #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
-/* PrintCvscanQueue is not used, so we ignore it... */
+/* rf_PrintCvscanQueue is not used, so we ignore it... */
 #else
-static void 
-PrintCvscanQueue(RF_CvscanHeader_t * hdr)
+void
+rf_PrintCvscanQueue(RF_CvscanHeader_t *hdr)
 {
 	RF_DiskQueueData_t *tmp;
 
@@ -364,21 +380,24 @@ PrintCvscanQueue(RF_CvscanHeader_t * hdr)
 	    (int) hdr->cur_block,
 	    (hdr->direction == rf_cvscan_LEFT) ? "LEFT" : "RIGHT");
 	printf("\tLeft(%d): ", hdr->left_cnt);
-	for (tmp = hdr->left; tmp != (RF_DiskQueueData_t *) NULL; tmp = tmp->next)
+	for (tmp = hdr->left; tmp != (RF_DiskQueueData_t *) NULL;
+	     tmp = tmp->next)
 		printf("(%d,%ld,%d) ",
 		    (int) tmp->sectorOffset,
 		    (long) (tmp->sectorOffset + tmp->numSector),
 		    tmp->priority);
 	printf("\n");
 	printf("\tRight(%d): ", hdr->right_cnt);
-	for (tmp = hdr->right; tmp != (RF_DiskQueueData_t *) NULL; tmp = tmp->next)
+	for (tmp = hdr->right; tmp != (RF_DiskQueueData_t *) NULL;
+	     tmp = tmp->next)
 		printf("(%d,%ld,%d) ",
 		    (int) tmp->sectorOffset,
 		    (long) (tmp->sectorOffset + tmp->numSector),
 		    tmp->priority);
 	printf("\n");
 	printf("\tBurner: ");
-	for (tmp = hdr->burner; tmp != (RF_DiskQueueData_t *) NULL; tmp = tmp->next)
+	for (tmp = hdr->burner; tmp != (RF_DiskQueueData_t *) NULL;
+	     tmp = tmp->next)
 		printf("(%d,%ld,%d) ",
 		    (int) tmp->sectorOffset,
 		    (long) (tmp->sectorOffset + tmp->numSector),
@@ -388,21 +407,24 @@ PrintCvscanQueue(RF_CvscanHeader_t * hdr)
 #endif
 
 
-/* promotes reconstruction accesses for the given stripeID to normal priority.
- * returns 1 if an access was found and zero otherwise.  Normally, we should
- * only have one or zero entries in the burner queue, so execution time should
- * be short.
+/*
+ * Promote reconstruction accesses for the given stripeID to normal priority.
+ * Return 1 if an access was found and zero otherwise.
+ * Normally, we should only have one or zero entries in the burner queue,
+ * so execution time should be short.
  */
-int 
-rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID, RF_ReconUnitNum_t which_ru)
+int
+rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID,
+    RF_ReconUnitNum_t which_ru)
 {
 	RF_CvscanHeader_t *hdr = (RF_CvscanHeader_t *) q_in;
 	RF_DiskQueueData_t *trailer = NULL, *tmp = hdr->burner, *tlist = NULL;
-	int     retval = 0;
+	int retval = 0;
 
 	DO_CHECK_STATE(hdr);
-	while (tmp) {		/* handle entries at the front of the list */
-		if (tmp->parityStripeID == parityStripeID && tmp->which_ru == which_ru) {
+	while (tmp) {		/* Handle entries at the front of the list. */
+		if (tmp->parityStripeID == parityStripeID &&
+		    tmp->which_ru == which_ru) {
 			hdr->burner = tmp->next;
 			tmp->priority = RF_IO_NORMAL_PRIORITY;
 			tmp->next = tlist;
@@ -415,12 +437,13 @@ rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID, RF_ReconUnitNum_t wh
 		trailer = tmp;
 		tmp = tmp->next;
 	}
-	while (tmp) {		/* handle entries on the rest of the list */
-		if (tmp->parityStripeID == parityStripeID && tmp->which_ru == which_ru) {
+	while (tmp) {		/* Handle entries on the rest of the list. */
+		if (tmp->parityStripeID == parityStripeID &&
+		    tmp->which_ru == which_ru) {
 			trailer->next = tmp->next;
 			tmp->priority = RF_IO_NORMAL_PRIORITY;
 			tmp->next = tlist;
-			tlist = tmp;	/* insert on a temp queue */
+			tlist = tmp;	/* Insert on a temp queue. */
 			tmp = trailer->next;
 		} else {
 			trailer = tmp;
@@ -430,7 +453,7 @@ rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID, RF_ReconUnitNum_t wh
 	while (tlist) {
 		retval++;
 		tmp = tlist->next;
-		RealEnqueue(hdr, tlist);
+		rf_RealEnqueue(hdr, tlist);
 		tlist = tmp;
 	}
 	RF_ASSERT(retval == 0 || retval == 1);