sys/dev/raidframe/rf_raid1.c

   1 /*      $NetBSD: rf_raid1.c,v 1.30 2007/03/04 06:02:39 christos Exp $   */
   2 /*
   3  * Copyright (c) 1995 Carnegie-Mellon University.
   4  * All rights reserved.
   5  *
   6  * Author: William V. Courtright II
   7  *
   8  * Permission to use, copy, modify and distribute this software and
   9  * its documentation is hereby granted, provided that both the copyright
  10  * notice and this permission notice appear in all copies of the
  11  * software, derivative works or modified versions, and any portions
  12  * thereof, and that both notices appear in supporting documentation.
  13  *
  14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  16  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  17  *
  18  * Carnegie Mellon requests users of this software to return to
  19  *
  20  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  21  *  School of Computer Science
  22  *  Carnegie Mellon University
  23  *  Pittsburgh PA 15213-3890
  24  *
  25  * any improvements or extensions that they make and grant Carnegie the
  26  * rights to redistribute these changes.
  27  */
  28
  29 /*****************************************************************************
  30  *
  31  * rf_raid1.c -- implements RAID Level 1
  32  *
  33  *****************************************************************************/
  34
  35 #include <sys/cdefs.h>
  36 __KERNEL_RCSID(0, "$NetBSD: rf_raid1.c,v 1.30 2007/03/04 06:02:39 christos Exp $");
  37
  38 #include "rf_raid.h"
  39 #include "rf_raid1.h"
  40 #include "rf_dag.h"
  41 #include "rf_dagffrd.h"
  42 #include "rf_dagffwr.h"
  43 #include "rf_dagdegrd.h"
  44 #include "rf_dagutils.h"
  45 #include "rf_dagfuncs.h"
  46 #include "rf_diskqueue.h"
  47 #include "rf_general.h"
  48 #include "rf_utils.h"
  49 #include "rf_parityscan.h"
  50 #include "rf_mcpair.h"
  51 #include "rf_layout.h"
  52 #include "rf_map.h"
  53 #include "rf_engine.h"
  54 #include "rf_reconbuffer.h"
  55
  56 typedef struct RF_Raid1ConfigInfo_s {
  57         RF_RowCol_t **stripeIdentifier;
  58 }       RF_Raid1ConfigInfo_t;
  59 /* start of day code specific to RAID level 1 */
  60 int
  61 rf_ConfigureRAID1(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
  62                   RF_Config_t *cfgPtr)
  63 {
  64         RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
  65         RF_Raid1ConfigInfo_t *info;
  66         RF_RowCol_t i;
  67
  68         /* create a RAID level 1 configuration structure */
  69         RF_MallocAndAdd(info, sizeof(RF_Raid1ConfigInfo_t), (RF_Raid1ConfigInfo_t *), raidPtr->cleanupList);
  70         if (info == NULL)
  71                 return (ENOMEM);
  72         layoutPtr->layoutSpecificInfo = (void *) info;
  73
  74         /* ... and fill it in. */
  75         info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol / 2, 2, raidPtr->cleanupList);
  76         if (info->stripeIdentifier == NULL)
  77                 return (ENOMEM);
  78         for (i = 0; i < (raidPtr->numCol / 2); i++) {
  79                 info->stripeIdentifier[i][0] = (2 * i);
  80                 info->stripeIdentifier[i][1] = (2 * i) + 1;
  81         }
  82
  83         /* this implementation of RAID level 1 uses one row of numCol disks
  84          * and allows multiple (numCol / 2) stripes per row.  A stripe
  85          * consists of a single data unit and a single parity (mirror) unit.
  86          * stripe id = raidAddr / stripeUnitSize */
  87         raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2) * layoutPtr->sectorsPerStripeUnit;
  88         layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2);
  89         layoutPtr->dataSectorsPerStripe = layoutPtr->sectorsPerStripeUnit;
  90         layoutPtr->numDataCol = 1;
  91         layoutPtr->numParityCol = 1;
  92         return (0);
  93 }
  94
  95
  96 /* returns the physical disk location of the primary copy in the mirror pair */
  97 void
  98 rf_MapSectorRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
  99                   RF_RowCol_t *col, RF_SectorNum_t *diskSector,
 100                   int remap)
 101 {
 102         RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 103         RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
 104
 105         *col = 2 * mirrorPair;
 106         *diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 107 }
 108
 109
 110 /* Map Parity
 111  *
 112  * returns the physical disk location of the secondary copy in the mirror
 113  * pair
 114  */
 115 void
 116 rf_MapParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
 117                   RF_RowCol_t *col, RF_SectorNum_t *diskSector,
 118                   int remap)
 119 {
 120         RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 121         RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
 122
 123         *col = (2 * mirrorPair) + 1;
 124
 125         *diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 126 }
 127
 128
 129 /* IdentifyStripeRAID1
 130  *
 131  * returns a list of disks for a given redundancy group
 132  */
 133 void
 134 rf_IdentifyStripeRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
 135                        RF_RowCol_t **diskids)
 136 {
 137         RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
 138         RF_Raid1ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
 139         RF_ASSERT(stripeID >= 0);
 140         RF_ASSERT(addr >= 0);
 141         *diskids = info->stripeIdentifier[stripeID % (raidPtr->numCol / 2)];
 142         RF_ASSERT(*diskids);
 143 }
 144
 145
 146 /* MapSIDToPSIDRAID1
 147  *
 148  * maps a logical stripe to a stripe in the redundant array
 149  */
 150 void
 151 rf_MapSIDToPSIDRAID1(RF_RaidLayout_t *layoutPtr,
 152                      RF_StripeNum_t stripeID,
 153                      RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 154 {
 155         *which_ru = 0;
 156         *psID = stripeID;
 157 }
 158
 159
 160
 161 /******************************************************************************
 162  * select a graph to perform a single-stripe access
 163  *
 164  * Parameters:  raidPtr    - description of the physical array
 165  *              type       - type of operation (read or write) requested
 166  *              asmap      - logical & physical addresses for this access
 167  *              createFunc - name of function to use to create the graph
 168  *****************************************************************************/
 169
 170 void
 171 rf_RAID1DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
 172                   RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
 173 {
 174         RF_RowCol_t fcol, oc;
 175         RF_PhysDiskAddr_t *failedPDA;
 176         int     prior_recon;
 177         RF_RowStatus_t rstat;
 178         RF_SectorNum_t oo;
 179
 180
 181         RF_ASSERT(RF_IO_IS_R_OR_W(type));
 182
 183         if (asmap->numDataFailed + asmap->numParityFailed > 1) {
 184 #if RF_DEBUG_DAG
 185                 if (rf_dagDebug)
 186                         RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
 187 #endif
 188                 *createFunc = NULL;
 189                 return;
 190         }
 191         if (asmap->numDataFailed + asmap->numParityFailed) {
 192                 /*
 193                  * We've got a fault. Re-map to spare space, iff applicable.
 194                  * Shouldn't the arch-independent code do this for us?
 195                  * Anyway, it turns out if we don't do this here, then when
 196                  * we're reconstructing, writes go only to the surviving
 197                  * original disk, and aren't reflected on the reconstructed
 198                  * spare. Oops. --jimz
 199                  */
 200                 failedPDA = asmap->failedPDAs[0];
 201                 fcol = failedPDA->col;
 202                 rstat = raidPtr->status;
 203                 prior_recon = (rstat == rf_rs_reconfigured) || (
 204                     (rstat == rf_rs_reconstructing) ?
 205                     rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, failedPDA->startSector) : 0
 206                     );
 207                 if (prior_recon) {
 208                         oc = fcol;
 209                         oo = failedPDA->startSector;
 210                         /*
 211                          * If we did distributed sparing, we'd monkey with that here.
 212                          * But we don't, so we'll
 213                          */
 214                         failedPDA->col = raidPtr->Disks[fcol].spareCol;
 215                         /*
 216                          * Redirect other components, iff necessary. This looks
 217                          * pretty suspicious to me, but it's what the raid5
 218                          * DAG select does.
 219                          */
 220                         if (asmap->parityInfo->next) {
 221                                 if (failedPDA == asmap->parityInfo) {
 222                                         failedPDA->next->col = failedPDA->col;
 223                                 } else {
 224                                         if (failedPDA == asmap->parityInfo->next) {
 225                                                 asmap->parityInfo->col = failedPDA->col;
 226                                         }
 227                                 }
 228                         }
 229 #if RF_DEBUG_DAG > 0 || RF_DEBUG_MAP > 0
 230                         if (rf_dagDebug || rf_mapDebug) {
 231                                 printf("raid%d: Redirected type '%c' c %d o %ld -> c %d o %ld\n",
 232                                        raidPtr->raidid, type, oc,
 233                                        (long) oo,
 234                                        failedPDA->col,
 235                                        (long) failedPDA->startSector);
 236                         }
 237 #endif
 238                         asmap->numDataFailed = asmap->numParityFailed = 0;
 239                 }
 240         }
 241         if (type == RF_IO_TYPE_READ) {
 242                 if (asmap->numDataFailed == 0)
 243                         *createFunc = (RF_VoidFuncPtr) rf_CreateMirrorIdleReadDAG;
 244                 else
 245                         *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneDegradedReadDAG;
 246         } else {
 247                 *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
 248         }
 249 }
 250
 251 int
 252 rf_VerifyParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
 253                      RF_PhysDiskAddr_t *parityPDA, int correct_it,
 254                      RF_RaidAccessFlags_t flags)
 255 {
 256         int     nbytes, bcount, stripeWidth, ret, i, j, nbad, *bbufs;
 257         RF_DagNode_t *blockNode, *wrBlock;
 258         RF_DagHeader_t *rd_dag_h, *wr_dag_h;
 259         RF_AccessStripeMapHeader_t *asm_h;
 260         RF_AllocListElem_t *allocList;
 261 #if RF_ACC_TRACE > 0
 262         RF_AccTraceEntry_t tracerec;
 263 #endif
 264         RF_ReconUnitNum_t which_ru;
 265         RF_RaidLayout_t *layoutPtr;
 266         RF_AccessStripeMap_t *aasm;
 267         RF_SectorCount_t nsector;
 268         RF_RaidAddr_t startAddr;
 269         char   *bf, *buf1, *buf2;
 270         RF_PhysDiskAddr_t *pda;
 271         RF_StripeNum_t psID;
 272         RF_MCPair_t *mcpair;
 273
 274         layoutPtr = &raidPtr->Layout;
 275         startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
 276         nsector = parityPDA->numSector;
 277         nbytes = rf_RaidAddressToByte(raidPtr, nsector);
 278         psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru);
 279
 280         asm_h = NULL;
 281         rd_dag_h = wr_dag_h = NULL;
 282         mcpair = NULL;
 283
 284         ret = RF_PARITY_COULD_NOT_VERIFY;
 285
 286         rf_MakeAllocList(allocList);
 287         if (allocList == NULL)
 288                 return (RF_PARITY_COULD_NOT_VERIFY);
 289         mcpair = rf_AllocMCPair();
 290         if (mcpair == NULL)
 291                 goto done;
 292         RF_ASSERT(layoutPtr->numDataCol == layoutPtr->numParityCol);
 293         stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
 294         bcount = nbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol);
 295         RF_MallocAndAdd(bf, bcount, (char *), allocList);
 296         if (bf == NULL)
 297                 goto done;
 298 #if RF_DEBUG_VERIFYPARITY
 299         if (rf_verifyParityDebug) {
 300                 printf("raid%d: RAID1 parity verify: buf=%lx bcount=%d (%lx - %lx)\n",
 301                        raidPtr->raidid, (long) bf, bcount, (long) bf,
 302                        (long) bf + bcount);
 303         }
 304 #endif
 305         /*
 306          * Generate a DAG which will read the entire stripe- then we can
 307          * just compare data chunks versus "parity" chunks.
 308          */
 309
 310         rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, nbytes, bf,
 311             rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rod", allocList, flags,
 312             RF_IO_NORMAL_PRIORITY);
 313         if (rd_dag_h == NULL)
 314                 goto done;
 315         blockNode = rd_dag_h->succedents[0];
 316
 317         /*
 318          * Map the access to physical disk addresses (PDAs)- this will
 319          * get us both a list of data addresses, and "parity" addresses
 320          * (which are really mirror copies).
 321          */
 322         asm_h = rf_MapAccess(raidPtr, startAddr, layoutPtr->dataSectorsPerStripe,
 323             bf, RF_DONT_REMAP);
 324         aasm = asm_h->stripeMap;
 325
 326         buf1 = bf;
 327         /*
 328          * Loop through the data blocks, setting up read nodes for each.
 329          */
 330         for (pda = aasm->physInfo, i = 0; i < layoutPtr->numDataCol; i++, pda = pda->next) {
 331                 RF_ASSERT(pda);
 332
 333                 rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
 334
 335                 RF_ASSERT(pda->numSector != 0);
 336                 if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
 337                         /* cannot verify parity with dead disk */
 338                         goto done;
 339                 }
 340                 pda->bufPtr = buf1;
 341                 blockNode->succedents[i]->params[0].p = pda;
 342                 blockNode->succedents[i]->params[1].p = buf1;
 343                 blockNode->succedents[i]->params[2].v = psID;
 344                 blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru);
 345                 buf1 += nbytes;
 346         }
 347         RF_ASSERT(pda == NULL);
 348         /*
 349          * keep i, buf1 running
 350          *
 351          * Loop through parity blocks, setting up read nodes for each.
 352          */
 353         for (pda = aasm->parityInfo; i < layoutPtr->numDataCol + layoutPtr->numParityCol; i++, pda = pda->next) {
 354                 RF_ASSERT(pda);
 355                 rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
 356                 RF_ASSERT(pda->numSector != 0);
 357                 if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
 358                         /* cannot verify parity with dead disk */
 359                         goto done;
 360                 }
 361                 pda->bufPtr = buf1;
 362                 blockNode->succedents[i]->params[0].p = pda;
 363                 blockNode->succedents[i]->params[1].p = buf1;
 364                 blockNode->succedents[i]->params[2].v = psID;
 365                 blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru);
 366                 buf1 += nbytes;
 367         }
 368         RF_ASSERT(pda == NULL);
 369
 370 #if RF_ACC_TRACE > 0
 371         memset((char *) &tracerec, 0, sizeof(tracerec));
 372         rd_dag_h->tracerec = &tracerec;
 373 #endif
 374 #if 0
 375         if (rf_verifyParityDebug > 1) {
 376                 printf("raid%d: RAID1 parity verify read dag:\n",
 377                        raidPtr->raidid);
 378                 rf_PrintDAGList(rd_dag_h);
 379         }
 380 #endif
 381         RF_LOCK_MUTEX(mcpair->mutex);
 382         mcpair->flag = 0;
 383         RF_UNLOCK_MUTEX(mcpair->mutex);
 384
 385         rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
 386             (void *) mcpair);
 387
 388         RF_LOCK_MUTEX(mcpair->mutex);
 389         while (mcpair->flag == 0) {
 390                 RF_WAIT_MCPAIR(mcpair);
 391         }
 392         RF_UNLOCK_MUTEX(mcpair->mutex);
 393
 394         if (rd_dag_h->status != rf_enable) {
 395                 RF_ERRORMSG("Unable to verify raid1 parity: can't read stripe\n");
 396                 ret = RF_PARITY_COULD_NOT_VERIFY;
 397                 goto done;
 398         }
 399         /*
 400          * buf1 is the beginning of the data blocks chunk
 401          * buf2 is the beginning of the parity blocks chunk
 402          */
 403         buf1 = bf;
 404         buf2 = bf + (nbytes * layoutPtr->numDataCol);
 405         ret = RF_PARITY_OKAY;
 406         /*
 407          * bbufs is "bad bufs"- an array whose entries are the data
 408          * column numbers where we had miscompares. (That is, column 0
 409          * and column 1 of the array are mirror copies, and are considered
 410          * "data column 0" for this purpose).
 411          */
 412         RF_MallocAndAdd(bbufs, layoutPtr->numParityCol * sizeof(int), (int *),
 413             allocList);
 414         nbad = 0;
 415         /*
 416          * Check data vs "parity" (mirror copy).
 417          */
 418         for (i = 0; i < layoutPtr->numDataCol; i++) {
 419 #if RF_DEBUG_VERIFYPARITY
 420                 if (rf_verifyParityDebug) {
 421                         printf("raid%d: RAID1 parity verify %d bytes: i=%d buf1=%lx buf2=%lx buf=%lx\n",
 422                                raidPtr->raidid, nbytes, i, (long) buf1,
 423                                (long) buf2, (long) bf);
 424                 }
 425 #endif
 426                 ret = memcmp(buf1, buf2, nbytes);
 427                 if (ret) {
 428 #if RF_DEBUG_VERIFYPARITY
 429                         if (rf_verifyParityDebug > 1) {
 430                                 for (j = 0; j < nbytes; j++) {
 431                                         if (buf1[j] != buf2[j])
 432                                                 break;
 433                                 }
 434                                 printf("psid=%ld j=%d\n", (long) psID, j);
 435                                 printf("buf1 %02x %02x %02x %02x %02x\n", buf1[0] & 0xff,
 436                                     buf1[1] & 0xff, buf1[2] & 0xff, buf1[3] & 0xff, buf1[4] & 0xff);
 437                                 printf("buf2 %02x %02x %02x %02x %02x\n", buf2[0] & 0xff,
 438                                     buf2[1] & 0xff, buf2[2] & 0xff, buf2[3] & 0xff, buf2[4] & 0xff);
 439                         }
 440                         if (rf_verifyParityDebug) {
 441                                 printf("raid%d: RAID1: found bad parity, i=%d\n", raidPtr->raidid, i);
 442                         }
 443 #endif
 444                         /*
 445                          * Parity is bad. Keep track of which columns were bad.
 446                          */
 447                         if (bbufs)
 448                                 bbufs[nbad] = i;
 449                         nbad++;
 450                         ret = RF_PARITY_BAD;
 451                 }
 452                 buf1 += nbytes;
 453                 buf2 += nbytes;
 454         }
 455
 456         if ((ret != RF_PARITY_OKAY) && correct_it) {
 457                 ret = RF_PARITY_COULD_NOT_CORRECT;
 458 #if RF_DEBUG_VERIFYPARITY
 459                 if (rf_verifyParityDebug) {
 460                         printf("raid%d: RAID1 parity verify: parity not correct\n", raidPtr->raidid);
 461                 }
 462 #endif
 463                 if (bbufs == NULL)
 464                         goto done;
 465                 /*
 466                  * Make a DAG with one write node for each bad unit. We'll simply
 467                  * write the contents of the data unit onto the parity unit for
 468                  * correction. (It's possible that the mirror copy was the correct
 469                  * copy, and that we're spooging good data by writing bad over it,
 470                  * but there's no way we can know that.
 471                  */
 472                 wr_dag_h = rf_MakeSimpleDAG(raidPtr, nbad, nbytes, bf,
 473                     rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wnp", allocList, flags,
 474                     RF_IO_NORMAL_PRIORITY);
 475                 if (wr_dag_h == NULL)
 476                         goto done;
 477                 wrBlock = wr_dag_h->succedents[0];
 478                 /*
 479                  * Fill in a write node for each bad compare.
 480                  */
 481                 for (i = 0; i < nbad; i++) {
 482                         j = i + layoutPtr->numDataCol;
 483                         pda = blockNode->succedents[j]->params[0].p;
 484                         pda->bufPtr = blockNode->succedents[i]->params[1].p;
 485                         wrBlock->succedents[i]->params[0].p = pda;
 486                         wrBlock->succedents[i]->params[1].p = pda->bufPtr;
 487                         wrBlock->succedents[i]->params[2].v = psID;
 488                         wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru);
 489                 }
 490 #if RF_ACC_TRACE > 0
 491                 memset((char *) &tracerec, 0, sizeof(tracerec));
 492                 wr_dag_h->tracerec = &tracerec;
 493 #endif
 494 #if 0
 495                 if (rf_verifyParityDebug > 1) {
 496                         printf("Parity verify write dag:\n");
 497                         rf_PrintDAGList(wr_dag_h);
 498                 }
 499 #endif
 500                 RF_LOCK_MUTEX(mcpair->mutex);
 501                 mcpair->flag = 0;
 502                 RF_UNLOCK_MUTEX(mcpair->mutex);
 503
 504                 /* fire off the write DAG */
 505                 rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
 506                     (void *) mcpair);
 507
 508                 RF_LOCK_MUTEX(mcpair->mutex);
 509                 while (!mcpair->flag) {
 510                         RF_WAIT_COND(mcpair->cond, mcpair->mutex);
 511                 }
 512                 RF_UNLOCK_MUTEX(mcpair->mutex);
 513                 if (wr_dag_h->status != rf_enable) {
 514                         RF_ERRORMSG("Unable to correct RAID1 parity in VerifyParity\n");
 515                         goto done;
 516                 }
 517                 ret = RF_PARITY_CORRECTED;
 518         }
 519 done:
 520         /*
 521          * All done. We might've gotten here without doing part of the function,
 522          * so cleanup what we have to and return our running status.
 523          */
 524         if (asm_h)
 525                 rf_FreeAccessStripeMap(asm_h);
 526         if (rd_dag_h)
 527                 rf_FreeDAG(rd_dag_h);
 528         if (wr_dag_h)
 529                 rf_FreeDAG(wr_dag_h);
 530         if (mcpair)
 531                 rf_FreeMCPair(mcpair);
 532         rf_FreeAllocList(allocList);
 533 #if RF_DEBUG_VERIFYPARITY
 534         if (rf_verifyParityDebug) {
 535                 printf("raid%d: RAID1 parity verify, returning %d\n",
 536                        raidPtr->raidid, ret);
 537         }
 538 #endif
 539         return (ret);
 540 }
 541
 542 /* rbuf          - the recon buffer to submit
 543  * keep_it       - whether we can keep this buffer or we have to return it
 544  * use_committed - whether to use a committed or an available recon buffer
 545  */
 546
 547 int
 548 rf_SubmitReconBufferRAID1(RF_ReconBuffer_t *rbuf, int keep_it,
 549                           int use_committed)
 550 {
 551         RF_ReconParityStripeStatus_t *pssPtr;
 552         RF_ReconCtrl_t *reconCtrlPtr;
 553         int     retcode;
 554         RF_CallbackDesc_t *cb, *p;
 555         RF_ReconBuffer_t *t;
 556         RF_Raid_t *raidPtr;
 557         void *ta;
 558
 559         retcode = 0;
 560
 561         raidPtr = rbuf->raidPtr;
 562         reconCtrlPtr = raidPtr->reconControl;
 563
 564         RF_ASSERT(rbuf);
 565         RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
 566
 567 #if RF_DEBUG_RECON
 568         if (rf_reconbufferDebug) {
 569                 printf("raid%d: RAID1 reconbuffer submission c%d psid %ld ru%d (failed offset %ld)\n",
 570                        raidPtr->raidid, rbuf->col,
 571                        (long) rbuf->parityStripeID, rbuf->which_ru,
 572                        (long) rbuf->failedDiskSectorOffset);
 573         }
 574 #endif
 575         if (rf_reconDebug) {
 576                 unsigned char *b = rbuf->buffer;
 577                 printf("RAID1 reconbuffer submit psid %ld buf %lx\n",
 578                     (long) rbuf->parityStripeID, (long) rbuf->buffer);
 579                 printf("RAID1 psid %ld   %02x %02x %02x %02x %02x\n",
 580                     (long)rbuf->parityStripeID, b[0], b[1], b[2], b[3], b[4]);
 581         }
 582         RF_LOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID);
 583
 584         RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
 585         while(reconCtrlPtr->rb_lock) {
 586                 ltsleep(&reconCtrlPtr->rb_lock, PRIBIO, "reconctlcnmhs", 0, &reconCtrlPtr->rb_mutex);
 587         }
 588         reconCtrlPtr->rb_lock = 1;
 589         RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
 590
 591         pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
 592             rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, NULL);
 593         RF_ASSERT(pssPtr);      /* if it didn't exist, we wouldn't have gotten
 594                                  * an rbuf for it */
 595
 596         /*
 597          * Since this is simple mirroring, the first submission for a stripe is also
 598          * treated as the last.
 599          */
 600
 601         t = NULL;
 602         if (keep_it) {
 603 #if RF_DEBUG_RECON
 604                 if (rf_reconbufferDebug) {
 605                         printf("raid%d: RAID1 rbuf submission: keeping rbuf\n",
 606                                raidPtr->raidid);
 607                 }
 608 #endif
 609                 t = rbuf;
 610         } else {
 611                 if (use_committed) {
 612 #if RF_DEBUG_RECON
 613                         if (rf_reconbufferDebug) {
 614                                 printf("raid%d: RAID1 rbuf submission: using committed rbuf\n", raidPtr->raidid);
 615                         }
 616 #endif
 617                         t = reconCtrlPtr->committedRbufs;
 618                         RF_ASSERT(t);
 619                         reconCtrlPtr->committedRbufs = t->next;
 620                         t->next = NULL;
 621                 } else
 622                         if (reconCtrlPtr->floatingRbufs) {
 623 #if RF_DEBUG_RECON
 624                                 if (rf_reconbufferDebug) {
 625                                         printf("raid%d: RAID1 rbuf submission: using floating rbuf\n", raidPtr->raidid);
 626                                 }
 627 #endif
 628                                 t = reconCtrlPtr->floatingRbufs;
 629                                 reconCtrlPtr->floatingRbufs = t->next;
 630                                 t->next = NULL;
 631                         }
 632         }
 633         if (t == NULL) {
 634 #if RF_DEBUG_RECON
 635                 if (rf_reconbufferDebug) {
 636                         printf("raid%d: RAID1 rbuf submission: waiting for rbuf\n", raidPtr->raidid);
 637                 }
 638 #endif
 639                 RF_ASSERT((keep_it == 0) && (use_committed == 0));
 640                 raidPtr->procsInBufWait++;
 641                 if ((raidPtr->procsInBufWait == (raidPtr->numCol - 1))
 642                     && (raidPtr->numFullReconBuffers == 0)) {
 643                         /* ruh-ro */
 644                         RF_ERRORMSG("Buffer wait deadlock\n");
 645                         rf_PrintPSStatusTable(raidPtr);
 646                         RF_PANIC();
 647                 }
 648                 pssPtr->flags |= RF_PSS_BUFFERWAIT;
 649                 cb = rf_AllocCallbackDesc();
 650                 cb->col = rbuf->col;
 651                 cb->callbackArg.v = rbuf->parityStripeID;
 652                 cb->next = NULL;
 653                 if (reconCtrlPtr->bufferWaitList == NULL) {
 654                         /* we are the wait list- lucky us */
 655                         reconCtrlPtr->bufferWaitList = cb;
 656                 } else {
 657                         /* append to wait list */
 658                         for (p = reconCtrlPtr->bufferWaitList; p->next; p = p->next);
 659                         p->next = cb;
 660                 }
 661                 retcode = 1;
 662                 goto out;
 663         }
 664         if (t != rbuf) {
 665                 t->col = reconCtrlPtr->fcol;
 666                 t->parityStripeID = rbuf->parityStripeID;
 667                 t->which_ru = rbuf->which_ru;
 668                 t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
 669                 t->spCol = rbuf->spCol;
 670                 t->spOffset = rbuf->spOffset;
 671                 /* Swap buffers. DANCE! */
 672                 ta = t->buffer;
 673                 t->buffer = rbuf->buffer;
 674                 rbuf->buffer = ta;
 675         }
 676         /*
 677          * Use the rbuf we've been given as the target.
 678          */
 679         RF_ASSERT(pssPtr->rbuf == NULL);
 680         pssPtr->rbuf = t;
 681
 682         t->count = 1;
 683         /*
 684          * Below, we use 1 for numDataCol (which is equal to the count in the
 685          * previous line), so we'll always be done.
 686          */
 687         rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, 1);
 688
 689 out:
 690         RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID);
 691         RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
 692         reconCtrlPtr->rb_lock = 0;
 693         wakeup(&reconCtrlPtr->rb_lock);
 694         RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
 695 #if RF_DEBUG_RECON
 696         if (rf_reconbufferDebug) {
 697                 printf("raid%d: RAID1 rbuf submission: returning %d\n",
 698                        raidPtr->raidid, retcode);
 699         }
 700 #endif
 701         return (retcode);
 702 }
 703
 704 RF_HeadSepLimit_t
 705 rf_GetDefaultHeadSepLimitRAID1(RF_Raid_t *raidPtr)
 706 {
 707         return (10);
 708 }
 709