summaryrefslogtreecommitdiff
path: root/sys/dev/raidframe
diff options
context:
space:
mode:
authoroster <oster@NetBSD.org>1999-01-26 04:05:01 +0000
committeroster <oster@NetBSD.org>1999-01-26 04:05:01 +0000
commit472e649cd832d96c79ec1699ce0078187ee8678a (patch)
tree2abbc01d1013aa7d0da16b9838368954ed307bff /sys/dev/raidframe
parentc52883118d004d4ca4042dc2b84f7fb698e0ec19 (diff)
More simulator bits going bye-bye.
Diffstat (limited to 'sys/dev/raidframe')
-rw-r--r--sys/dev/raidframe/rf_geometry.c835
-rw-r--r--sys/dev/raidframe/rf_geometry.h113
2 files changed, 0 insertions, 948 deletions
diff --git a/sys/dev/raidframe/rf_geometry.c b/sys/dev/raidframe/rf_geometry.c
deleted file mode 100644
index bd9b2ec0a08..00000000000
--- a/sys/dev/raidframe/rf_geometry.c
+++ /dev/null
@@ -1,835 +0,0 @@
-/* $NetBSD: rf_geometry.c,v 1.2 1999/01/26 02:33:58 oster Exp $ */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
- * School of Computer Science
- * Carnegie Mellon University
- * Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * Changes:
- * 10/24/91 Changes to support disk bus contention model
- * (MCH) 1. Added media_done_time param to Access_time()
- *
- * 08/18/92 Geometry routines have been modified to support zone-bit
- * recording.
- * (AS) 1. Each routine which originally referenced the variable
- * 'disk->geom->sectors_per_track' has been modified,
- * since the number of sectors per track varies on disks
- * with zone-bit recording.
- */
-
-
-#include "rf_types.h"
-#include "rf_geometry.h"
-#include "rf_raid.h"
-#include "rf_general.h"
-#include "rf_debugMem.h"
-
-#define DISK_DB "disk_db"
-#define DISK_NAME "HP2247"
-
-#define ABS_DIFF(a,b) ( ((a)>(b)) ? ((a)-(b)) : ((b)-(a)) )
-
-static RF_GeometryList_t *geom_list = (RF_GeometryList_t *) NULL;
-
-RF_TICS_t rf_globalSpinup = 1.5;
-
-#define NM_LGTH 80
-#define NM_PATN " %80s"
-
-static RF_GeometryList_t *Fetch_geometry_db(FILE *fd);
-static void Format_disk(RF_DiskState_t *disk, long sectors_per_block);
-static long Find_cyl(RF_SectorNum_t block, RF_DiskState_t *disk);
-static long Find_track(RF_SectorNum_t block, RF_DiskState_t *disk);
-static long Find_phys_sector(RF_SectorNum_t block, RF_DiskState_t *disk);
-static RF_TICS_t Delay_to(RF_TICS_t cur_time, RF_SectorNum_t block,
- RF_DiskState_t *disk);
-static RF_TICS_t Seek_time(long to_cyl, long to_track, long from_cyl,
- long from_track, RF_DiskState_t *disk);
-static RF_TICS_t Seek(RF_TICS_t cur_time, RF_SectorNum_t block,
- RF_DiskState_t *disk, long update);
-static RF_TICS_t Rotate(RF_TICS_t cur_time, RF_SectorNum_t block,
- RF_DiskState_t *disk, long update);
-static RF_TICS_t Seek_Rotate(RF_TICS_t cur_time, RF_SectorNum_t block,
- RF_DiskState_t *disk, long update);
-static RF_TICS_t GAP(long sec_per_track, RF_DiskState_t *disk);
-static RF_TICS_t Block_access_time(RF_TICS_t cur_time, RF_SectorNum_t block,
- RF_SectorCount_t numblocks, RF_DiskState_t *disk, long update);
-static void Zero_stats(RF_DiskState_t *disk);
-static RF_TICS_t Update_stats(RF_TICS_t cur_time, RF_TICS_t seek, RF_TICS_t rotate,
- RF_TICS_t transfer, RF_DiskState_t *disk);
-static void rf_DiskParam(long numCyls, RF_TICS_t minSeek, RF_TICS_t avgSeek, RF_TICS_t maxSeek,
- RF_TICS_t *a, RF_TICS_t *b, RF_TICS_t *c);
-
-static RF_GeometryList_t *Fetch_geometry_db(fd)
- FILE *fd;
-{
- long ret, lineno;
- char name[NM_LGTH], title[20];
- RF_GeometryList_t * list = (RF_GeometryList_t *) NULL,
- ** next_ptr = & list;
-
- if( RF_MAX_DISKNAME_LEN<NM_LGTH ) RF_PANIC();
- lineno = 0;
- while( (ret = fscanf( fd, " %20s", title )) != EOF ) {
- float tmp_f1, tmp_f2, tmp_f3, tmp_f4;
- float tmp_f5=0.0;
- float tmp_f6=0.0;
- RF_Geometry_t *g;
- long i, x, y, z, num_cylinders;
- RF_ZoneList_t ** znext_ptr;
-
- if( ret == 1 && strncmp( "enddisk", title, 8 ) == 0 ) break;
-
- RF_Calloc(*next_ptr, 1, sizeof(RF_GeometryList_t), (RF_GeometryList_t *));
- (*next_ptr)->next = (RF_GeometryList_t *) NULL;
- RF_Calloc(g, 1, sizeof(RF_Geometry_t), (RF_Geometry_t *));
- (*next_ptr)->disk = g;
- next_ptr = &( (*next_ptr)->next ); /*prep for next iteration */
- lineno++;
- if (fscanf( fd, NM_PATN, name ) != 1) {
- fprintf(stderr,"Disk DB Error: Can't get disk name from disk db\n");
- fprintf(stderr,"lineno=%d\n", lineno);
- fprintf(stderr,"name=\"%s\"\n", name);
- exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " tracks per cylinder %ld", &(g->tracks_per_cyl)) != 1) || g->tracks_per_cyl <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid tracks/cyl for disk %s\n", name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " number of disk zones %ld", &(g->num_zones)) != 1) || g->num_zones <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid number of zones for disk %s\n", name); exit(1);
- }
-
-
-
- /* This section of code creates the linked list which
- contains the disk's zone information. */
- g->zbr_data = (RF_ZoneList_t *) NULL;
- znext_ptr = &(g->zbr_data);
- num_cylinders = 0;
-
- /* This for-loop reads in the cylinder count, the sectors
- per track, and track skew for each zone on the disk. */
- for (i=1; i <= g->num_zones; i++) {
- lineno++;
- if ( (fscanf(fd, " number of cylinders in zone %ld", &x) != 1) || x < 1) {
- fprintf(stderr,"Disk DB Error: Zone %ld: Missing or invalid cyls/zone for disk %s\n", i, name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " sectors per track in zone %ld", &y) != 1) || y < 1 ) {
- fprintf(stderr,"Disk DB Error: Zone %ld: Missing or invalid sectors/track for disk %s\n", i, name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " track skew in zone %ld", &z) != 1) || z < 0 ) {
- fprintf(stderr,"Disk DB Error: Zone %ld: Missing or invalid track skew for disk %s\n",i, name); exit(1);
- }
-
- RF_Calloc(*znext_ptr, 1, sizeof(RF_ZoneList_t), (RF_ZoneList_t *));
- (*znext_ptr)->next = (RF_ZoneList_t *) NULL;
- (*znext_ptr)->zone.num_cylinders = x;
- (*znext_ptr)->zone.sec_per_track = y;
- (*znext_ptr)->zone.track_skew = z;
- (*znext_ptr)->zone.num_sectors =
- (*znext_ptr)->zone.num_cylinders *
- g->tracks_per_cyl *
- (*znext_ptr)->zone.sec_per_track;
- znext_ptr = &((*znext_ptr)->next);
- num_cylinders = num_cylinders + x;
- } /* End of for-loop */
-
- lineno++;
- if ( (fscanf(fd, " revolution time %f", &tmp_f1) != 1) || tmp_f1 <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid revolution time for disk %s\n",name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " 1 cylinder seek time %f", &tmp_f2 ) != 1) || tmp_f2 <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid 1-cyl seek time for disk %s\n",name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " max stroke seek time %f", &tmp_f3) != 1) || tmp_f3 <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid max seek time for disk %s\n",name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " average seek time %f", &tmp_f4) != 1) || tmp_f4 <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid avg seek time for disk %s\n",name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " time to sleep %f", &tmp_f5) != 1) || tmp_f4 <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid time to sleep for disk %s\n",name); exit(1);
- }
- lineno++;
- if ( (fscanf(fd, " time to spinup %f", &tmp_f6) != 1) || tmp_f4 <= 0) {
- fprintf(stderr,"Disk DB Error: Missing or invalid time to sleep for disk %s\n",name); exit(1);
- }
- strcpy( g->disk_name, name );
- g->revolution_time = tmp_f1;
- g->seek_one_cyl = tmp_f2;
- g->seek_max_stroke = tmp_f3;
- g->seek_avg = tmp_f4;
- g->time_to_sleep = tmp_f5;
- g->time_to_spinup = tmp_f6;
- /* convert disk specs to seek equation coeff */
- rf_DiskParam( num_cylinders, g->seek_one_cyl,
- g->seek_avg, g->seek_max_stroke,
- &g->seek_sqrt_coeff, &g->seek_linear_coeff,
- &g->seek_constant_coeff );
- }
- return( list );
-}
-
-static void Format_disk(disk, sectors_per_block)
- RF_DiskState_t *disk;
- long sectors_per_block;
-{
- long sector_count = 0;
- RF_ZoneList_t *z;
-
- if( disk == (RF_DiskState_t *) NULL ) RF_PANIC();
- if( disk->geom == (RF_Geometry_t *) NULL ) RF_PANIC();
- if( sectors_per_block <=0 ) RF_PANIC();
-
- disk->sectors_per_block = sectors_per_block;
- z = disk->geom->zbr_data;
- /* This while-loop visits each disk zone and computes the total
- number of sectors on the disk. */
- while (z != (RF_ZoneList_t *) NULL) {
- sector_count = sector_count + (z->zone.num_cylinders *
- disk->geom->tracks_per_cyl *
- z->zone.sec_per_track);
- z = z->next;
- }
-
- disk->last_block_index = (sector_count / sectors_per_block) - 1;
-}
-
-void rf_InitDisk( disk, disk_db, disk_name, init_cyl, init_track, init_offset, row, col)
- RF_DiskState_t *disk;
- char *disk_db;
- char *disk_name;
- long init_cyl;
- long init_track;
- RF_TICS_t init_offset;
- int row;
- int col;
-{
- RF_GeometryList_t *gp;
- FILE *f;
-
- RF_ASSERT( disk != (RF_DiskState_t *) NULL );
-
- disk->cur_cyl = init_cyl;
- disk->cur_track = init_track;
- disk->index_offset = init_offset;
- disk->geom = (RF_Geometry_t *) NULL;
- disk->queueFinishTime = 0.0;
- disk->lastBlock = 0;
- disk->row=row;
- disk->col=col;
- Zero_stats(disk);
-
- if (strncmp(disk_name,"/dev",4 )==0) strcpy(disk_name,"HP2247");
-
- if( geom_list == (RF_GeometryList_t *) NULL ) {
- f = fopen(disk_db,"r");
- if (f == NULL) {
- fprintf(stderr, "ERROR: RAIDframe could not open disk db %s\n", disk_db);
- exit(1);
- }
- geom_list = Fetch_geometry_db( f );
- fclose( f );
- }
- for( gp = geom_list; gp != (RF_GeometryList_t *) NULL; gp = gp->next ) {
- RF_ASSERT( gp->disk != (RF_Geometry_t *) NULL
- && gp->disk->disk_name != (char *) NULL );
- if( strncmp( disk_name, gp->disk->disk_name, RF_MAX_DISKNAME_LEN )
- == 0 ) {
- disk->geom = gp->disk;
- break;
- }
- }
- if( disk->geom == (RF_Geometry_t *) NULL ) {
- fprintf( stderr, "Disk %s not found in database %s\n",
- disk_name, disk_db );
- exit(1);
- }
-
- Format_disk( disk, 1 );
-}
-
-static long Find_cyl( block, disk )
- RF_SectorNum_t block;
- RF_DiskState_t *disk;
-{
- RF_ZoneList_t * z;
- long tmp;
-
- long log_sector = block * disk->sectors_per_block;
- long cylinder = 0;
- z = disk->geom->zbr_data;
- /* This while-loop finds the zone to which log_sector belongs,
- computes the starting cylinder number of this zone, and
- computes the sector offset into this zone. */
- while (log_sector >= z->zone.num_sectors) {
- log_sector = log_sector - z->zone.num_sectors;
- cylinder = cylinder + z->zone.num_cylinders;
- z = z->next;
- }
-
- /* The cylinder to which log_sector belongs equals the starting
- cylinder number of its zone plus the cylinder offset into
- the zone. */
- tmp = cylinder + (log_sector / (z->zone.sec_per_track *
- disk->geom->tracks_per_cyl));
-
- return( tmp );
-}
-
-static long Find_track( block, disk )
- RF_SectorNum_t block;
- RF_DiskState_t *disk;
-{
- RF_ZoneList_t * z;
- long tmp;
-
- long log_sector = block * disk->sectors_per_block;
- long track = 0;
- z = disk->geom->zbr_data;
- /* This while-loop finds the zone to which log_sector belongs,
- computes the starting track number of this zone, and computes
- the sector offset into this zone. */
- while (log_sector >= z->zone.num_sectors) {
- log_sector = log_sector - z->zone.num_sectors;
- track = track + (z->zone.num_cylinders *
- disk->geom->tracks_per_cyl);
- z = z->next;
- }
-
- /* The track to which log_sector belongs equals the starting
- track number of its zone plus the track offset into the zone,
- modulo the number of tracks per cylinder on the disk. */
- tmp = (track + (log_sector / z->zone.sec_per_track)) %
- disk->geom->tracks_per_cyl;
-
- return( tmp );
-}
-
-/*
- ** The position of a logical sector relative to the index mark on any track
- ** is not simple. A simple organization would be:
-**
-** track 0 : 0, 1, 2, 3, ... N-1
-** track 1 : N,N+1,N+2,N+3, ... 2N-1
-** ^
-** Index mark just before this point
-**
-** This is not good because sequential access of sectors N-1 then N
-** will require a full revolution in between (because track switch requires
-** a couple of sectors to recalibrate from embedded servo). So frequently
-** sequentially numbered sectors are physically skewed so that the next
-** accessible sector after N-1 will be N (with a skew of 2)
-**
-** track 0 : 0, 1, 2, 3, ... N-1
-** track 1 : 2N-2,2N-1, N, N+1, ... 2N-3
-** ^
-** Index mark just before this point
-**
-** Layout gets even more complex with cylinder boundaries. Seek time
-** is A + B*M where M is the number of cylinders to seek over. On a sequential
-** access that crosses a cylinder boundary, the disk will rotate for
-** A+B seconds, then "track skew" sectors (inter-sector gaps actually)
-** before it can access another sector, so the cylinder to cylinder skew
-** is "track skew" + CEIL( sectors_per_track*(A+B)/revolution_time ).
-**
-** So if sector 0 is 0 sectors from the index mark on the first track,
-** where is sector X relative to the index mark on its track?
-**
-** ( ( X % sectors_per_track ) basic relative position **
-** + track_skew * ( X / sectors_per_track ) skewed for each track **
-** + CEIL( sectors_per_track*(A+B)/revolution_time )
-** * ( X / sectors_per_cylinder ) skewed more for each cyl **
-** ) % sectors_per_track wrapped around in the track **
-**
-**
-*/
-
-static long Find_phys_sector(block, disk)
- RF_SectorNum_t block;
- RF_DiskState_t *disk;
-{
- long phys = 0;
- RF_ZoneList_t * z;
- long previous_spt = 1;
- long sector = block * disk->sectors_per_block;
-
- z = disk->geom->zbr_data;
- /* This while-loop finds the zone to which sector belongs,
- and computes the physical sector up to that zone. */
- while (sector >= z->zone.num_sectors) {
- sector = sector - z->zone.num_sectors;
- /* By first multiplying 'phys' by the sectors per track in
- the current zone divided by the sectors per track in the
- previous zone, we convert a given physical sector in one
- zone to an equivalent physical sector in another zone. */
- phys = ((phys * z->zone.sec_per_track / previous_spt) +
- (((z->zone.num_sectors - 1) % z->zone.sec_per_track) +
- (z->zone.track_skew * z->zone.num_cylinders *
- disk->geom->tracks_per_cyl) +
- (long) ceil( (double) z->zone.sec_per_track *
- (disk->geom->seek_constant_coeff) /
- disk->geom->revolution_time) *
- z->zone.num_cylinders)) %
- z->zone.sec_per_track;
- previous_spt = z->zone.sec_per_track;
- z = z->next;
- }
-
- /* The final physical sector equals the physical sector up to
- the particular zone, plus the physical sector caused by the
- sector offset into this zone. */
- phys = ((phys * z->zone.sec_per_track / previous_spt) +
- ((sector % z->zone.sec_per_track) +
- (z->zone.track_skew * (sector / z->zone.sec_per_track)) +
- (long) ceil( (RF_TICS_t) z->zone.sec_per_track *
- (disk->geom->seek_constant_coeff) /
- disk->geom->revolution_time) *
- (sector / (z->zone.sec_per_track *
- disk->geom->tracks_per_cyl)))) %
- z->zone.sec_per_track;
-
-
- return( phys );
-}
-
-/*
- ** When each disk starts up, its index mark is a fraction (f) of a rotation
- ** ahead from its heads (in the direction of rotation). The sector
- ** under its heads is at a fraction f of a rotation from the index
- ** mark. After T time has past, T/rotation_time revolutions have occured, so
- ** the sector under the heads is at a fraction FRAC(f+T/rotation_time) of a
- ** rotation from the index mark. If the target block is at physical sector
- ** X relative to its index mark, then it is at fraction (X/sectors_per_track),
- ** so the rotational delay is
- ** ((X/sectors_per_track)-FRAC(f+T/rotation_time)) * revolution_time
- ** if this is positive, otherwise it is
- ** (1+(X/sectors_per_track)-FRAC(f+T/rotation_time)) * revolution_time
- */
-
-#define FRAC(a) ( (a) - (long) floor(a) )
-
-static RF_TICS_t Delay_to(cur_time, block, disk)
- RF_TICS_t cur_time;
- RF_SectorNum_t block;
- RF_DiskState_t *disk;
-{
- RF_TICS_t tmp;
- RF_ZoneList_t *z;
-
- long sector = block * disk->sectors_per_block;
- z = disk->geom->zbr_data;
- /* This while-loop finds the zone to which sector belongs. */
- while (sector >= z->zone.num_sectors) {
- sector = sector - z->zone.num_sectors;
- z = z->next;
- }
-
- tmp = (
- (RF_TICS_t) Find_phys_sector(block,disk)/z->zone.sec_per_track
- - FRAC(disk->index_offset+cur_time/disk->geom->revolution_time)
- ) * disk->geom->revolution_time;
- if( tmp < 0 ) tmp += disk->geom->revolution_time;
- if( tmp < 0 ) RF_PANIC();
- return( tmp );
-}
-
-/* Hmmm...they seem to be computing the head switch time as
- * equal to the track skew penalty. Is this an approximation?
- * (MCH)
- */
-static RF_TICS_t Seek_time( to_cyl, to_track, from_cyl, from_track, disk )
- long to_cyl;
- long to_track;
- long from_cyl;
- long from_track;
- RF_DiskState_t *disk;
-{
- long cyls = ABS_DIFF( from_cyl, to_cyl ) - 1;
- RF_TICS_t seek = 0.0;
- RF_ZoneList_t * z;
-
- /* printf("Seek_time: from_cyl %ld, to_cyl %ld, from_trk %ld, to_trk %ld\n",from_cyl, to_cyl, from_track, to_track); */
- if( from_cyl != to_cyl ) {
- z = disk->geom->zbr_data;
- /* This while-loop finds the zone to which to_cyl belongs. */
- while (to_cyl >= z->zone.num_cylinders) {
- to_cyl = to_cyl - z->zone.num_cylinders;
- z = z->next;
- }
-
- seek = disk->geom->seek_constant_coeff
- + disk->geom->seek_linear_coeff * cyls
- + disk->geom->seek_sqrt_coeff * sqrt( (double) cyls )
- + z->zone.track_skew * disk->geom->revolution_time /
- z->zone.sec_per_track;
-
- } else if( from_track != to_track ) {
- /* from_track and to_track must lie in the same zone. */
- z = disk->geom->zbr_data;
- /* This while-loop finds the zone to which from_cyl belongs. */
- while (from_cyl >= z->zone.num_cylinders) {
- from_cyl = from_cyl - z->zone.num_cylinders;
- z = z->next;
- }
-
- seek = z->zone.track_skew
- * disk->geom->revolution_time
- / z->zone.sec_per_track;
- }
- return( seek );
-}
-
-static RF_TICS_t Seek(cur_time, block, disk, update)
- RF_TICS_t cur_time;
- RF_SectorNum_t block;
- RF_DiskState_t *disk;
- long update;
-{
- long cur_cyl, cur_track;
- /*
- ** current location is derived from the time,
- ** current track and current cylinder
- **
- ** update current location as you go
- */
-
- RF_ASSERT( block <= disk->last_block_index );
- cur_cyl = disk->cur_cyl;
- cur_track = disk->cur_track;
- if (update) {
- disk->cur_cyl = Find_cyl( block, disk );
- disk->cur_track = Find_track( block, disk );
- }
- return( Seek_time( disk->cur_cyl, disk->cur_track,
- cur_cyl, cur_track, disk ) );
-}
-
-static RF_TICS_t Rotate(cur_time, block, disk, update)
- RF_TICS_t cur_time;
- RF_SectorNum_t block;
- RF_DiskState_t *disk;
- long update;
-{
- /*
- ** current location is derived from the time,
- ** current track and current cylinder
- **
- ** block the process until at the appropriate block
- ** updating current location as you go
- */
-
- RF_ASSERT( block <= disk->last_block_index );
- return( Delay_to( cur_time, block, disk ) );
-}
-
-static RF_TICS_t Seek_Rotate(cur_time, block, disk, update)
- RF_TICS_t cur_time;
- RF_SectorNum_t block;
- RF_DiskState_t *disk;
- long update;
-{
- RF_TICS_t seek, delay;
-
- RF_ASSERT( block <= disk->last_block_index );
- seek = Seek( cur_time, block, disk, update );
- delay = seek + Rotate( cur_time+seek, block, disk, update );
- return( delay );
-}
-
-static RF_TICS_t GAP(sec_per_track, disk)
- long sec_per_track;
- RF_DiskState_t *disk;
-{
- RF_TICS_t tmp = (disk->geom->revolution_time/(100*sec_per_track));
- return (tmp);
-}
-
-RF_TICS_t Block_access_time(cur_time, block, numblocks, disk, update)
- RF_TICS_t cur_time;
- RF_SectorNum_t block;
- RF_SectorCount_t numblocks;
- RF_DiskState_t *disk;
- long update;
-{
- RF_TICS_t delay = 0;
- long cur = block, end = block + numblocks;
- long sector, tmp;
- RF_ZoneList_t * z;
- /*
- ** this is the same as Seek_Rotate by merit of the mapping
- ** except that the access ends before the gap to the next block
- */
- RF_ASSERT( numblocks > 0 && end-1 <= disk->last_block_index );
-
- while( cur < end ) {
- sector = cur * disk->sectors_per_block;
- z = disk->geom->zbr_data;
- /* This while-loop finds the zone to which sector belongs. */
- while (sector >= z->zone.num_sectors) {
- sector = sector - z->zone.num_sectors;
- z = z->next;
- }
-
- tmp = RF_MIN( end - cur, z->zone.sec_per_track
- - cur % z->zone.sec_per_track );
- delay += tmp * disk->geom->revolution_time /
- z->zone.sec_per_track -
- GAP(z->zone.sec_per_track, disk);
- cur += tmp;
- if( cur != end )
- delay += Seek_Rotate( cur_time+delay, cur, disk, update );
- }
- return( delay );
-}
-
-static void Zero_stats(disk)
- RF_DiskState_t *disk;
-{
- char traceFileName[64];
- disk->stats.num_events = 0;
- disk->stats.seek_sum = 0;
- disk->stats.seekSq_sum = 0;
- disk->stats.rotate_sum = 0;
- disk->stats.rotateSq_sum = 0;
- disk->stats.transfer_sum = 0;
- disk->stats.transferSq_sum = 0;
- disk->stats.access_sum = 0;
- disk->stats.accessSq_sum = 0;
- disk->stats.sleep_sum=0;
- disk->stats.idle_sum=0;
- disk->stats.rw_sum=0;
- disk->stats.spinup_sum=0;
- disk->stats.last_acc=0;
- if (rf_diskTrace){
- sprintf (traceFileName,"rf_diskTracer%dc%d\0",disk->row,disk->col);
- if ( (disk->traceFile= fopen(traceFileName, "w")) == NULL) {
- perror(traceFileName); RF_PANIC();}
- }
-}
-
-static RF_TICS_t Update_stats(cur_time, seek, rotate, transfer, disk)
- RF_TICS_t cur_time;
- RF_TICS_t seek;
- RF_TICS_t rotate;
- RF_TICS_t transfer;
- RF_DiskState_t *disk;
-{
- RF_TICS_t spinup=0;
- RF_TICS_t sleep=0;
- RF_TICS_t idle=0;
-
- disk->stats.num_events++;
- disk->stats.seek_sum += seek;
- disk->stats.seekSq_sum += seek*seek;
- disk->stats.rotate_sum += rotate;
- disk->stats.rotateSq_sum += rotate*rotate;
- disk->stats.transfer_sum += transfer;
- disk->stats.transferSq_sum += transfer*transfer;
- disk->stats.access_sum += seek+rotate+transfer;
- disk->stats.accessSq_sum +=
- (seek+rotate+transfer)*(seek+rotate+transfer);
-
-/* ASSERT (cur_time - disk->stats.last_acc >= 0); */
-
- if (cur_time-disk->stats.last_acc>disk->geom->time_to_sleep){
- idle=disk->geom->time_to_sleep;
-
- sleep = cur_time - disk->stats.last_acc - idle;
- spinup=disk->geom->time_to_spinup;
- rf_globalSpinup = spinup;
- }
-
- else{
- idle=cur_time - disk->stats.last_acc;
- }
-
-
- disk->stats.sleep_sum+=sleep;
- disk->stats.idle_sum+=idle;
- disk->stats.rw_sum+=seek+rotate+transfer;
- disk->stats.spinup_sum+=spinup;
-
- if (rf_diskTrace){
- fprintf(disk->traceFile,"%g %g\n",disk->stats.last_acc,2.0);
- fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),2.0);
- if (sleep){
- fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),1.0);
- fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle+sleep),1.0);
- }
-
- if (spinup){
- fprintf(disk->traceFile,"%g %g\n",(cur_time),4.0);
- fprintf(disk->traceFile,"%g %g\n",(cur_time+spinup),4.0);
- }
-
- fprintf(disk->traceFile,"%g %g\n",(cur_time+spinup),3.0);
- fprintf(disk->traceFile,"%g %g\n",(cur_time+spinup+seek+rotate+transfer),3.0);
-
-
- }
-
- disk->stats.last_acc=cur_time+spinup+seek+rotate+transfer;
-
- return(spinup);
-}
-
-
-void rf_StopStats(disk, cur_time)
- RF_DiskState_t *disk;
- RF_TICS_t cur_time;
-{
-
- RF_TICS_t sleep=0;
- RF_TICS_t idle=0;
-
- if (cur_time - disk->stats.last_acc > disk->geom->time_to_sleep){
-
- sleep = cur_time - disk->stats.last_acc-disk->geom->time_to_sleep;
- idle = disk->geom->time_to_sleep;
-
- }
-
-
-
- else{
- idle=cur_time - disk->stats.last_acc;
- }
-
- disk->stats.sleep_sum+=sleep;
- disk->stats.idle_sum+=idle;
-
- if (rf_diskTrace){
- fprintf(disk->traceFile,"%g %g\n",disk->stats.last_acc,2.0);
- fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),2.0);
- if (sleep){
- fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),1.0);
- fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle+sleep),1.0);
- }
- fclose(disk->traceFile);
- }
-}
-
-/* Sometimes num_events is zero because the disk was failed at the start
- * of the simulation and never replaced. This causes a crash on some
- * architectures, which is why we have the conditional.
- */
-void rf_Report_stats(
- RF_DiskState_t *disk,
- long *numEventsPtr,
- RF_TICS_t *avgSeekPtr,
- RF_TICS_t *avgRotatePtr,
- RF_TICS_t *avgTransferPtr,
- RF_TICS_t *avgAccessPtr,
- RF_TICS_t *SleepPtr,
- RF_TICS_t *IdlePtr,
- RF_TICS_t *RwPtr,
- RF_TICS_t *SpinupPtr)
-{
- *numEventsPtr = disk->stats.num_events;
- if (disk->stats.num_events) {
- *avgSeekPtr = disk->stats.seek_sum / disk->stats.num_events;
- *avgRotatePtr = disk->stats.rotate_sum / disk->stats.num_events;
- *avgTransferPtr = disk->stats.transfer_sum / disk->stats.num_events;
- *avgAccessPtr = disk->stats.access_sum / disk->stats.num_events;
- } else {
- *avgSeekPtr = 0;
- *avgRotatePtr = 0;
- *avgTransferPtr = 0;
- *avgAccessPtr = 0;
- }
- *SleepPtr = disk->stats.sleep_sum;
- *IdlePtr = disk->stats.idle_sum;
- *RwPtr = disk->stats.rw_sum ;
- *SpinupPtr = disk->stats.spinup_sum ;
-}
-
-int rf_Access_time( access_time, cur_time, block, numblocks, disk, media_done_time, update )
- RF_TICS_t *access_time;
- RF_TICS_t cur_time;
- RF_SectorNum_t block;
- RF_SectorCount_t numblocks;
- RF_DiskState_t *disk;
- RF_TICS_t *media_done_time;
- long update; /* 1 => update disk state, 0 => don't */
-{
- /*
- * first move to the start of the data, then sweep to the end
- */
- RF_TICS_t spinup=0;
- RF_TICS_t seek = Seek( cur_time, block, disk, update );
- RF_TICS_t rotate = Rotate( cur_time+seek, block, disk, update );
- RF_TICS_t transfer = Block_access_time( cur_time+seek+rotate, block,
- numblocks, disk, update );
-
- if (update) spinup=Update_stats(cur_time, seek, rotate, transfer, disk );
- *media_done_time = seek+rotate+transfer;
- *access_time =( seek+rotate+transfer+spinup);
- return(0);
-}
-
-/* added to take into account the fact that maping code acounts for the disk label */
-
-void rf_GeometryDoReadCapacity(disk, numBlocks, blockSize)
- RF_DiskState_t *disk;
- RF_SectorCount_t *numBlocks;
- int *blockSize;
-{
- *numBlocks= (disk->last_block_index + 1 )-rf_protectedSectors;
-
- *blockSize= (disk->sectors_per_block*512 );
-
- /* in bytes */
-}
-
-
-/* END GEOMETRY ROUTINES **********************************************/
-
-
-static void rf_DiskParam(numCyls, minSeek, avgSeek, maxSeek, a, b, c)
- long numCyls;
- RF_TICS_t minSeek;
- RF_TICS_t avgSeek;
- RF_TICS_t maxSeek;
- RF_TICS_t *a;
- RF_TICS_t *b;
- RF_TICS_t *c;
-{
- if (minSeek == avgSeek && minSeek == maxSeek) {
- *a = 0.0; *b = 0.0; *c = minSeek;
- } else {
- *a = ( 15 * avgSeek - 10 * minSeek - 5 * maxSeek ) / ( 3 * sqrt( (double) numCyls ));
- *b = ( 7 * minSeek + 8 * maxSeek - 15 * avgSeek ) / ( 3 * numCyls );
- *c = minSeek;
- }
-}
diff --git a/sys/dev/raidframe/rf_geometry.h b/sys/dev/raidframe/rf_geometry.h
deleted file mode 100644
index 60d722839e8..00000000000
--- a/sys/dev/raidframe/rf_geometry.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/* $NetBSD: rf_geometry.h,v 1.2 1999/01/26 02:33:58 oster Exp $ */
-/* geometry.h
- * code from raidSim to model disk behavior
- */
-/*
- * Changes:
- * 8/18/92 Additional structures have been declared and existing
- * structures have been modified in order to support zone-
- * bit recording.
- * (AS) 1. The types 'Zone_data' and 'Zone_list' have been defined.
- * (AS) 2. The type 'Geometry' has been modified.
- */
-
-#ifndef _RF__RF_GEOMETRY_H_
-#define _RF__RF_GEOMETRY_H_
-
-#include "rf_types.h"
-#include "rf_sys.h"
-
-#define RF_MAX_DISKNAME_LEN 80
-
-typedef struct RF_ZoneData_s {
- long num_cylinders; /* Number of cylinders in zone */
- long sec_per_track; /* Sectors per track in zone */
- long track_skew; /* Skew of each track in zone */
- long num_sectors; /* Number of sectors in zone */
-} RF_ZoneData_t;
-
-/*
- * Linked list containing zone data
- */
-typedef struct RF_ZoneList_s RF_ZoneList_t;
-struct RF_ZoneList_s {
- RF_ZoneData_t zone; /* for each disk */
- RF_ZoneList_t *next;
-};
-
-typedef struct RF_Geometry_s {
- char disk_name[RF_MAX_DISKNAME_LEN]; /* name for a type of disk */
- long tracks_per_cyl; /* tracks in a cylinder */
- /* assume 1 head per track, 1 set of read/write electronics */
- long num_zones; /* number of ZBR zones on disk */
- RF_TICS_t revolution_time; /* milliseconds per revolution */
- RF_TICS_t seek_one_cyl; /* adjacent cylinder seek time */
- RF_TICS_t seek_max_stroke; /* end to end seek time */
- RF_TICS_t seek_avg; /* random from/to average time */
- /*
- * seek time = a * (x-1)^0.5 + b * (x-1) + c
- * x >= 1 is the seek distance in cylinders
- */
- RF_TICS_t seek_sqrt_coeff; /* a */
- RF_TICS_t seek_linear_coeff; /* b */
- RF_TICS_t seek_constant_coeff; /* c */
- RF_ZoneList_t *zbr_data; /* linked list with ZBR data */
- RF_TICS_t time_to_sleep; /* seconds of idle time before disks goes to sleep */
- RF_TICS_t time_to_spinup; /* seconds spin up takes */
-} RF_Geometry_t;
-
-typedef struct RF_GeometryList_s RF_GeometryList_t;
-struct RF_GeometryList_s {
- RF_Geometry_t *disk;
- RF_GeometryList_t *next;
-};
-
-typedef struct RF_DiskStats_s {
- long num_events;
- RF_TICS_t seek_sum;
- RF_TICS_t seekSq_sum;
- RF_TICS_t rotate_sum;
- RF_TICS_t rotateSq_sum;
- RF_TICS_t transfer_sum;
- RF_TICS_t transferSq_sum;
- RF_TICS_t access_sum;
- RF_TICS_t accessSq_sum;
- RF_TICS_t sleep_sum;
- RF_TICS_t idle_sum;
- RF_TICS_t rw_sum;
- RF_TICS_t spinup_sum;
- RF_TICS_t last_acc; /* time the last acces was finished */
-} RF_DiskStats_t;
-
-struct RF_DiskState_s {
- int row;
- int col;
- RF_Geometry_t *geom;
- long sectors_per_block; /* formatted per disk */
- long last_block_index; /* format result for convenience */
- RF_TICS_t index_offset; /* powerup head offset to index mark */
- long cur_track; /* current track */
- long cur_cyl; /* current cylinder */
- RF_DiskStats_t stats; /* disk statistics */
-
- RF_TICS_t queueFinishTime; /* used by shortest-seek code */
- long lastBlock;
- FILE *traceFile;
-};
-typedef struct RF_DiskState_s RF_DiskState_t;
-
-extern RF_TICS_t rf_globalSpinup;
-
-void rf_InitDisk(RF_DiskState_t *disk, char *disk_name, char *disk_db, long init_cyl,
- long init_track, RF_TICS_t init_offset, int row, int col);
-void rf_StopStats(RF_DiskState_t *disk, RF_TICS_t cur_time);
-void rf_Report_stats(RF_DiskState_t *disk, long *numEventsPtr, RF_TICS_t *avgSeekPtr,
- RF_TICS_t *avgRotatePtr, RF_TICS_t *avgTransferPtr, RF_TICS_t *avgAccessPtr,
- RF_TICS_t *SleepPtr, RF_TICS_t *IdlePtr, RF_TICS_t *RwPtr, RF_TICS_t *SpinupPtr);
-int rf_Access_time(RF_TICS_t *access_time, RF_TICS_t cur_time,
- RF_SectorNum_t block, RF_SectorCount_t numblocks, RF_DiskState_t *disk,
- RF_TICS_t *media_done_time, long update);
-void rf_GeometryDoReadCapacity(RF_DiskState_t *disk, RF_SectorCount_t *numBlocks,
- int *blockSize);
-
-#endif /* !_RF__RF_GEOMETRY_H_ */