Home | History | Annotate | Line # | Download | only in raidframe
rf_reconmap.c revision 1.1
      1  1.1  oster /*	$NetBSD: rf_reconmap.c,v 1.1 1998/11/13 04:20:33 oster Exp $	*/
      2  1.1  oster /*
      3  1.1  oster  * Copyright (c) 1995 Carnegie-Mellon University.
      4  1.1  oster  * All rights reserved.
      5  1.1  oster  *
      6  1.1  oster  * Author: Mark Holland
      7  1.1  oster  *
      8  1.1  oster  * Permission to use, copy, modify and distribute this software and
      9  1.1  oster  * its documentation is hereby granted, provided that both the copyright
     10  1.1  oster  * notice and this permission notice appear in all copies of the
     11  1.1  oster  * software, derivative works or modified versions, and any portions
     12  1.1  oster  * thereof, and that both notices appear in supporting documentation.
     13  1.1  oster  *
     14  1.1  oster  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
     15  1.1  oster  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
     16  1.1  oster  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
     17  1.1  oster  *
     18  1.1  oster  * Carnegie Mellon requests users of this software to return to
     19  1.1  oster  *
     20  1.1  oster  *  Software Distribution Coordinator  or  Software.Distribution (at) CS.CMU.EDU
     21  1.1  oster  *  School of Computer Science
     22  1.1  oster  *  Carnegie Mellon University
     23  1.1  oster  *  Pittsburgh PA 15213-3890
     24  1.1  oster  *
     25  1.1  oster  * any improvements or extensions that they make and grant Carnegie the
     26  1.1  oster  * rights to redistribute these changes.
     27  1.1  oster  */
     28  1.1  oster 
     29  1.1  oster /*************************************************************************
     30  1.1  oster  * rf_reconmap.c
     31  1.1  oster  *
     32  1.1  oster  * code to maintain a map of what sectors have/have not been reconstructed
     33  1.1  oster  *
     34  1.1  oster  *************************************************************************/
     35  1.1  oster 
     36  1.1  oster /* :
     37  1.1  oster  * Log: rf_reconmap.c,v
     38  1.1  oster  * Revision 1.23  1996/07/27 23:36:08  jimz
     39  1.1  oster  * Solaris port of simulator
     40  1.1  oster  *
     41  1.1  oster  * Revision 1.22  1996/07/15  17:22:18  jimz
     42  1.1  oster  * nit-pick code cleanup
     43  1.1  oster  * resolve stdlib problems on DEC OSF
     44  1.1  oster  *
     45  1.1  oster  * Revision 1.21  1996/06/17  14:38:33  jimz
     46  1.1  oster  * properly #if out RF_DEMO code
     47  1.1  oster  * fix bug in MakeConfig that was causing weird behavior
     48  1.1  oster  * in configuration routines (config was not zeroed at start)
     49  1.1  oster  * clean up genplot handling of stacks
     50  1.1  oster  *
     51  1.1  oster  * Revision 1.20  1996/06/09  02:36:46  jimz
     52  1.1  oster  * lots of little crufty cleanup- fixup whitespace
     53  1.1  oster  * issues, comment #ifdefs, improve typing in some
     54  1.1  oster  * places (esp size-related)
     55  1.1  oster  *
     56  1.1  oster  * Revision 1.19  1996/06/07  21:33:04  jimz
     57  1.1  oster  * begin using consistent types for sector numbers,
     58  1.1  oster  * stripe numbers, row+col numbers, recon unit numbers
     59  1.1  oster  *
     60  1.1  oster  * Revision 1.18  1996/06/05  18:06:02  jimz
     61  1.1  oster  * Major code cleanup. The Great Renaming is now done.
     62  1.1  oster  * Better modularity. Better typing. Fixed a bunch of
     63  1.1  oster  * synchronization bugs. Made a lot of global stuff
     64  1.1  oster  * per-desc or per-array. Removed dead code.
     65  1.1  oster  *
     66  1.1  oster  * Revision 1.17  1996/05/31  22:26:54  jimz
     67  1.1  oster  * fix a lot of mapping problems, memory allocation problems
     68  1.1  oster  * found some weird lock issues, fixed 'em
     69  1.1  oster  * more code cleanup
     70  1.1  oster  *
     71  1.1  oster  * Revision 1.16  1996/05/30  23:22:16  jimz
     72  1.1  oster  * bugfixes of serialization, timing problems
     73  1.1  oster  * more cleanup
     74  1.1  oster  *
     75  1.1  oster  * Revision 1.15  1996/05/27  18:56:37  jimz
     76  1.1  oster  * more code cleanup
     77  1.1  oster  * better typing
     78  1.1  oster  * compiles in all 3 environments
     79  1.1  oster  *
     80  1.1  oster  * Revision 1.14  1996/05/24  22:17:04  jimz
     81  1.1  oster  * continue code + namespace cleanup
     82  1.1  oster  * typed a bunch of flags
     83  1.1  oster  *
     84  1.1  oster  * Revision 1.13  1996/05/24  04:40:57  jimz
     85  1.1  oster  * don't do recon meter demo stuff in kernel
     86  1.1  oster  *
     87  1.1  oster  * Revision 1.12  1996/05/23  00:33:23  jimz
     88  1.1  oster  * code cleanup: move all debug decls to rf_options.c, all extern
     89  1.1  oster  * debug decls to rf_options.h, all debug vars preceded by rf_
     90  1.1  oster  *
     91  1.1  oster  * Revision 1.11  1996/05/20  16:14:50  jimz
     92  1.1  oster  * switch to rf_{mutex,cond}_{init,destroy}
     93  1.1  oster  *
     94  1.1  oster  * Revision 1.10  1996/05/18  19:51:34  jimz
     95  1.1  oster  * major code cleanup- fix syntax, make some types consistent,
     96  1.1  oster  * add prototypes, clean out dead code, et cetera
     97  1.1  oster  *
     98  1.1  oster  * Revision 1.9  1995/12/12  18:10:06  jimz
     99  1.1  oster  * MIN -> RF_MIN, MAX -> RF_MAX, ASSERT -> RF_ASSERT
    100  1.1  oster  * fix 80-column brain damage in comments
    101  1.1  oster  *
    102  1.1  oster  * Revision 1.8  1995/12/06  15:05:23  root
    103  1.1  oster  * added copyright info
    104  1.1  oster  *
    105  1.1  oster  */
    106  1.1  oster 
    107  1.1  oster #include "rf_raid.h"
    108  1.1  oster #include <sys/time.h>
    109  1.1  oster #include "rf_general.h"
    110  1.1  oster #include "rf_utils.h"
    111  1.1  oster #if RF_DEMO > 0
    112  1.1  oster #include "rf_demo.h"
    113  1.1  oster #endif /* RF_DEMO > 0 */
    114  1.1  oster #include "rf_sys.h"
    115  1.1  oster 
    116  1.1  oster /* special pointer values indicating that a reconstruction unit
    117  1.1  oster  * has been either totally reconstructed or not at all.  Both
    118  1.1  oster  * are illegal pointer values, so you have to be careful not to
    119  1.1  oster  * dereference through them.  RU_NOTHING must be zero, since
    120  1.1  oster  * MakeReconMap uses bzero to initialize the structure.  These are used
    121  1.1  oster  * only at the head of the list.
    122  1.1  oster  */
    123  1.1  oster #define RU_ALL      ((RF_ReconMapListElem_t *) -1)
    124  1.1  oster #define RU_NOTHING  ((RF_ReconMapListElem_t *) 0)
    125  1.1  oster 
    126  1.1  oster /* used to mark the end of the list */
    127  1.1  oster #define RU_NIL      ((RF_ReconMapListElem_t *) 0)
    128  1.1  oster 
    129  1.1  oster 
    130  1.1  oster static void compact_stat_entry(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr,
    131  1.1  oster 	int i);
    132  1.1  oster static void crunch_list(RF_ReconMap_t *mapPtr, RF_ReconMapListElem_t *listPtr);
    133  1.1  oster static RF_ReconMapListElem_t *MakeReconMapListElem(RF_SectorNum_t startSector,
    134  1.1  oster 	RF_SectorNum_t stopSector, RF_ReconMapListElem_t *next);
    135  1.1  oster static void FreeReconMapListElem(RF_ReconMap_t *mapPtr,
    136  1.1  oster 	RF_ReconMapListElem_t *p);
    137  1.1  oster static void update_size(RF_ReconMap_t *mapPtr, int size);
    138  1.1  oster static void PrintList(RF_ReconMapListElem_t *listPtr);
    139  1.1  oster 
    140  1.1  oster /*-----------------------------------------------------------------------------
    141  1.1  oster  *
    142  1.1  oster  * Creates and initializes new Reconstruction map
    143  1.1  oster  *
    144  1.1  oster  *-----------------------------------------------------------------------------*/
    145  1.1  oster 
    146  1.1  oster RF_ReconMap_t *rf_MakeReconMap(raidPtr, ru_sectors, disk_sectors, spareUnitsPerDisk)
    147  1.1  oster   RF_Raid_t            *raidPtr;
    148  1.1  oster   RF_SectorCount_t      ru_sectors;        /* size of reconstruction unit in sectors */
    149  1.1  oster   RF_SectorCount_t      disk_sectors;      /* size of disk in sectors */
    150  1.1  oster   RF_ReconUnitCount_t   spareUnitsPerDisk; /* zero unless distributed sparing */
    151  1.1  oster {
    152  1.1  oster   RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
    153  1.1  oster   RF_ReconUnitCount_t num_rus = layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerRU;
    154  1.1  oster   RF_ReconMap_t *p;
    155  1.1  oster   int rc;
    156  1.1  oster 
    157  1.1  oster   RF_Malloc(p, sizeof(RF_ReconMap_t), (RF_ReconMap_t *));
    158  1.1  oster   p->sectorsPerReconUnit = ru_sectors;
    159  1.1  oster   p->sectorsInDisk = disk_sectors;
    160  1.1  oster 
    161  1.1  oster   p->totalRUs = num_rus;
    162  1.1  oster   p->spareRUs = spareUnitsPerDisk;
    163  1.1  oster   p->unitsLeft = num_rus - spareUnitsPerDisk;
    164  1.1  oster 
    165  1.1  oster   RF_Malloc(p->status, num_rus * sizeof(RF_ReconMapListElem_t *), (RF_ReconMapListElem_t **));
    166  1.1  oster   RF_ASSERT(p->status != (RF_ReconMapListElem_t **) NULL);
    167  1.1  oster 
    168  1.1  oster   (void) bzero((char *) p->status, num_rus * sizeof(RF_ReconMapListElem_t *));
    169  1.1  oster 
    170  1.1  oster   p->size = sizeof(RF_ReconMap_t) + num_rus * sizeof(RF_ReconMapListElem_t *);
    171  1.1  oster   p->maxSize = p->size;
    172  1.1  oster 
    173  1.1  oster   rc = rf_mutex_init(&p->mutex);
    174  1.1  oster   if (rc) {
    175  1.1  oster     RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
    176  1.1  oster       __LINE__, rc);
    177  1.1  oster     RF_Free(p->status, num_rus * sizeof(RF_ReconMapListElem_t *));
    178  1.1  oster     RF_Free(p, sizeof(RF_ReconMap_t));
    179  1.1  oster     return(NULL);
    180  1.1  oster   }
    181  1.1  oster   return(p);
    182  1.1  oster }
    183  1.1  oster 
    184  1.1  oster 
    185  1.1  oster /*-----------------------------------------------------------------------------
    186  1.1  oster  *
    187  1.1  oster  * marks a new set of sectors as reconstructed.  All the possible mergings get
    188  1.1  oster  * complicated.  To simplify matters, the approach I take is to just dump
    189  1.1  oster  * something into the list, and then clean it up (i.e. merge elements and
    190  1.1  oster  * eliminate redundant ones) in a second pass over the list (compact_stat_entry()).
    191  1.1  oster  * Not 100% efficient, since a structure can be allocated and then immediately
    192  1.1  oster  * freed, but it keeps this code from becoming (more of) a nightmare of
    193  1.1  oster  * special cases.  The only thing that compact_stat_entry() assumes is that the
    194  1.1  oster  * list is sorted by startSector, and so this is the only condition I maintain
    195  1.1  oster  * here.  (MCH)
    196  1.1  oster  *
    197  1.1  oster  *-----------------------------------------------------------------------------*/
    198  1.1  oster 
    199  1.1  oster void rf_ReconMapUpdate(raidPtr, mapPtr, startSector, stopSector)
    200  1.1  oster   RF_Raid_t       *raidPtr;
    201  1.1  oster   RF_ReconMap_t   *mapPtr;
    202  1.1  oster   RF_SectorNum_t   startSector;
    203  1.1  oster   RF_SectorNum_t   stopSector;
    204  1.1  oster {
    205  1.1  oster   RF_SectorCount_t sectorsPerReconUnit = mapPtr->sectorsPerReconUnit;
    206  1.1  oster   RF_SectorNum_t i, first_in_RU, last_in_RU;
    207  1.1  oster   RF_ReconMapListElem_t *p, *pt;
    208  1.1  oster 
    209  1.1  oster   RF_LOCK_MUTEX(mapPtr->mutex);
    210  1.1  oster   RF_ASSERT(startSector >=0 && stopSector < mapPtr->sectorsInDisk && stopSector > startSector);
    211  1.1  oster 
    212  1.1  oster   while (startSector <= stopSector) {
    213  1.1  oster     i = startSector/mapPtr->sectorsPerReconUnit;
    214  1.1  oster     first_in_RU = i*sectorsPerReconUnit;
    215  1.1  oster     last_in_RU  = first_in_RU + sectorsPerReconUnit -1 ;
    216  1.1  oster     p = mapPtr->status[i];
    217  1.1  oster     if (p!=RU_ALL) {
    218  1.1  oster       if (p==RU_NOTHING || p->startSector > startSector ) {	/* insert at front of list */
    219  1.1  oster 
    220  1.1  oster 	mapPtr->status[i] = MakeReconMapListElem(startSector, RF_MIN(stopSector,last_in_RU), (p==RU_NOTHING) ? NULL : p);
    221  1.1  oster 	update_size(mapPtr, sizeof(RF_ReconMapListElem_t));
    222  1.1  oster 
    223  1.1  oster       } else {						/* general case */
    224  1.1  oster 	do {						/* search for place to insert */
    225  1.1  oster 	  pt = p; p = p->next;
    226  1.1  oster 	} while (p && (p->startSector < startSector));
    227  1.1  oster 	pt->next = MakeReconMapListElem(startSector,RF_MIN(stopSector,last_in_RU),p);
    228  1.1  oster 	update_size(mapPtr, sizeof(RF_ReconMapListElem_t));
    229  1.1  oster       }
    230  1.1  oster       compact_stat_entry(raidPtr, mapPtr, i);
    231  1.1  oster     }
    232  1.1  oster     startSector = RF_MIN(stopSector, last_in_RU) +1;
    233  1.1  oster   }
    234  1.1  oster   RF_UNLOCK_MUTEX(mapPtr->mutex);
    235  1.1  oster }
    236  1.1  oster 
    237  1.1  oster 
    238  1.1  oster 
    239  1.1  oster /*-----------------------------------------------------------------------------
    240  1.1  oster  *
    241  1.1  oster  * performs whatever list compactions can be done, and frees any space
    242  1.1  oster  * that is no longer necessary.  Assumes only that the list is sorted
    243  1.1  oster  * by startSector.  crunch_list() compacts a single list as much as possible,
    244  1.1  oster  * and the second block of code deletes the entire list if possible.
    245  1.1  oster  * crunch_list() is also called from MakeReconMapAccessList().
    246  1.1  oster  *
    247  1.1  oster  * When a recon unit is detected to be fully reconstructed, we set the
    248  1.1  oster  * corresponding bit in the parity stripe map so that the head follow
    249  1.1  oster  * code will not select this parity stripe again.  This is redundant (but
    250  1.1  oster  * harmless) when compact_stat_entry is called from the reconstruction code,
    251  1.1  oster  * but necessary when called from the user-write code.
    252  1.1  oster  *
    253  1.1  oster  *-----------------------------------------------------------------------------*/
    254  1.1  oster 
    255  1.1  oster static void compact_stat_entry(raidPtr, mapPtr, i)
    256  1.1  oster   RF_Raid_t      *raidPtr;
    257  1.1  oster   RF_ReconMap_t  *mapPtr;
    258  1.1  oster   int             i;
    259  1.1  oster {
    260  1.1  oster   RF_SectorCount_t sectorsPerReconUnit = mapPtr->sectorsPerReconUnit;
    261  1.1  oster   RF_ReconMapListElem_t *p = mapPtr->status[i];
    262  1.1  oster 
    263  1.1  oster   crunch_list(mapPtr, p);
    264  1.1  oster 
    265  1.1  oster   if ((p->startSector == i*sectorsPerReconUnit) &&
    266  1.1  oster       (p->stopSector == i*sectorsPerReconUnit +sectorsPerReconUnit -1)) {
    267  1.1  oster     mapPtr->status[i] = RU_ALL;
    268  1.1  oster     mapPtr->unitsLeft--;
    269  1.1  oster     FreeReconMapListElem(mapPtr,p);
    270  1.1  oster   }
    271  1.1  oster }
    272  1.1  oster 
    273  1.1  oster static void crunch_list(mapPtr, listPtr)
    274  1.1  oster   RF_ReconMap_t          *mapPtr;
    275  1.1  oster   RF_ReconMapListElem_t  *listPtr;
    276  1.1  oster {
    277  1.1  oster   RF_ReconMapListElem_t *pt, *p = listPtr;
    278  1.1  oster 
    279  1.1  oster   if (!p) return;
    280  1.1  oster   pt = p;  p = p->next;
    281  1.1  oster   while (p) {
    282  1.1  oster     if (pt->stopSector >= p->startSector-1) {
    283  1.1  oster       pt->stopSector = RF_MAX(pt->stopSector, p->stopSector);
    284  1.1  oster       pt->next = p->next;
    285  1.1  oster       FreeReconMapListElem(mapPtr, p);
    286  1.1  oster       p = pt->next;
    287  1.1  oster     }
    288  1.1  oster     else {
    289  1.1  oster       pt = p;
    290  1.1  oster       p = p->next;
    291  1.1  oster     }
    292  1.1  oster   }
    293  1.1  oster }
    294  1.1  oster 
    295  1.1  oster /*-----------------------------------------------------------------------------
    296  1.1  oster  *
    297  1.1  oster  * Allocate and fill a new list element
    298  1.1  oster  *
    299  1.1  oster  *-----------------------------------------------------------------------------*/
    300  1.1  oster 
    301  1.1  oster static RF_ReconMapListElem_t *MakeReconMapListElem(
    302  1.1  oster   RF_SectorNum_t          startSector,
    303  1.1  oster   RF_SectorNum_t          stopSector,
    304  1.1  oster   RF_ReconMapListElem_t  *next)
    305  1.1  oster {
    306  1.1  oster   RF_ReconMapListElem_t *p;
    307  1.1  oster 
    308  1.1  oster   RF_Malloc(p, sizeof(RF_ReconMapListElem_t), (RF_ReconMapListElem_t *));
    309  1.1  oster   if (p == NULL)
    310  1.1  oster     return(NULL);
    311  1.1  oster   p->startSector = startSector;
    312  1.1  oster   p->stopSector = stopSector;
    313  1.1  oster   p->next = next;
    314  1.1  oster   return(p);
    315  1.1  oster }
    316  1.1  oster 
    317  1.1  oster /*-----------------------------------------------------------------------------
    318  1.1  oster  *
    319  1.1  oster  * Free a list element
    320  1.1  oster  *
    321  1.1  oster  *-----------------------------------------------------------------------------*/
    322  1.1  oster 
    323  1.1  oster static void FreeReconMapListElem(mapPtr,p)
    324  1.1  oster   RF_ReconMap_t          *mapPtr;
    325  1.1  oster   RF_ReconMapListElem_t  *p;
    326  1.1  oster {
    327  1.1  oster   int delta;
    328  1.1  oster 
    329  1.1  oster   if (mapPtr) {
    330  1.1  oster     delta = 0 - (int)sizeof(RF_ReconMapListElem_t);
    331  1.1  oster     update_size(mapPtr, delta);
    332  1.1  oster   }
    333  1.1  oster   RF_Free(p, sizeof(*p));
    334  1.1  oster }
    335  1.1  oster 
    336  1.1  oster /*-----------------------------------------------------------------------------
    337  1.1  oster  *
    338  1.1  oster  * Free an entire status structure.  Inefficient, but can be called at any time.
    339  1.1  oster  *
    340  1.1  oster  *-----------------------------------------------------------------------------*/
    341  1.1  oster void rf_FreeReconMap(mapPtr)
    342  1.1  oster   RF_ReconMap_t  *mapPtr;
    343  1.1  oster {
    344  1.1  oster   RF_ReconMapListElem_t *p, *q;
    345  1.1  oster   RF_ReconUnitCount_t numRUs;
    346  1.1  oster   RF_ReconUnitNum_t i;
    347  1.1  oster 
    348  1.1  oster   numRUs = mapPtr->sectorsInDisk / mapPtr->sectorsPerReconUnit;
    349  1.1  oster   if (mapPtr->sectorsInDisk % mapPtr->sectorsPerReconUnit)
    350  1.1  oster     numRUs++;
    351  1.1  oster 
    352  1.1  oster   for (i=0; i<numRUs; i++) {
    353  1.1  oster     p = mapPtr->status[i];
    354  1.1  oster     while (p != RU_NOTHING && p != RU_ALL) {
    355  1.1  oster       q = p; p = p->next;
    356  1.1  oster       RF_Free(q, sizeof(*q));
    357  1.1  oster     }
    358  1.1  oster   }
    359  1.1  oster   rf_mutex_destroy(&mapPtr->mutex);
    360  1.1  oster   RF_Free(mapPtr->status, mapPtr->totalRUs * sizeof(RF_ReconMapListElem_t *));
    361  1.1  oster   RF_Free(mapPtr, sizeof(RF_ReconMap_t));
    362  1.1  oster }
    363  1.1  oster 
    364  1.1  oster /*-----------------------------------------------------------------------------
    365  1.1  oster  *
    366  1.1  oster  * returns nonzero if the indicated RU has been reconstructed already
    367  1.1  oster  *
    368  1.1  oster  *---------------------------------------------------------------------------*/
    369  1.1  oster 
    370  1.1  oster int rf_CheckRUReconstructed(mapPtr, startSector)
    371  1.1  oster   RF_ReconMap_t   *mapPtr;
    372  1.1  oster   RF_SectorNum_t   startSector;
    373  1.1  oster {
    374  1.1  oster   RF_ReconMapListElem_t *l;		/* used for searching */
    375  1.1  oster   RF_ReconUnitNum_t i;
    376  1.1  oster 
    377  1.1  oster   i = startSector / mapPtr->sectorsPerReconUnit;
    378  1.1  oster   l = mapPtr->status[i];
    379  1.1  oster   return( (l == RU_ALL) ? 1 : 0 );
    380  1.1  oster }
    381  1.1  oster 
    382  1.1  oster RF_ReconUnitCount_t rf_UnitsLeftToReconstruct(mapPtr)
    383  1.1  oster   RF_ReconMap_t  *mapPtr;
    384  1.1  oster {
    385  1.1  oster   RF_ASSERT(mapPtr != NULL);
    386  1.1  oster   return( mapPtr->unitsLeft );
    387  1.1  oster }
    388  1.1  oster 
    389  1.1  oster /* updates the size fields of a status descriptor */
    390  1.1  oster static void update_size(mapPtr, size)
    391  1.1  oster   RF_ReconMap_t  *mapPtr;
    392  1.1  oster   int             size;
    393  1.1  oster {
    394  1.1  oster   mapPtr->size += size;
    395  1.1  oster   mapPtr->maxSize = RF_MAX(mapPtr->size, mapPtr->maxSize);
    396  1.1  oster }
    397  1.1  oster 
    398  1.1  oster static void PrintList(listPtr)
    399  1.1  oster   RF_ReconMapListElem_t  *listPtr;
    400  1.1  oster {
    401  1.1  oster   while (listPtr) {
    402  1.1  oster     printf("%d,%d -> ",(int)listPtr->startSector,(int)listPtr->stopSector);
    403  1.1  oster     listPtr = listPtr->next;
    404  1.1  oster   }
    405  1.1  oster   printf("\n");
    406  1.1  oster }
    407  1.1  oster 
    408  1.1  oster void rf_PrintReconMap(raidPtr, mapPtr, frow, fcol)
    409  1.1  oster   RF_Raid_t      *raidPtr;
    410  1.1  oster   RF_ReconMap_t  *mapPtr;
    411  1.1  oster   RF_RowCol_t     frow;
    412  1.1  oster   RF_RowCol_t     fcol;
    413  1.1  oster {
    414  1.1  oster   RF_ReconUnitCount_t numRUs;
    415  1.1  oster   RF_ReconMapListElem_t *p;
    416  1.1  oster   RF_ReconUnitNum_t i;
    417  1.1  oster 
    418  1.1  oster   numRUs = mapPtr->totalRUs;
    419  1.1  oster   if (mapPtr->sectorsInDisk % mapPtr->sectorsPerReconUnit)
    420  1.1  oster     numRUs++;
    421  1.1  oster 
    422  1.1  oster   for (i=0; i<numRUs; i++) {
    423  1.1  oster     p = mapPtr->status[i];
    424  1.1  oster     if (p==RU_ALL) /*printf("[%d] ALL\n",i)*/;
    425  1.1  oster     else if (p == RU_NOTHING) {
    426  1.1  oster       printf("%d: Unreconstructed\n",i);
    427  1.1  oster     } else {
    428  1.1  oster       printf("%d: ", i);
    429  1.1  oster       PrintList(p);
    430  1.1  oster     }
    431  1.1  oster   }
    432  1.1  oster }
    433  1.1  oster 
    434  1.1  oster void rf_PrintReconSchedule(mapPtr, starttime)
    435  1.1  oster   RF_ReconMap_t   *mapPtr;
    436  1.1  oster   struct timeval  *starttime;
    437  1.1  oster {
    438  1.1  oster   static int old_pctg = -1;
    439  1.1  oster   struct timeval tv, diff;
    440  1.1  oster   int new_pctg;
    441  1.1  oster 
    442  1.1  oster   new_pctg = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs);
    443  1.1  oster   if (new_pctg != old_pctg) {
    444  1.1  oster     RF_GETTIME(tv);
    445  1.1  oster     RF_TIMEVAL_DIFF(starttime, &tv, &diff);
    446  1.1  oster #if RF_DEMO > 0
    447  1.1  oster     if (rf_demoMode) {
    448  1.1  oster       rf_update_recon_meter(new_pctg);
    449  1.1  oster     }
    450  1.1  oster     else {
    451  1.1  oster       printf("%d %d.%06d\n",new_pctg, diff.tv_sec, diff.tv_usec);
    452  1.1  oster     }
    453  1.1  oster #else /* RF_DEMO > 0 */
    454  1.1  oster     printf("%d %d.%06d\n",(int)new_pctg, (int)diff.tv_sec, (int)diff.tv_usec);
    455  1.1  oster #endif /* RF_DEMO > 0 */
    456  1.1  oster     old_pctg = new_pctg;
    457  1.1  oster   }
    458  1.1  oster }
    459