rf_evenodd_dagfuncs.c

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

  RF_ASSERT( bytesPerEU % sizeof(short) == 0 );
#elif RF_EO_MATRIX_DIM == 17
  RF_ASSERT( sizeof(long) == 8 || sizeof(long) == 4 );
  RF_ASSERT( bytesPerEU % sizeof(long) == 0);
#endif

  S_index = rf_EO_Mod( ( RF_EO_MATRIX_DIM -1 + destLogicCol - srcLogicCol), RF_EO_MATRIX_DIM);
#if RF_EO_MATRIX_DIM > 17
  srcShortBuf1 = (short *)(srcSecbuf + S_index * bytesPerEU);
#elif RF_EO_MATRIX_DIM == 17
  srcLongBuf1 = (long *)(srcSecbuf + S_index * bytesPerEU);
#endif

  for( indexInDest = 0; indexInDest < numRowInEncMatix ; indexInDest++){
     indexInSrc = rf_EO_Mod( (indexInDest + destLogicCol - srcLogicCol), RF_EO_MATRIX_DIM );

#if RF_EO_MATRIX_DIM > 17
     destShortBuf = (short *)(destSecbuf + indexInDest * bytesPerEU);
     srcShortBuf2 = (short *)(srcSecbuf + indexInSrc * bytesPerEU);
     for(j=0; j < shortsPerEU; j++) {
        temp1 = destShortBuf[j]^srcShortBuf1[j];
        /* note: S_index won't be at the end row for any src col! */
        if(indexInSrc != RF_EO_MATRIX_DIM -1) destShortBuf[j] = (srcShortBuf2[j])^temp1;
        /* if indexInSrc is at the end row, ie. RF_EO_MATRIX_DIM -1, then all elements are zero! */
	else destShortBuf[j] = temp1;
     }

#elif RF_EO_MATRIX_DIM == 17
     destLongBuf = (long *)(destSecbuf + indexInDest * bytesPerEU);
     srcLongBuf2 = (long *)(srcSecbuf + indexInSrc * bytesPerEU);
     for(j=0; j < longsPerEU; j++) {
        temp1 = destLongBuf[j]^srcLongBuf1[j];
        if(indexInSrc != RF_EO_MATRIX_DIM -1) destLongBuf[j] = (srcLongBuf2[j])^temp1;
        else destLongBuf[j] = temp1;
     }
#endif
  }
}

void rf_e_encToBuf(
  RF_Raid_t    *raidPtr,
  RF_RowCol_t   srcLogicCol,
  char         *srcbuf,
  RF_RowCol_t   destLogicCol,
  char         *destbuf,
  int           numSector)
{
  int i, bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);

  for (i=0; i < numSector; i++)
  {
     rf_e_EncOneSect( srcLogicCol, srcbuf, destLogicCol, destbuf, bytesPerSector);
     srcbuf += bytesPerSector; 
     destbuf += bytesPerSector; 
  }
}

/**************************************************************************************  
 * when parity die and one data die, We use second redundant information, 'E', 
 * to recover the data in dead disk. This function is used in the recovery node of 
 * for EO_110_CreateReadDAG 
 **************************************************************************************/
int rf_RecoveryEFunc(node)   
  RF_DagNode_t  *node;
{
  RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams-1].p;
  RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &raidPtr->Layout;
  RF_PhysDiskAddr_t *failedPDA = (RF_PhysDiskAddr_t *) node->params[node->numParams-2].p;
  RF_RowCol_t scol, /*source logical column*/ 
              fcol = rf_EUCol(layoutPtr, failedPDA->raidAddress ); /* logical column of failed SU */
  int i, retcode = 0;
  RF_PhysDiskAddr_t *pda;
  int suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr,failedPDA->startSector);
  char *srcbuf, *destbuf;
  RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
  RF_Etimer_t timer;

  bzero( (char *)node->results[0], rf_RaidAddressToByte(raidPtr,failedPDA->numSector));
  if (node->dagHdr->status == rf_enable) {
    RF_ETIMER_START(timer);
    for (i=0; i<node->numParams-2; i+=2) if (node->params[i+1].p != node->results[0]) {
      pda = (RF_PhysDiskAddr_t *) node->params[i].p;
      if( i == node->numParams - 4 ) scol = RF_EO_MATRIX_DIM - 2; /* the colume of redundant E */
      else scol = rf_EUCol(layoutPtr, pda->raidAddress ); 
      srcbuf = (char *) node->params[i+1].p;
      suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
      destbuf = ((char *) node->results[0]) + rf_RaidAddressToByte(raidPtr,suoffset-failedSUOffset);
      rf_e_encToBuf(raidPtr,  scol, srcbuf, fcol, destbuf, pda->numSector);
    }          
    RF_ETIMER_STOP(timer);
    RF_ETIMER_EVAL(timer);
    tracerec->xor_us += RF_ETIMER_VAL_US(timer);
  }
  return (rf_GenericWakeupFunc(node, 0)); /* node execute successfully */
}

/**************************************************************************************
 * This function is used in the case where one data and the parity have filed.
 * (in EO_110_CreateWriteDAG )
 **************************************************************************************/
int rf_EO_DegradedWriteEFunc(RF_DagNode_t *node)
{
  rf_DegrESubroutine(node, node->results[0]);
  rf_GenericWakeupFunc(node, 0);
}


                                                       
/**************************************************************************************
 *  		THE FUNCTION IS FOR DOUBLE DEGRADED READ AND WRITE CASES
 **************************************************************************************/

void rf_doubleEOdecode(
  RF_Raid_t     *raidPtr,
  char         **rrdbuf,
  char         **dest,
  RF_RowCol_t   *fcol,
  char          *pbuf,
  char          *ebuf)
{
  RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &(raidPtr->Layout);
  int i, j, k, f1, f2, row;
  int rrdrow, erow, count = 0;
  int bytesPerSector = rf_RaidAddressToByte(raidPtr, 1 );
  int numRowInEncMatix = (RF_EO_MATRIX_DIM) -1;
  int pcol = (RF_EO_MATRIX_DIM) - 1;
  int ecol = (RF_EO_MATRIX_DIM) - 2;
  int bytesPerEU = bytesPerSector/numRowInEncMatix;
  int numDataCol  = layoutPtr->numDataCol;
#if RF_EO_MATRIX_DIM > 17
  int shortsPerEU = bytesPerEU/sizeof(short);
  short *rrdbuf_current, *pbuf_current, *ebuf_current;
  short *dest_smaller, *dest_smaller_current, *dest_larger, *dest_larger_current;
  register short *temp;
  short *P;

  RF_ASSERT( bytesPerEU % sizeof(short) == 0);
  RF_Malloc(P, bytesPerEU, (short *));
  RF_Malloc(temp, bytesPerEU, (short *));
#elif RF_EO_MATRIX_DIM == 17
  int longsPerEU = bytesPerEU/sizeof(long);
  long *rrdbuf_current, *pbuf_current, *ebuf_current; 
  long *dest_smaller, *dest_smaller_current, *dest_larger, *dest_larger_current;
  register long *temp;
  long *P;

  RF_ASSERT( bytesPerEU % sizeof(long) == 0);
  RF_Malloc(P, bytesPerEU, (long *));
  RF_Malloc(temp, bytesPerEU, (long *));
#endif
  RF_ASSERT( *((long *)dest[0]) == 0);
  RF_ASSERT( *((long *)dest[1]) == 0);
  bzero((char *)P, bytesPerEU);  
  bzero((char *)temp, bytesPerEU);
  RF_ASSERT( *P == 0 );
  /* calculate the 'P' parameter, which, not parity, is the Xor of all elements in 
     the last two column, ie. 'E' and 'parity' colume, see the Ref. paper by Blaum, et al 1993  */
  for( i=0; i< numRowInEncMatix; i++) 
       for( k=0; k< longsPerEU; k++) { 
#if RF_EO_MATRIX_DIM > 17
            ebuf_current = ((short *)ebuf) + i*shortsPerEU + k;
            pbuf_current = ((short *)pbuf) + i*shortsPerEU + k;
#elif RF_EO_MATRIX_DIM == 17
            ebuf_current = ((long *)ebuf) + i*longsPerEU + k;
            pbuf_current = ((long *)pbuf) + i*longsPerEU + k;
#endif
            P[k] ^= *ebuf_current;
            P[k] ^= *pbuf_current;
       }
  RF_ASSERT( fcol[0] != fcol[1] );
  if( fcol[0] < fcol[1] ) { 
#if RF_EO_MATRIX_DIM > 17
        dest_smaller = (short *)(dest[0]);
        dest_larger = (short *)(dest[1]);
#elif RF_EO_MATRIX_DIM == 17
	dest_smaller = (long *)(dest[0]); 
	dest_larger = (long *)(dest[1]); 
#endif
	f1 = fcol[0]; 
	f2 = fcol[1]; 
  }
  else { 
#if RF_EO_MATRIX_DIM > 17
        dest_smaller = (short *)(dest[1]);
        dest_larger = (short *)(dest[0]);
#elif RF_EO_MATRIX_DIM == 17
	dest_smaller = (long *)(dest[1]); 
	dest_larger = (long *)(dest[0]); 
#endif
	f1 = fcol[1]; 
	f2 = fcol[0]; 
  }
  row = (RF_EO_MATRIX_DIM) -1;
  while( (row = rf_EO_Mod( (row+f1-f2), RF_EO_MATRIX_DIM )) != ( (RF_EO_MATRIX_DIM) -1) )
  {   
#if RF_EO_MATRIX_DIM > 17
       dest_larger_current = dest_larger + row*shortsPerEU;
       dest_smaller_current = dest_smaller + row*shortsPerEU;
#elif RF_EO_MATRIX_DIM == 17
       dest_larger_current = dest_larger + row*longsPerEU;
       dest_smaller_current = dest_smaller + row*longsPerEU;
#endif
       /**    Do the diagonal recovery. Initially, temp[k] = (failed 1), 
	      which is the failed data in the colume which has smaller col index. **/
       /*   step 1:  ^(SUM of nonfailed in-diagonal A(rrdrow,0..m-3))         */
       for( j=0; j< numDataCol; j++)
       {     
             if( j == f1 || j == f2 ) continue;
             rrdrow = rf_EO_Mod( (row+f2-j), RF_EO_MATRIX_DIM );
	     if ( rrdrow != (RF_EO_MATRIX_DIM) -1 ) {
#if RF_EO_MATRIX_DIM > 17
                 rrdbuf_current = (short *)(rrdbuf[j]) + rrdrow * shortsPerEU;
                 for (k=0; k< shortsPerEU; k++) temp[k] ^= *(rrdbuf_current + k);
#elif RF_EO_MATRIX_DIM == 17
	         rrdbuf_current = (long *)(rrdbuf[j]) + rrdrow * longsPerEU;
                 for (k=0; k< longsPerEU; k++) temp[k] ^= *(rrdbuf_current + k);
#endif
	     }
       }         
       /*   step 2:  ^E(erow,m-2), If erow is at the buttom row, don't Xor into it  
	    E(erow,m-2) = (principle diagonal) ^ (failed 1) ^ (failed 2)
                        ^ ( SUM of nonfailed in-diagonal A(rrdrow,0..m-3) ) 
            After this step, temp[k] = (principle diagonal) ^ (failed 2)       */

       erow = rf_EO_Mod( (row+f2-ecol), (RF_EO_MATRIX_DIM) );
       if ( erow != (RF_EO_MATRIX_DIM) -1) {  
#if RF_EO_MATRIX_DIM > 17
           ebuf_current = (short *)ebuf + shortsPerEU * erow;
           for (k=0; k< shortsPerEU; k++) temp[k] ^= *(ebuf_current+k);
#elif RF_EO_MATRIX_DIM == 17
           ebuf_current = (long *)ebuf + longsPerEU * erow;
           for (k=0; k< longsPerEU; k++) temp[k] ^= *(ebuf_current+k);
#endif
       }
       /*   step 3: ^P to obtain the failed data (failed 2).  
	    P can be proved to be actually  (principle diagonal)  
            After this step, temp[k] = (failed 2), the failed data to be recovered */
#if RF_EO_MATRIX_DIM > 17
       for (k=0; k< shortsPerEU; k++) temp[k] ^= P[k];
       /*   Put the data to the destination buffer                              */
       for (k=0; k< shortsPerEU; k++) dest_larger_current[k] = temp[k];
#elif RF_EO_MATRIX_DIM == 17
       for (k=0; k< longsPerEU; k++) temp[k] ^= P[k];
       /*   Put the data to the destination buffer                              */
       for (k=0; k< longsPerEU; k++) dest_larger_current[k] = temp[k];
#endif

       /**          THE FOLLOWING DO THE HORIZONTAL XOR                **/ 
       /*   step 1:  ^(SUM of A(row,0..m-3)), ie. all nonfailed data columes    */ 
       for (j=0; j< numDataCol; j++)      
       {
             if( j == f1 || j == f2 ) continue;
#if RF_EO_MATRIX_DIM > 17
             rrdbuf_current = (short *)(rrdbuf[j]) + row * shortsPerEU;
             for (k=0; k< shortsPerEU; k++) temp[k] ^= *(rrdbuf_current+k);
#elif RF_EO_MATRIX_DIM == 17
	     rrdbuf_current = (long *)(rrdbuf[j]) + row * longsPerEU;
             for (k=0; k< longsPerEU; k++) temp[k] ^= *(rrdbuf_current+k);
#endif
       } 
       /*   step 2: ^A(row,m-1) */
       /*   step 3: Put the data to the destination buffer                             	*/
#if RF_EO_MATRIX_DIM > 17
       pbuf_current = (short *)pbuf + shortsPerEU * row;
       for (k=0; k< shortsPerEU; k++) temp[k] ^= *(pbuf_current+k);
       for (k=0; k< shortsPerEU; k++) dest_smaller_current[k] = temp[k];
#elif RF_EO_MATRIX_DIM == 17
       pbuf_current = (long *)pbuf + longsPerEU * row;
       for (k=0; k< longsPerEU; k++) temp[k] ^= *(pbuf_current+k);      
       for (k=0; k< longsPerEU; k++) dest_smaller_current[k] = temp[k];
#endif
       count++;  
  }
  /*        Check if all Encoding Unit in the data buffer have been decoded, 
	    according EvenOdd theory, if "RF_EO_MATRIX_DIM" is a prime number, 
	    this algorithm will covered all buffer 				 */
  RF_ASSERT( count == numRowInEncMatix );
  RF_Free((char *)P, bytesPerEU);
  RF_Free((char *)temp, bytesPerEU);
}
 

/***************************************************************************************
* 	This function is called by double degragded read
* 	EO_200_CreateReadDAG 								      
*
***************************************************************************************/
int rf_EvenOddDoubleRecoveryFunc(node)
  RF_DagNode_t  *node;