rf_testcode.c

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

    rf_FreeAccessStripeMap(rasm);
    
    if (markbad)
      rf_FailDisk(raidPtr, badrow, badcol, 0);
    if (markbad2)
      rf_FailDisk(raidPtr, badrow2, badcol2, 0);
    type = RF_IO_TYPE_WRITE;
    retcode = rf_DoAccess(raidPtr, type,NULL, raidAddr, numBlocks, buffer, NULL, &wdag, &wasm, RF_DAG_RETURN_ASM|RF_DAG_RETURN_DAG, NULL, NULL, NULL);
    if (wasm == NULL)
      {
	wasm = rf_MapAccess(raidPtr, raidAddr, numBlocks, buffer, RF_DONT_REMAP);
      }

    if (retcode) {printf("Write access failed, code %d\n",retcode); goto eol;}
    else printf("Write Access successful\n");
    
    for (i=0; i<bufSize; i++) if (buffer[i] != tbuf[i]) {
      printf("\n\nData buffer corrupted in write operation: index %d (addr 0x%lx): is %d should be %d\n",
	     i,(long)(buffer+i),buffer[i],i&0xFF);
      exit(1);
    }
    
    (void) bzero(rdbuf, bufSize);
    type = RF_IO_TYPE_READ;
    retcode = rf_DoAccess(raidPtr, type,NULL, raidAddr, numBlocks, rdbuf, NULL, &rdag, &rasm, 
			  RF_DAG_RETURN_ASM|RF_DAG_RETURN_DAG, NULL, NULL, NULL);
    if (rasm == NULL)
      {
	rasm = rf_MapAccess(raidPtr, raidAddr, numBlocks, rdbuf, RF_DONT_REMAP);
      }

    if (retcode) {printf("Read access failed, code %d\n",retcode); goto eol;}
    else printf("Read Access successful\n");

    for (miscomparecount=i=0; i<bufSize; i++) if (rdbuf[i] != buffer[i]) {
      if (++miscomparecount==10) {printf("Quitting after 10 miscompares.\n"); break;}
      printf("MISCOMPARE! index %d: is 0x%x, should be 0x%x\n",i,(u_char) rdbuf[i], (u_char) tbuf[i]);
    }
    /* don't verify parity if we've marked a disk as bad */
    if (raidPtr->Layout.map->faultsTolerated && !markbad) {
      status = rf_VerifyParity(raidPtr, wasm->stripeMap, RF_DONT_CORRECT_PARITY, RF_DAG_FLAGS_NONE);
      if (status == RF_PARITY_COULD_NOT_VERIFY)
        PrintParityVerifyString(status);
      else {
        if (status)
          miscomparecount = 1;
      }
    }

    if (miscomparecount==0)
      printf("\n\nDATA SUCCESSFULLY WRITTEN, RE-READ, AND VERIFIED.\n\n");
    else
      PrintAccessInfo(raidPtr, raidAddr, numBlocks, wasm, wdag, rasm, rdag);
    
    if (wdag != NULL)
      rf_FreeDAG(wdag);
    if (rdag != NULL)
      rf_FreeDAG(rdag);
    rf_FreeAccessStripeMap(wasm);
    rf_FreeAccessStripeMap(rasm);
  eol:
    RF_Free(tbuf, bufSize);
    RF_Free(buffer, bufSize);
    RF_Free(rdbuf, bufSize);
    if (markbad) raidPtr->Disks[badrow][badcol].status = rf_ds_optimal;
  }
}


static int ios_per_thread;   /* quick and dirty communication down to the threads */
static int different_seeds = 0;
static RF_LockTableEntry_t *lockTable;        /* we want to lock stripes at coarser granularity than a single access */

void LoopTest(raidPtr, listp)
  RF_Raid_t           *raidPtr;
  RF_ShutdownList_t  **listp;
{
  int nthreads, i, badrow, badcol, rc, do_copyback;
  RF_Thread_t *tthreads, fthread;
  RF_GRpair_t *grp;
  char cbuf[100];
  long status;

  do_copyback = 0;
  rf_test_running = 0;

  grp = rf_GetGrpair(listp);
  if (grp == NULL) {
    RF_PANIC();
  }
  grp->raidPtr = raidPtr;

  /* make our own stripe lock table */
  /* XXX why??? */
  lockTable = rf_MakeLockTable();
  
  fprintf(stderr,"How many parallel threads? ");
  gets(cbuf);
  nthreads = atoi(cbuf);
  if (nthreads <= 0) {fprintf(stderr,"Huh?\n"); exit(1);}
  fprintf(stderr,"How many I/Os per thread? ");
  gets(cbuf);
  ios_per_thread = atoi(cbuf);
  fprintf(stderr,"Same seed or different seeds in each thread [s/d]? ");
  gets(cbuf);
  if (*cbuf == 'd') different_seeds = 1;
  fprintf(stderr,"Degraded mode? [n=none, c=constant, a=asynchronously, r=async+recon, C=async+recon+copyback] ");
  gets(cbuf);
  rf_testcode_degr_mode_type = *cbuf;
  if (rf_testcode_degr_mode_type == 'C') {
    rf_testcode_degr_mode_type = 'r';
    do_copyback = 1;
  }
  if (rf_testcode_degr_mode_type == 'c') {
    fprintf(stderr,"Row id of disk to mark as bad (-1 for none)? ");
    gets(cbuf);
    badrow = atoi(cbuf);
    if ((badrow >= 0) && (badrow < raidPtr->numRow)) {
      fprintf(stderr,"Column id of disk to mark as bad (-1 for none)? ");
      gets(cbuf);
      badcol = atoi(cbuf);
      if (badcol < 0 || badcol >= raidPtr->numCol) {
        /* cancel it if the user messes up */
        fprintf(stderr, "Not failing a disk.\n");
        rf_testcode_degr_mode_type = 'n';
      }
    }
  }

  /* initialize all parity */
  if (raidPtr->Layout.map->faultsTolerated && rf_rewriteParityStripes) {
    rf_RewriteParity(raidPtr);
  }
  if (rf_testcode_degr_mode_type == 'c') {
    rf_FailDisk(raidPtr, badrow, badcol, 0);
  }
  if (rf_testcode_degr_mode_type == '2') {
    /* jimz's secret, undocumented double failure test */
    rf_FailDisk(raidPtr, 0, 0, 0);
    rf_FailDisk(raidPtr, 0, 2, 0);
  }
  if (rf_testcode_degr_mode_type == '@') {
    /* jimz's other secret, undocumented double failure test */
    rf_FailDisk(raidPtr, 0, 2, 1);
  }
#if RF_DEMO > 0
  if (rf_demoMode) {
    rf_startup_iops_demo(rf_demoMeterVpos, raidPtr->numCol, raidPtr->Layout.numDataCol+raidPtr->Layout.numParityCol);
  }
#endif /* RF_DEMO > 0 */

  RF_CallocAndAdd(tthreads, nthreads, sizeof(RF_Thread_t), (RF_Thread_t *), raidPtr->cleanupList);

  rf_test_running = 1;

  for (i=0; i<nthreads; i++) {
    if (RF_CREATE_THREAD(tthreads[i], RealLoopTest, grp)) {
      RF_ERRORMSG1("Unable to create test thread number %d\n",i);
      punt(1);
    }
    RF_THREADGROUP_STARTED(&grp->group);
  }
  if ((rf_testcode_degr_mode_type == 'a') || (rf_testcode_degr_mode_type == 'r')
    || (rf_testcode_degr_mode_type == '@'))
  {
    if (RF_CREATE_THREAD(fthread, DiskFailingThread, grp)) {
      RF_ERRORMSG1("Unable to create test thread number %d\n",i);
      punt(1);
    }
    RF_THREADGROUP_STARTED(&grp->group);
  }

  RF_THREADGROUP_WAIT_START(&grp->group);
  /* nothing to do in here */
  RF_THREADGROUP_WAIT_STOP(&grp->group);

  /*
   * Do the copyback only after all the user threads have exited,
   * since it quiesces the array anyway.
   */
  if (do_copyback)
    rf_CopybackReconstructedData(raidPtr);

  rf_test_running = 0;
#if RF_DEMO > 0
  if (rf_demoMode) {
    rf_finish_iops_demo();
  }
#endif /* RF_DEMO > 0 */
  rf_ShutdownStripeLocks(lockTable);
}

#endif /* !SIMULATE */

#ifdef SIMULATE

void DoubleDiskFailingThread(arg)
 RF_ThreadArg_t  arg;
{
  RF_Raid_t *raidPtr;

  raidPtr = (RF_Raid_t *)arg;
  rf_assign_threadid();
  disk_has_failed = 1;
  rf_FailDisk(raidPtr, 0, 0, (rf_testcode_degr_mode_type == 'r') ? 1 : 0);
  rf_FailDisk(raidPtr, 0, 1, (rf_testcode_degr_mode_type == 'r') ? 1 : 0);
}

/* this is the execution routine for a thread that waits 10 seconds, fails a disk, and exits */
void DiskFailingThread(arg)
  RF_ThreadArg_t  arg;
{
  RF_Raid_t *raidPtr;
  int badrow, badcol;
  RF_DECLARE_RANDOM;
  unsigned long rv;
  RF_GRpair_t *grp;
  char cbuf[10];

  grp = (RF_GRpair_t *)arg;
  raidPtr = (RF_Raid_t *)arg;;

  RF_INIT_RANDOM(1);
  if (rf_testcode_degr_mode_type == '@') {
    RF_DELAY_THREAD(0,200);
    badrow = 0;
    badcol = 0;
  }
  else {
    RF_DELAY_THREAD(4,0);
    rv = RF_RANDOM();
    badrow = rv % raidPtr->numRow;
    rv = RF_RANDOM();
    badcol = rv % raidPtr->numCol;
  }

  disk_has_failed = 1;
  fflush(stdin); fflush(stdout);
  printf ("Failing Disk (%d,%d) \n",badrow,badcol );
#if RF_DEMO > 0
 if (rf_demoMode)
   rf_demo_update_mode (RF_DEMO_DEGRADED);
#endif /* RF_DEMO > 0 */
  rf_FailDisk(raidPtr, badrow, badcol, (rf_testcode_degr_mode_type == 'a') ? 0 : 1);
}

#else /* SIMULATE */

void DoubleDiskFailingThread(arg)
 RF_ThreadArg_t  arg;
{
  RF_ThreadGroup_t *group;
  RF_Raid_t *raidPtr;
  RF_GRpair_t *grp;

  rf_assign_threadid();
  grp = (RF_GRpair_t *)arg;
  raidPtr = grp->raidPtr;
  group = &grp->group;
  RF_THREADGROUP_RUNNING(group);
  RF_DELAY_THREAD(4,0);
  disk_has_failed = 1;
  rf_FailDisk(raidPtr, 0, 0, (rf_testcode_degr_mode_type == 'r') ? 1 : 0);
  rf_FailDisk(raidPtr, 0, 1, (rf_testcode_degr_mode_type == 'r') ? 1 : 0);
  RF_DELAY_THREAD(20,0);
  RF_THREADGROUP_DONE(group);
  RF_EXIT_THREAD(0);
}

/* this is the execution routine for a thread that waits 10 seconds, fails a disk, and exits */
void DiskFailingThread(arg)
  RF_ThreadArg_t  arg;
{
  RF_ThreadGroup_t *group;
  RF_Raid_t *raidPtr;
  int badrow, badcol;
  RF_DECLARE_RANDOM;
  unsigned long rv;
  RF_GRpair_t *grp;
  char cbuf[10];

  rf_assign_threadid();

  grp = (RF_GRpair_t *)arg;
  raidPtr = grp->raidPtr;
  group = &grp->group;
  RF_THREADGROUP_RUNNING(group);

  RF_INIT_RANDOM(1);
  if (rf_testcode_degr_mode_type == '@') {
    RF_DELAY_THREAD(0,200);
    badrow = 0;
    badcol = 0;
  }
  else {
    RF_DELAY_THREAD(4,0);
    rv = RF_RANDOM();
    badrow = rv % raidPtr->numRow;
    rv = RF_RANDOM();
    badcol = rv % raidPtr->numCol;
  }

  disk_has_failed = 1;
#ifndef KERNEL
  fflush(stdin); fflush(stdout);
#ifndef SIMULATE
#if RF_DEMO > 0
  if (rf_demoMode) {
     printf ("\n");
     printf ("About to fail disk (%d,%d), hit return to Continue:", badrow,badcol);
     gets(cbuf);     
  }
#endif /* RF_DEMO > 0 */
#else /* !SIMULATE */
  printf ("Failing Disk (%d,%d) \n",badrow,badcol );
#endif /* !SIMULATE */
#if RF_DEMO > 0
 if (rf_demoMode)
   rf_demo_update_mode (RF_DEMO_DEGRADED);
#endif /* RF_DEMO > 0 */
#endif /* !KERNEL */
  rf_FailDisk(raidPtr, badrow, badcol, (rf_testcode_degr_mode_type == 'a') ? 0 : 1);
  RF_DELAY_THREAD(20,0); 
  RF_THREADGROUP_DONE(group);
  RF_EXIT_THREAD(0);
}

#endif /* SIMULATE */

#ifndef SIMULATE

#define BUFSIZE (64*1024)
#define B2S(_o_) ((_o_) >> raidPtr->logBytesPerSector)
#define S2B(_o_) ((_o_) << raidPtr->logBytesPerSector)

void FileWriteReadTest(raidPtr)
  RF_Raid_t  *raidPtr;
{
  char *buf, fname[100], cbuf[100];
  int bytesPerSector = S2B(1);
  int fd, nactual, numsect;
  long offset, filesize;
  RF_RowCol_t badcol;

  fprintf(stderr, "Degraded mode? [n=none, c=constant 2 = double failure] ");
  gets(cbuf);
  switch(*cbuf) {
    case 'k':
      /* undocumented, same as c, prompt for which disk */
      rf_testcode_degr_mode_type = 'c';
      fprintf(stderr,"Column id of disk to mark as bad? ");
      gets(cbuf);
      badcol = atoi(cbuf);
      if (badcol < 0) {
        fprintf(stderr, "Bad column id, not failing a disk\n");
        rf_testcode_degr_mode_type = 'n';
      }
      else {
        rf_FailDisk(raidPtr, 0, badcol, 0);
      }
      break;
    case 'c':
      rf_testcode_degr_mode_type = 'c';
      rf_FailDisk(raidPtr, 0, 0, 0);
      break;
    case '2':
      rf_testcode_degr_mode_type = 'c';
      rf_FailDisk(raidPtr, 0,0,0);
      rf_FailDisk(raidPtr, 0,1,0);
      break;
    default:
      rf_testcode_degr_mode_type = 'n';
  }
  fprintf(stderr,"File name? ");
  gets(fname);
  if (fname[ strlen(fname)-1 ] == '\n') fname[ strlen(fname)-1 ] = NULL;    /* strip off newline */
  if (!(fd = open(fname, O_RDONLY, 0))) {
    fprintf(stderr,"Unable to open input file %s\n",fname);
    exit(1);
  }
  RF_Malloc(buf, BUFSIZE, (char *));                                           /* get a 64 KB buffer */

  for (offset = 0, nactual = BUFSIZE; nactual == BUFSIZE; ) {
    if ( (nactual = read(fd, buf, BUFSIZE)) < 0) {
      perror("File read error"); exit(1);
    }
    if (nactual > 0) {
      numsect = B2S((nactual % bytesPerSector) ? ((nactual / bytesPerSector)+1)*bytesPerSector : nactual);
      if (rf_DoAccess(raidPtr, RF_IO_TYPE_WRITE,NULL, B2S(offset), numsect, buf, NULL, NULL, NULL, RF_DAG_FLAGS_NONE, NULL, NULL, NULL)) {
	fprintf(stderr,"Write access failed\n"); exit(1);
      }
    }
    offset += nactual;
  }
  close(fd);
  filesize = offset;

  printf("File %s (%d bytes) successfully transferred to array\n",fname,offset);

  strcat(fname,".new");
  fd = open(fname, O_CREAT|O_WRONLY, 0644);
  if (fd < 0) {
    perror("open");
    fprintf(stderr,"Unable to open output file %s\n",fname);
    exit(1);
  }
  for (offset=0; offset<filesize;) {
    if (rf_DoAccess(raidPtr, RF_IO_TYPE_READ,NULL, B2S(offset), B2S(BUFSIZE), buf, NULL, NULL, NULL, RF_DAG_FLAGS_NONE,NULL,NULL,NULL)) {
      fprintf(stderr,"Read access failed\n"); exit(1);