layout_g1.c

来自「disksim是一个非常优秀的磁盘仿真工具」· C语言 代码 · 共 2,170 行 · 第 1/4 页

{
  int i;
  int blkspercyl;
  int slips = 0;

  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  struct dm_layout_g1_band *b = find_band_lbn(l, lbn);
  lbn -= l->band_blknos[b->num];
  lbn += b->deadspace;

  if ((maptype == MAP_ADDSLIPS) || (maptype == MAP_FULL)) {
    for (i=0; i<b->numslips; i++) {
      if (b->slip[i] <= (lbn+slips)) {
	slips++;
      }
    }
  }
  lbn += slips;

  if (maptype == MAP_FULL) {
    for (i=0; i<b->numdefects; i++) {
      if ((b->defect[i] == lbn) && 
	  (b->remap[i] != b->defect[i])) {

	if(remapsector) *remapsector = 1;
	lbn = b->remap[i];
	break;
      }
    }
  }

  blkspercyl = b->blkspertrack * d->dm_surfaces;

  result->cyl = b->startcyl + lbn / blkspercyl;
  result->head = (lbn % blkspercyl) / b->blkspertrack;
  result->head = g1_surfno_on_cyl(l,b,result);
  result->sector = lbn % b->blkspertrack;

  return DM_OK;
}


/*
 * NOTE: The total number of allowable slips and remaps per band is
 * equal to the number of spare tracks per band.  The following code
 * will produce incorrect results if this rule is violated.  To fix
 * this, b needs to be re-calculated after the detection of a
 * slip or spare.  Also, slips on immediately previous bands need to
 * be accounted for.  Lastly, the mismatch in sectors per track
 * between zones must be handled.  
 * Extremely low priority.  
 */

static dm_ptol_result_t
g1_ltop_trackspare(struct dm_disk_if *d, 
		   int lbn, 
		   dm_layout_maptype maptype,
		   struct dm_pbn *result,
 		   int *remapsector)

{
  int i;
  int blkspertrack;
  int trackno;


  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  struct dm_layout_g1_band *b = find_band_lbn(l, lbn);
  lbn -= l->band_blknos[b->num];
  lbn += b->deadspace;

  blkspertrack = b->blkspertrack;
  trackno = lbn/blkspertrack;
  if ((maptype == MAP_ADDSLIPS) || (maptype == MAP_FULL)) {
    for (i=0; i<b->numslips; i++) {
      if (b->slip[i] <= trackno) {
	trackno++;
      }
    }
  }
  if (maptype == MAP_FULL) {
    for (i=0; i<b->numdefects; i++) {
      if (b->defect[i] == trackno) {
	trackno = b->remap[i];
	break;
      }
    }
  }

  result->cyl = (trackno/d->dm_surfaces) + b->startcyl;
  result->head = trackno % d->dm_surfaces;
  result->head = g1_surfno_on_cyl(l,b,result);
  result->sector = lbn % blkspertrack;

  return DM_OK;
}


static dm_ptol_result_t
g1_seek_distance(struct dm_disk_if *d,
		 int start_lbn,
		 int end_lbn)
{
  struct dm_pbn p1, p2;
  int rv;

  rv = d->layout->dm_translate_ltop(d, start_lbn, MAP_NONE, &p1, 0);
  if(rv != DM_OK) {
    return rv;
  }

  rv = d->layout->dm_translate_ltop(d, end_lbn, MAP_NONE, &p2, 0);
  if(rv != DM_OK) {
    return rv;
  }

  
  return abs(p2.cyl - p1.cyl);
}


static dm_angle_t
g1_get_sector_width(struct dm_disk_if *d,
		    struct dm_pbn *track,
		    int num)
{
  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  struct dm_layout_g1_band *b = find_band_pbn(l, track);

  dm_angle_t result;

  if(num > b->blkspertrack) {
    return 0;
  }

  result = b->sector_width;
  result *=  num;
  return result;
}

static dm_angle_t
g1_lbn_offset(struct dm_disk_if *d, int lbn1, int lbn2)
{
  struct dm_pbn pbn1, pbn2;
  dm_angle_t a1, a2;

  //  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  //  struct dm_layout_g1_band *b1 = find_band_lbn(l, lbn1);
  //  struct dm_layout_g1_band *b2 = find_band_lbn(l, lbn2);
  
  d->layout->dm_translate_ltop(d, lbn1, MAP_FULL, &pbn1, 0);
  d->layout->dm_translate_ltop(d, lbn2, MAP_FULL, &pbn2, 0);

  a1 = d->layout->dm_pbn_skew(d, &pbn1);
  a2 = d->layout->dm_pbn_skew(d, &pbn2);

  return a2 - a1;
}



static int 
layout_g1_marshaled_len(struct dm_disk_if *d) {
  int c;
  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  int result = sizeof(struct dm_marshal_hdr) + sizeof(struct dm_layout_g1); 

  // band blknos
  result += l->bands_len * sizeof(int);

  // add the zones
  result += l->bands_len * sizeof(struct dm_layout_g1_band);
  for(c = 0; c < l->bands_len; c++) {
    struct dm_layout_g1_band *b = &l->bands[c];
    result += b->numslips * sizeof(int);
    // defects and remapped locations
    result += b->numdefects * 2 * sizeof(int);
  }
  
  return result;
}

static void *
layout_g1_marshal(struct dm_disk_if *d, char *buff) {
  int c;
  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  char *ptr = buff;
  struct dm_marshal_hdr *hdr = (struct dm_marshal_hdr *)buff;
  hdr->type = DM_LAYOUT_G1_TYP;
  hdr->len = layout_g1_marshaled_len(d);
  
  ptr += sizeof(struct dm_marshal_hdr);
  memcpy(ptr, d->layout, sizeof(struct dm_layout_g1));

  // fix function pointers here
  marshal_fns((void **)&l->hdr, 
	       sizeof(l->hdr) / sizeof(void *),
	       ptr,
	       DM_LAYOUT_G1_TYP);

  ptr += sizeof(struct dm_layout_g1);

 
  // now do the zones
  for(c = 0; c < l->bands_len; c++) {
    struct dm_layout_g1_band *b = &l->bands[c];
    memcpy(ptr, b, sizeof(struct dm_layout_g1_band));
    ptr += sizeof(struct dm_layout_g1_band);

    // slips
    memcpy(ptr, b->slip, b->numslips * sizeof(int));
    ptr += b->numslips * sizeof(int);

    // defect locations
    memcpy(ptr, b->defect, b->numdefects * sizeof(int));
    ptr += b->numdefects * sizeof(int);

    // defect remaps
    memcpy(ptr, b->remap, b->numdefects * sizeof(int));
    ptr += b->numdefects * sizeof(int);
  }

  // do the band blknos array
  memcpy(ptr, l->band_blknos, l->bands_len * sizeof(int));
  ptr += l->bands_len * sizeof(int);

  return ptr;
}

char *
layout_g1_unmarshal(struct dm_marshal_hdr *hdr, 
		     void **result,
		     void *parent)
{
  int c;
  struct dm_layout_g1 *l = malloc(sizeof(struct dm_layout_g1));
  char *ptr = (char *)hdr;
  
  ddbg_assert(hdr->type == DM_LAYOUT_G1_TYP);
  
  ptr += sizeof(struct dm_marshal_hdr);

  memcpy(l, ptr, sizeof(struct dm_layout_g1));
  unmarshal_fns((void **)&l->hdr,
		 sizeof(l->hdr) / sizeof(void*),
		 ptr,
		 DM_LAYOUT_G1_TYP);

  ptr += sizeof(struct dm_layout_g1);
  
  l->bands = malloc(l->bands_len * sizeof(struct dm_layout_g1_band));

  // now do the zones
  for(c = 0; c < l->bands_len; c++) {
    struct dm_layout_g1_band *b = &l->bands[c];
    memcpy(b, ptr, sizeof(struct dm_layout_g1_band));
    ptr += sizeof(struct dm_layout_g1_band);

    // slips
    if(b->numslips != 0) {
      b->slip = malloc(b->numslips * sizeof(int));
      memcpy(b->slip, ptr, b->numslips * sizeof(int));
      ptr += b->numslips * sizeof(int);
    }

    // defect locations
    if(b->numdefects != 0) {
      b->defect = malloc(b->numdefects * sizeof(int));
      memcpy(b->defect, ptr, b->numdefects * sizeof(int));
      ptr += b->numdefects * sizeof(int);

      // defect remaps
      b->remap = malloc(b->numdefects * sizeof(int));
      memcpy(b->remap, ptr, b->numdefects * sizeof(int));
      ptr += b->numdefects * sizeof(int);
    }
  }

  // do the band blknos array
  l->band_blknos = malloc(l->bands_len * sizeof(int));
  memcpy(l->band_blknos, ptr, l->bands_len * sizeof(int));
  ptr += l->bands_len * sizeof(int);


  l->disk = parent;

  *result = l;
  return ptr;
}


// returns the number of zones for the layout
static int 
g1_get_numzones(struct dm_disk_if *d) 
{
  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  return l->bands_len;
}

// Fetch the info about the nth zone and store it in the result
// parameter z.  Returns 0 on success, -1 on error (bad n)
// n should be within 0 and (dm_get_numzones() - 1)
static int 
g1_get_zone(struct dm_disk_if *d, 
	    int n, 
	    struct dm_layout_zone *result)
{
  struct dm_layout_g1 *l = (struct dm_layout_g1 *)d->layout;
  struct dm_layout_g1_band *z;

  // check args  
  if(z == 0) { return -1; }
  if(n < 0 || n >= l->bands_len) { return -1; }

  z = &l->bands[n];

  result->spt = z->blkspertrack;
  result->lbn_low = l->band_blknos[n];
  result->lbn_high = l->band_blknos[n] + z->blksinband - 1;

  result->cyl_low = z->startcyl;
  result->cyl_high = z->endcyl;

  return 0;
}


// any function that appears in the interface must be listed here
void *layout_g1_fns[] = {
  g1_ltop_nosparing,
  g1_ltop_sectpertrackspare,  
  g1_ltop_sectpercylspare,
  g1_ltop_sectperrangespare,
  g1_ltop_sectperzonespare,
  g1_ltop_trackspare,

  g1_ltop_0t,

  g1_ptol_nosparing,
  g1_ptol_sectpertrackspare,
  g1_ptol_sectpercylspare,
  g1_ptol_sectperrangespare,
  g1_ptol_sectperzonespare,
  g1_ptol_trackspare,

  g1_ptol_0t,

  g1_st_lbn,
  g1_st_pbn,

  g1_track_boundaries_nosparing,
  g1_track_boundaries_sectpertrackspare,
  g1_track_boundaries_sectpercylspare,
  g1_track_boundaries_sectperrangespare,
  g1_track_boundaries_sectperzonespare,
  g1_track_boundaries_trackspare,

  g1_seek_distance,
  g1_map_pbn_skew,
  g1_get_track_0l,
  g1_convert_ptoa,
  g1_convert_atop,
  g1_get_sector_width,
  layout_g1_marshaled_len,
  layout_g1_marshal,
  g1_lbn_offset,
  g1_get_numzones,
  g1_get_zone
};

struct dm_marshal_module dm_layout_g1_marshal_mod =
{ 
  layout_g1_unmarshal, 
  layout_g1_fns, 
  sizeof(layout_g1_fns) / sizeof(void *) 
};


// instances of interface struct for the various sparing schemes

struct dm_layout_if g1_layout_nosparing = {
  g1_ltop_nosparing,
  g1_ltop_0t,
  g1_ptol_nosparing,
  g1_ptol_0t,
  g1_st_lbn,
  g1_st_pbn,
  g1_track_boundaries_nosparing,
  g1_seek_distance,
  g1_map_pbn_skew,
  g1_get_track_0l,
  g1_convert_ptoa, // ptoa
  g1_convert_atop, // atop
  g1_get_sector_width,
  g1_lbn_offset,
  layout_g1_marshaled_len,
  layout_g1_marshal,
  g1_get_numzones,
  g1_get_zone
};

struct dm_layout_if g1_layout_tracksparing = {
  g1_ltop_trackspare,
  g1_ltop_0t,
  g1_ptol_trackspare,
  g1_ptol_0t,
  g1_st_lbn,
  g1_st_pbn,
  g1_track_boundaries_trackspare,
  g1_seek_distance,
  g1_map_pbn_skew,
  g1_get_track_0l,
  g1_convert_ptoa, // ptoa
  g1_convert_atop, // atop
  g1_get_sector_width,
  g1_lbn_offset,
  layout_g1_marshaled_len,
  layout_g1_marshal,
  g1_get_numzones,
  g1_get_zone
};

struct dm_layout_if g1_layout_sectpertrackspare = {
  g1_ltop_sectpertrackspare,
  g1_ltop_0t,
  g1_ptol_sectpertrackspare,
  g1_ptol_0t,
  g1_st_lbn,
  g1_st_pbn,
  g1_track_boundaries_sectpertrackspare,
  g1_seek_distance,
  g1_map_pbn_skew,
  g1_get_track_0l,
  g1_convert_ptoa, // ptoa
  g1_convert_atop, // atop
  g1_get_sector_width,
  g1_lbn_offset,
  layout_g1_marshaled_len,
  layout_g1_marshal,
  g1_get_numzones,
  g1_get_zone
};

struct dm_layout_if g1_layout_sectpercylspare = {
  g1_ltop_sectpercylspare,
  g1_ltop_0t,
  g1_ptol_sectpercylspare,
  g1_ptol_0t,
  g1_st_lbn,
  g1_st_pbn,
  g1_track_boundaries_sectpercylspare,
  g1_seek_distance,
  g1_map_pbn_skew,
  g1_get_track_0l,
  g1_convert_ptoa, // ptoa
  g1_convert_atop, // atop
  g1_get_sector_width,
  g1_lbn_offset,
  layout_g1_marshaled_len,
  layout_g1_marshal,
  g1_get_numzones,
  g1_get_zone
};

struct dm_layout_if g1_layout_sectperrangespare = {
  g1_ltop_sectperrangespare,
  g1_ltop_0t,
  g1_ptol_sectperrangespare,
  g1_ptol_0t,
  g1_st_lbn,
  g1_st_pbn,
  g1_track_boundaries_sectperrangespare,
  g1_seek_distance,
  g1_map_pbn_skew,
  g1_get_track_0l,
  g1_convert_ptoa,  // ptoa
  g1_convert_atop,  // atop
  g1_get_sector_width,
  g1_lbn_offset,
  layout_g1_marshaled_len,
  layout_g1_marshal,
  g1_get_numzones,
  g1_get_zone
};

struct dm_layout_if g1_layout_sectperzonespare = {
  g1_ltop_sectperzonespare,
  g1_ltop_0t,
  g1_ptol_sectperzonespare,
  g1_ptol_0t,
  g1_st_lbn,
  g1_st_pbn,
  g1_track_boundaries_sectperzonespare,
  g1_seek_distance,
  g1_map_pbn_skew,
  g1_get_track_0l,
  g1_convert_ptoa, // ptoa
  g1_convert_atop,  // atop
  g1_get_sector_width,
  g1_lbn_offset,
  layout_g1_marshaled_len,
  layout_g1_marshal,
  g1_get_numzones,
  g1_get_zone
};




#if 0

// the old old old disksim loader code used this
static void bandcopy(struct dm_layout_g1_band **destbands, 
		     struct dm_layout_g1_band *srcbands, 
		     int numbands)
{
   int i;
   *destbands = malloc(numbands * sizeof(struct dm_layout_g1_band));
   memcpy(*destbands,srcbands,sizeof(struct dm_layout_g1_band));

   for (i=0; i<numbands; i++) {
      (*destbands)[i].slip = malloc (srcbands[i].numslips * sizeof(int));
      (*destbands)[i].defect = malloc (srcbands[i].numdefects * sizeof(int));
      (*destbands)[i].remap = malloc (srcbands[i].numdefects * sizeof(int));

      memcpy((*destbands)[i].slip, 
	     srcbands[i].slip, 
	     srcbands[i].numslips * sizeof(int));
      memcpy((*destbands)[i].defect, 
	     srcbands[i].defect, 
	     srcbands[i].numdefects * sizeof(int));
      memcpy((*destbands)[i].remap, 
	     srcbands[i].remap, 
	     srcbands[i].numdefects * sizeof(int));
   }
}

#endif