rf_aselect.c

RAIDFrame是个非常好的磁盘阵列RAID仿真工具

{
  RF_AccessStripeMapHeader_t *asm_h = desc->asmap;
  RF_IoType_t type     = desc->type;
  RF_Raid_t *raidPtr = desc->raidPtr;
  void *bp      = desc->bp;

  RF_AccessStripeMap_t *asmap = asm_h->stripeMap;
  RF_AccessStripeMap_t *asm_p;
  RF_DagHeader_t *dag_h = NULL, *tempdag_h, *lastdag_h;
  int i, j, k;
  RF_VoidFuncPtr *stripeFuncs, normalStripeFuncs[MAXNSTRIPES];

  RF_AccessStripeMap_t *asm_up, *asm_bp;
  RF_AccessStripeMapHeader_t ***asmh_u, *endASMList;
  RF_AccessStripeMapHeader_t ***asmh_b;
  RF_VoidFuncPtr **stripeUnitFuncs, uFunc;
  RF_VoidFuncPtr **blockFuncs, bFunc;
  int numStripesBailed = 0, cantCreateDAGs = RF_FALSE;
  int numStripeUnitsBailed = 0;
  int stripeNum, numUnitDags = 0, stripeUnitNum, numBlockDags = 0;
  RF_StripeNum_t numStripeUnits;
  RF_SectorNum_t numBlocks;
  RF_RaidAddr_t address;
  int length;
  RF_PhysDiskAddr_t *physPtr;
  caddr_t buffer;

  lastdag_h = NULL;
  asmh_u = asmh_b = NULL;
  stripeUnitFuncs = NULL;
  blockFuncs = NULL;

  /* get an array of dag-function creation pointers, try to avoid calling malloc */
  if (asm_h->numStripes <= MAXNSTRIPES) stripeFuncs = normalStripeFuncs;
  else RF_Calloc(stripeFuncs, asm_h->numStripes, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));

  /* walk through the asm list once collecting information */
  /* attempt to find a single creation function for each stripe */
  desc->numStripes = 0;
  for (i=0,asm_p = asmap; asm_p; asm_p=asm_p->next,i++) {
    desc->numStripes++;
    (raidPtr->Layout.map->SelectionFunc)(raidPtr, type, asm_p, &stripeFuncs[i]);
    /* check to see if we found a creation func for this stripe */
    if (stripeFuncs[i] == (RF_VoidFuncPtr) NULL)
      {
	/* could not find creation function for entire stripe
	   so, let's see if we can find one for each stripe unit in the stripe */
	
	if (numStripesBailed == 0)
	  {
	    /* one stripe map header for each stripe we bail on */
	    RF_Malloc(asmh_u, sizeof(RF_AccessStripeMapHeader_t **) * asm_h->numStripes, (RF_AccessStripeMapHeader_t ***));
	    /* create an array of ptrs to arrays of stripeFuncs */
	    RF_Calloc(stripeUnitFuncs, asm_h->numStripes, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr **));
	  }
	
	/* create an array of creation funcs (called stripeFuncs) for this stripe */
	numStripeUnits = asm_p->numStripeUnitsAccessed;
	RF_Calloc(stripeUnitFuncs[numStripesBailed], numStripeUnits, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));
	RF_Malloc(asmh_u[numStripesBailed], numStripeUnits * sizeof(RF_AccessStripeMapHeader_t *), (RF_AccessStripeMapHeader_t **));
	
	/* lookup array of stripeUnitFuncs for this stripe */
	for (j=0, physPtr = asm_p->physInfo; physPtr; physPtr = physPtr->next, j++)
	  {
	    /* remap for series of single stripe-unit accesses */
	    address = physPtr->raidAddress;
	    length  = physPtr->numSector;
	    buffer  = physPtr->bufPtr;

	    asmh_u[numStripesBailed][j] = rf_MapAccess(raidPtr, address, length, buffer, RF_DONT_REMAP);
	    asm_up = asmh_u[numStripesBailed][j]->stripeMap;
	    
	    /* get the creation func for this stripe unit */
	    (raidPtr->Layout.map-> SelectionFunc)(raidPtr, type, asm_up, &(stripeUnitFuncs[numStripesBailed][j]));
	    
	    /* check to see if we found a creation func for this stripe unit */
	    if (stripeUnitFuncs[numStripesBailed][j] == (RF_VoidFuncPtr) NULL)
	      {
		/* could not find creation function for stripe unit so,
		   let's see if we can find one for each block in the stripe unit */
		if (numStripeUnitsBailed == 0)
		  {
		    /* one stripe map header for each stripe unit we bail on */
		    RF_Malloc(asmh_b, sizeof(RF_AccessStripeMapHeader_t **) * asm_h->numStripes * raidPtr->Layout.numDataCol, (RF_AccessStripeMapHeader_t ***));
		    /* create an array of ptrs to arrays of blockFuncs */
		    RF_Calloc(blockFuncs, asm_h->numStripes * raidPtr->Layout.numDataCol, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr **));
		  }

		/* create an array of creation funcs (called blockFuncs) for this stripe unit */
		numBlocks = physPtr->numSector;
		numBlockDags += numBlocks;
		RF_Calloc(blockFuncs[numStripeUnitsBailed], numBlocks, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));
		RF_Malloc(asmh_b[numStripeUnitsBailed], numBlocks * sizeof(RF_AccessStripeMapHeader_t *), (RF_AccessStripeMapHeader_t **));
	
		/* lookup array of blockFuncs for this stripe unit */
		for (k=0; k < numBlocks; k++)
		  {
		    /* remap for series of single stripe-unit accesses */
		    address = physPtr->raidAddress + k;
		    length  = 1;
		    buffer  = physPtr->bufPtr + (k * (1<<raidPtr->logBytesPerSector));
		    
		    asmh_b[numStripeUnitsBailed][k] = rf_MapAccess(raidPtr, address, length, buffer, RF_DONT_REMAP);
		    asm_bp = asmh_b[numStripeUnitsBailed][k]->stripeMap;
		    
		    /* get the creation func for this stripe unit */
		    (raidPtr->Layout.map-> SelectionFunc)(raidPtr, type, asm_bp, &(blockFuncs[numStripeUnitsBailed][k]));
		    
		    /* check to see if we found a creation func for this stripe unit */
		    if (blockFuncs[numStripeUnitsBailed][k] == NULL)
		      cantCreateDAGs = RF_TRUE;
		  }
		numStripeUnitsBailed++;
	      }
	    else
	      {
		numUnitDags++;
	      }
	  }
	RF_ASSERT(j == numStripeUnits);
	numStripesBailed++;
      }
  }

  if (cantCreateDAGs)
    {
      /* free memory and punt */
      if (asm_h->numStripes > MAXNSTRIPES)
	RF_Free(stripeFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
      if (numStripesBailed > 0)
	{
	  stripeNum = 0;
	  for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++)
	    if (stripeFuncs[i] == NULL)
	      {
		numStripeUnits = asm_p->numStripeUnitsAccessed;
		for (j = 0; j < numStripeUnits; j++)
		    rf_FreeAccessStripeMap(asmh_u[stripeNum][j]);
		RF_Free(asmh_u[stripeNum], numStripeUnits * sizeof(RF_AccessStripeMapHeader_t *));
		RF_Free(stripeUnitFuncs[stripeNum], numStripeUnits * sizeof(RF_VoidFuncPtr));
		stripeNum++;
	      }
	  RF_ASSERT(stripeNum == numStripesBailed);
	  RF_Free(stripeUnitFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
	  RF_Free(asmh_u, asm_h->numStripes * sizeof(RF_AccessStripeMapHeader_t **));
	}
      return(1);
    }
  else
    {
      /* begin dag creation */
      stripeNum = 0;
      stripeUnitNum = 0;

      /* create an array of dagLists and fill them in */
      RF_CallocAndAdd(desc->dagArray, desc->numStripes, sizeof(RF_DagList_t), (RF_DagList_t *), desc->cleanupList);

      for (i=0, asm_p = asmap; asm_p; asm_p=asm_p->next,i++) {
	/* grab dag header for this stripe */
	dag_h = NULL;
	desc->dagArray[i].desc = desc;

	if (stripeFuncs[i] == (RF_VoidFuncPtr) NULL)
	  {
	    /* use bailout functions for this stripe */
	    for (j = 0, physPtr = asm_p->physInfo; physPtr; physPtr=physPtr->next, j++)
	      {
		uFunc = stripeUnitFuncs[stripeNum][j];
		if (uFunc == (RF_VoidFuncPtr) NULL)
		  {
		    /* use bailout functions for this stripe unit */
		    for (k = 0; k < physPtr->numSector; k++)
		      {
			/* create a dag for this block */
			InitHdrNode(&tempdag_h, raidPtr, rf_useMemChunks);
			desc->dagArray[i].numDags++;
			if (dag_h == NULL) {
			  dag_h = tempdag_h;
			}
			else {
			  lastdag_h->next = tempdag_h;
			}
			lastdag_h = tempdag_h;
			
			bFunc = blockFuncs[stripeUnitNum][k];
			RF_ASSERT(bFunc);
			asm_bp = asmh_b[stripeUnitNum][k]->stripeMap;
			(*bFunc)(raidPtr, asm_bp, tempdag_h, bp, flags, tempdag_h->allocList);
		      }
		    stripeUnitNum++;
		  }
		else
		  {
		    /* create a dag for this unit */
		    InitHdrNode(&tempdag_h, raidPtr, rf_useMemChunks);
		    desc->dagArray[i].numDags++;
		    if (dag_h == NULL) {
		      dag_h = tempdag_h;
		    }
		    else {
		      lastdag_h->next = tempdag_h;
		    }
		    lastdag_h = tempdag_h;
	  
		    asm_up = asmh_u[stripeNum][j]->stripeMap;
		    (*uFunc)(raidPtr, asm_up, tempdag_h, bp, flags, tempdag_h->allocList);
		  }
	      }
	    RF_ASSERT(j == asm_p->numStripeUnitsAccessed);
	    /* merge linked bailout dag to existing dag collection */
	    stripeNum++;
	  }
	else {
	  /* Create a dag for this parity stripe */
	  InitHdrNode(&tempdag_h, raidPtr, rf_useMemChunks);
	  desc->dagArray[i].numDags++;
	  if (dag_h == NULL) {
	    dag_h = tempdag_h;
	  }
	  else {
	    lastdag_h->next = tempdag_h;
	  }
	  lastdag_h = tempdag_h;
	  
	  (stripeFuncs[i])(raidPtr, asm_p, tempdag_h, bp, flags, tempdag_h->allocList);
	}
	desc->dagArray[i].dags = dag_h;
      }
      RF_ASSERT(i == desc->numStripes);

      /* free memory */
      if (asm_h->numStripes > MAXNSTRIPES)
	RF_Free(stripeFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
      if ((numStripesBailed > 0) || (numStripeUnitsBailed > 0))
	{
	  stripeNum = 0;
	  stripeUnitNum = 0;
	  if (dag_h->asmList)
	    {
	      endASMList = dag_h->asmList;
	      while (endASMList->next)
		endASMList = endASMList->next;
	    }
	  else
	    endASMList = NULL;
	  /* walk through io, stripe by stripe */
	  for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++)
	    if (stripeFuncs[i] == NULL)
	      {
		numStripeUnits = asm_p->numStripeUnitsAccessed;
		/* walk through stripe, stripe unit by stripe unit */
		for (j = 0, physPtr = asm_p->physInfo; physPtr; physPtr = physPtr->next, j++)
		  {
		    if (stripeUnitFuncs[stripeNum][j] == NULL)
		      {
			numBlocks = physPtr->numSector;
			/* walk through stripe unit, block by block */
			for (k = 0; k < numBlocks; k++)
			  if (dag_h->asmList == NULL)
			    {
			      dag_h->asmList = asmh_b[stripeUnitNum][k];
			      endASMList = dag_h->asmList;
			    }
			  else
			    {
			      endASMList->next = asmh_b[stripeUnitNum][k];
			      endASMList = endASMList->next;
			    }
			RF_Free(asmh_b[stripeUnitNum], numBlocks * sizeof(RF_AccessStripeMapHeader_t *));
			RF_Free(blockFuncs[stripeUnitNum], numBlocks * sizeof(RF_VoidFuncPtr));
			stripeUnitNum++;
		      }
		    if (dag_h->asmList == NULL)
		      {
			dag_h->asmList = asmh_u[stripeNum][j];
			endASMList = dag_h->asmList;
		      }
		    else
		      {
			endASMList->next = asmh_u[stripeNum][j];
			endASMList = endASMList->next;
		      }
		  }
		RF_Free(asmh_u[stripeNum], numStripeUnits * sizeof(RF_AccessStripeMapHeader_t *));
		RF_Free(stripeUnitFuncs[stripeNum], numStripeUnits * sizeof(RF_VoidFuncPtr));
		stripeNum++;
	      }
	  RF_ASSERT(stripeNum == numStripesBailed);
	  RF_Free(stripeUnitFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
	  RF_Free(asmh_u, asm_h->numStripes * sizeof(RF_AccessStripeMapHeader_t **));
	  if (numStripeUnitsBailed > 0)
	    {
	      RF_ASSERT(stripeUnitNum == numStripeUnitsBailed);
	      RF_Free(blockFuncs, raidPtr->Layout.numDataCol * asm_h->numStripes * sizeof(RF_VoidFuncPtr));
	      RF_Free(asmh_b, raidPtr->Layout.numDataCol * asm_h->numStripes * sizeof(RF_AccessStripeMapHeader_t **));
	    }
	}
      return(0);
    }
}