root/dev/raidframe/rf_paritylogging.c

DEFINITIONS

1. RF_ParityLoggingConfigInfo_t
2. rf_ConfigureParityLogging
3. rf_FreeRegionInfo
4. rf_FreeParityLogQueue
5. rf_FreeRegionBufferQueue
6. rf_ShutdownParityLoggingRegionInfo
7. rf_ShutdownParityLoggingPool
8. rf_ShutdownParityLoggingRegionBufferPool
9. rf_ShutdownParityLoggingParityBufferPool
10. rf_ShutdownParityLoggingDiskQueue
11. rf_ShutdownParityLogging
12. rf_GetDefaultNumFloatingReconBuffersParityLogging
13. rf_GetDefaultHeadSepLimitParityLogging
14. rf_MapRegionIDParityLogging
15. rf_MapSectorParityLogging
16. rf_MapParityParityLogging
17. rf_MapLogParityLogging
18. rf_MapRegionParity
19. rf_IdentifyStripeParityLogging
20. rf_MapSIDToPSIDParityLogging
21. rf_ParityLoggingDagSelect

    1 /*      $OpenBSD: rf_paritylogging.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $     */
    2 /*      $NetBSD: rf_paritylogging.c,v 1.10 2000/02/12 16:06:27 oster Exp $      */
    4 /*
    5  * Copyright (c) 1995 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Author: William V. Courtright II
    9  *
   10  * Permission to use, copy, modify and distribute this software and
   11  * its documentation is hereby granted, provided that both the copyright
   12  * notice and this permission notice appear in all copies of the
   13  * software, derivative works or modified versions, and any portions
   14  * thereof, and that both notices appear in supporting documentation.
   15  *
   16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   19  *
   20  * Carnegie Mellon requests users of this software to return to
   21  *
   22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   23  *  School of Computer Science
   24  *  Carnegie Mellon University
   25  *  Pittsburgh PA 15213-3890
   26  *
   27  * any improvements or extensions that they make and grant Carnegie the
   28  * rights to redistribute these changes.
   29  */
   32 /*
   33  * Parity logging configuration, dag selection, and mapping is implemented here.
   34  */
   36 #include "rf_archs.h"
   38 #if     RF_INCLUDE_PARITYLOGGING > 0
   40 #include "rf_types.h"
   41 #include "rf_raid.h"
   42 #include "rf_dag.h"
   43 #include "rf_dagutils.h"
   44 #include "rf_dagfuncs.h"
   45 #include "rf_dagffrd.h"
   46 #include "rf_dagffwr.h"
   47 #include "rf_dagdegrd.h"
   48 #include "rf_dagdegwr.h"
   49 #include "rf_paritylog.h"
   50 #include "rf_paritylogDiskMgr.h"
   51 #include "rf_paritylogging.h"
   52 #include "rf_parityloggingdags.h"
   53 #include "rf_general.h"
   54 #include "rf_map.h"
   55 #include "rf_utils.h"
   56 #include "rf_shutdown.h"
   58 typedef struct RF_ParityLoggingConfigInfo_s {
RF_RowCol_t **stripeIdentifier; /*
   60                                          * Filled in at config time & used by
   61                                          * IdentifyStripe.
   62                                          */
   63 } RF_ParityLoggingConfigInfo_t;
   65 void rf_FreeRegionInfo(RF_Raid_t *, RF_RegionId_t);
   66 void rf_FreeParityLogQueue(RF_Raid_t *, RF_ParityLogQueue_t *);
   67 void rf_FreeRegionBufferQueue(RF_RegionBufferQueue_t *);
   68 void rf_ShutdownParityLogging(RF_ThreadArg_t);
   69 void rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t);
   70 void rf_ShutdownParityLoggingPool(RF_ThreadArg_t);
   71 void rf_ShutdownParityLoggingRegionBufferPool(RF_ThreadArg_t);
   72 void rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t);
   73 void rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t);
   76 int
rf_ConfigureParityLogging(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
RF_Config_t *cfgPtr)
   79 {
   80         int i, j, startdisk, rc;
RF_SectorCount_t totalLogCapacity, fragmentation, lastRegionCapacity;
RF_SectorCount_t parityBufferCapacity, maxRegionParityRange;
RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
RF_ParityLoggingConfigInfo_t *info;
RF_ParityLog_t *l = NULL, *next;
caddr_t lHeapPtr;
   88         if (rf_numParityRegions <= 0)
   89                 return(EINVAL);
   91         /*
   92          * We create multiple entries on the shutdown list here, since
   93          * this configuration routine is fairly complicated in and of
   94          * itself, and this makes backing out of a failed configuration
   95          * much simpler.
   96          */
raidPtr->numSectorsPerLog = RF_DEFAULT_NUM_SECTORS_PER_LOG;
  100         /* Create a parity logging configuration structure. */
RF_MallocAndAdd(info, sizeof(RF_ParityLoggingConfigInfo_t),
  102                         (RF_ParityLoggingConfigInfo_t *),
raidPtr->cleanupList);
  104         if (info == NULL)
  105                 return (ENOMEM);
layoutPtr->layoutSpecificInfo = (void *) info;
RF_ASSERT(raidPtr->numRow == 1);
  110         /*
  111          * The stripe identifier must identify the disks in each stripe, IN
  112          * THE ORDER THAT THEY APPEAR IN THE STRIPE.
  113          */
info->stripeIdentifier = rf_make_2d_array((raidPtr->numCol),
  115                                                   (raidPtr->numCol),
raidPtr->cleanupList);
  117         if (info->stripeIdentifier == NULL)
  118                 return (ENOMEM);
startdisk = 0;
  121         for (i = 0; i < (raidPtr->numCol); i++) {
  122                 for (j = 0; j < (raidPtr->numCol); j++) {
info->stripeIdentifier[i][j] = (startdisk + j) %
  124                             (raidPtr->numCol - 1);
  125                 }
  126                 if ((--startdisk) < 0)
startdisk = raidPtr->numCol - 1 - 1;
  128         }
  130         /* Fill in the remaining layout parameters. */
layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
raidPtr->logBytesPerSector;
layoutPtr->numParityCol = 1;
layoutPtr->numParityLogCol = 1;
layoutPtr->numDataCol = raidPtr->numCol - layoutPtr->numParityCol -
layoutPtr->numParityLogCol;
layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
layoutPtr->sectorsPerStripeUnit;
layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
layoutPtr->sectorsPerStripeUnit;
raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
  147         /*
  148          * Configure parity log parameters.
  149          *
  150          * Parameter                    Comment/constraints
  151          * ------------------------------------------------
  152          * numParityRegions*            All regions (except possibly last)
  153          *                              of equal size.
  154          * totalInCoreLogCapacity*      Amount of memory in bytes available
  155          *                              for in-core logs (default 1 MB).
  156          * numSectorsPerLog#            Capacity of an in-core log in sectors
  157          *                              (1 * disk track).
  158          * numParityLogs                Total number of in-core logs,
  159          *                              should be at least numParityRegions.
  160          * regionLogCapacity            Size of a region log (except possibly
  161          *                              last one) in sectors.
  162          * totalLogCapacity             Total amount of log space in sectors.
  163          *
  164          * Where '*' denotes a user settable parameter.
  165          * Note that logs are fixed to be the size of a disk track,
  166          * value #defined in rf_paritylog.h.
  167          *
  168          */
totalLogCapacity = layoutPtr->stripeUnitsPerDisk *
layoutPtr->sectorsPerStripeUnit * layoutPtr->numParityLogCol;
raidPtr->regionLogCapacity = totalLogCapacity / rf_numParityRegions;
  173         if (rf_parityLogDebug)
printf("bytes per sector %d\n", raidPtr->bytesPerSector);
  176         /*
  177          * Reduce fragmentation within a disk region by adjusting the number
  178          * of regions in an attempt to allow an integral number of logs to fit
  179          * into a disk region.
  180          */
fragmentation = raidPtr->regionLogCapacity % raidPtr->numSectorsPerLog;
  182         if (fragmentation > 0)
  183                 for (i = 1; i < (raidPtr->numSectorsPerLog / 2); i++) {
  184                         if (((totalLogCapacity / (rf_numParityRegions + i)) %
raidPtr->numSectorsPerLog) < fragmentation) {
rf_numParityRegions++;
raidPtr->regionLogCapacity = totalLogCapacity /
rf_numParityRegions;
fragmentation = raidPtr->regionLogCapacity %
raidPtr->numSectorsPerLog;
  191                         }
  192                         if (((totalLogCapacity / (rf_numParityRegions - i)) %
raidPtr->numSectorsPerLog) < fragmentation) {
rf_numParityRegions--;
raidPtr->regionLogCapacity = totalLogCapacity /
rf_numParityRegions;
fragmentation = raidPtr->regionLogCapacity %
raidPtr->numSectorsPerLog;
  199                         }
  200                 }
  201         /* Ensure integral number of regions per log. */
raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity /
raidPtr->numSectorsPerLog) * raidPtr->numSectorsPerLog;
raidPtr->numParityLogs = rf_totalInCoreLogCapacity /
  206             (raidPtr->bytesPerSector * raidPtr->numSectorsPerLog);
  207         /*
  208          * To avoid deadlock, must ensure that enough logs exist for each
  209          * region to have one simultaneously.
  210          */
  211         if (raidPtr->numParityLogs < rf_numParityRegions)
raidPtr->numParityLogs = rf_numParityRegions;
  214         /* Create region information structs. */
printf("Allocating %d bytes for in-core parity region info\n",
  216                (int) (rf_numParityRegions * sizeof(RF_RegionInfo_t)));
RF_Malloc(raidPtr->regionInfo,
  218                   (rf_numParityRegions * sizeof(RF_RegionInfo_t)),
  219                   (RF_RegionInfo_t *));
  220         if (raidPtr->regionInfo == NULL)
  221                 return (ENOMEM);
  223         /* Last region may not be full capacity. */
lastRegionCapacity = raidPtr->regionLogCapacity;
  225         while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity +
lastRegionCapacity > totalLogCapacity)
lastRegionCapacity = lastRegionCapacity -
raidPtr->numSectorsPerLog;
raidPtr->regionParityRange = raidPtr->sectorsPerDisk /
rf_numParityRegions;
maxRegionParityRange = raidPtr->regionParityRange;
  234         /* I can't remember why this line is in the code -wvcii 6/30/95. */
  235         /* if (raidPtr->sectorsPerDisk % rf_numParityRegions > 0)
  236          *      regionParityRange++; */
  238         /* Build pool of unused parity logs. */
printf("Allocating %d bytes for %d parity logs\n",
raidPtr->numParityLogs * raidPtr->numSectorsPerLog *
raidPtr->bytesPerSector,
raidPtr->numParityLogs);
RF_Malloc(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
raidPtr->numSectorsPerLog * raidPtr->bytesPerSector,
  245                   (caddr_t));
  246         if (raidPtr->parityLogBufferHeap == NULL)
  247                 return (ENOMEM);
lHeapPtr = raidPtr->parityLogBufferHeap;
rc = rf_mutex_init(&raidPtr->parityLogPool.mutex);
  250         if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
  255                 return (ENOMEM);
  256         }
  257         for (i = 0; i < raidPtr->numParityLogs; i++) {
  258                 if (i == 0) {
RF_Calloc(raidPtr->parityLogPool.parityLogs, 1,
  260                                   sizeof(RF_ParityLog_t), (RF_ParityLog_t *));
  261                         if (raidPtr->parityLogPool.parityLogs == NULL) {
RF_Free(raidPtr->parityLogBufferHeap,
raidPtr->numParityLogs *
raidPtr->numSectorsPerLog *
raidPtr->bytesPerSector);
  266                                 return (ENOMEM);
  267                         }
l = raidPtr->parityLogPool.parityLogs;
  269                 } else {
RF_Calloc(l->next, 1, sizeof(RF_ParityLog_t),
  271                                   (RF_ParityLog_t *));
  272                         if (l->next == NULL) {
RF_Free(raidPtr->parityLogBufferHeap,
raidPtr->numParityLogs *
raidPtr->numSectorsPerLog *
raidPtr->bytesPerSector);
  277                                 for (l = raidPtr->parityLogPool.parityLogs;
l;
l = next) {
next = l->next;
  281                                         if (l->records)
RF_Free(l->records,
  283                                                     (raidPtr->numSectorsPerLog *
  284                                                  sizeof(RF_ParityLogRecord_t)));
RF_Free(l, sizeof(RF_ParityLog_t));
  286                                 }
  287                                 return (ENOMEM);
  288                         }
l = l->next;
  290                 }
l->bufPtr = lHeapPtr;
lHeapPtr += raidPtr->numSectorsPerLog *
raidPtr->bytesPerSector;
RF_Malloc(l->records, (raidPtr->numSectorsPerLog *
  295                                        sizeof(RF_ParityLogRecord_t)),
  296                           (RF_ParityLogRecord_t *));
  297                 if (l->records == NULL) {
RF_Free(raidPtr->parityLogBufferHeap,
raidPtr->numParityLogs *
raidPtr->numSectorsPerLog *
raidPtr->bytesPerSector);
  302                         for (l = raidPtr->parityLogPool.parityLogs;
l;
l = next) {
next = l->next;
  306                                 if (l->records)
RF_Free(l->records,
  308                                                 (raidPtr->numSectorsPerLog *
  309                                                  sizeof(RF_ParityLogRecord_t)));
RF_Free(l, sizeof(RF_ParityLog_t));
  311                         }
  312                         return (ENOMEM);
  313                 }
  314         }
rc = rf_ShutdownCreate(listp, rf_ShutdownParityLoggingPool, raidPtr);
  316         if (rc) {
RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
  318                              " rc=%d\n", __FILE__, __LINE__, rc);
rf_ShutdownParityLoggingPool(raidPtr);
  320                 return (rc);
  321         }
  322         /* Build pool of region buffers. */
rc = rf_mutex_init(&raidPtr->regionBufferPool.mutex);
  324         if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
  327                 return (ENOMEM);
  328         }
rc = rf_cond_init(&raidPtr->regionBufferPool.cond);
  330         if (rc) {
RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
  334                 return (ENOMEM);
  335         }
raidPtr->regionBufferPool.bufferSize = raidPtr->regionLogCapacity *
raidPtr->bytesPerSector;
printf("regionBufferPool.bufferSize %d\n",
raidPtr->regionBufferPool.bufferSize);
  341         /* For now, only one region at a time may be reintegrated. */
raidPtr->regionBufferPool.totalBuffers = 1;
raidPtr->regionBufferPool.availableBuffers =
raidPtr->regionBufferPool.totalBuffers;
raidPtr->regionBufferPool.availBuffersIndex = 0;
raidPtr->regionBufferPool.emptyBuffersIndex = 0;
printf("Allocating %d bytes for regionBufferPool\n",
  349                (int) (raidPtr->regionBufferPool.totalBuffers *
  350                       sizeof(caddr_t)));
RF_Malloc(raidPtr->regionBufferPool.buffers,
raidPtr->regionBufferPool.totalBuffers * sizeof(caddr_t),
  353                   (caddr_t *));
  354         if (raidPtr->regionBufferPool.buffers == NULL) {
rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
rf_cond_destroy(&raidPtr->regionBufferPool.cond);
  357                 return (ENOMEM);
  358         }
  359         for (i = 0; i < raidPtr->regionBufferPool.totalBuffers; i++) {
printf("Allocating %d bytes for regionBufferPool#%d\n",
  361                        (int) (raidPtr->regionBufferPool.bufferSize *
  362                               sizeof(char)), i);
RF_Malloc(raidPtr->regionBufferPool.buffers[i],
raidPtr->regionBufferPool.bufferSize * sizeof(char),
  365                           (caddr_t));
  366                 if (raidPtr->regionBufferPool.buffers[i] == NULL) {
rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
rf_cond_destroy(&raidPtr->regionBufferPool.cond);
  369                         for (j = 0; j < i; j++) {
RF_Free(raidPtr->regionBufferPool.buffers[i],
raidPtr->regionBufferPool.bufferSize *
  372                                         sizeof(char));
  373                         }
RF_Free(raidPtr->regionBufferPool.buffers,
raidPtr->regionBufferPool.totalBuffers *
  376                                 sizeof(caddr_t));
  377                         return (ENOMEM);
  378                 }
printf("raidPtr->regionBufferPool.buffers[%d] = %lx\n", i,
  380                     (long) raidPtr->regionBufferPool.buffers[i]);
  381         }
rc = rf_ShutdownCreate(listp,
rf_ShutdownParityLoggingRegionBufferPool,
raidPtr);
  385         if (rc) {
RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
  387                              " rc=%d\n", __FILE__, __LINE__, rc);
rf_ShutdownParityLoggingRegionBufferPool(raidPtr);
  389                 return (rc);
  390         }
  391         /* Build pool of parity buffers. */
parityBufferCapacity = maxRegionParityRange;
rc = rf_mutex_init(&raidPtr->parityBufferPool.mutex);
  394         if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
  397                 return (rc);
  398         }
rc = rf_cond_init(&raidPtr->parityBufferPool.cond);
  400         if (rc) {
RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
  404                 return (ENOMEM);
  405         }
raidPtr->parityBufferPool.bufferSize = parityBufferCapacity *
raidPtr->bytesPerSector;
printf("parityBufferPool.bufferSize %d\n",
raidPtr->parityBufferPool.bufferSize);
  411         /* For now, only one region at a time may be reintegrated. */
raidPtr->parityBufferPool.totalBuffers = 1;
raidPtr->parityBufferPool.availableBuffers =
raidPtr->parityBufferPool.totalBuffers;
raidPtr->parityBufferPool.availBuffersIndex = 0;
raidPtr->parityBufferPool.emptyBuffersIndex = 0;
printf("Allocating %d bytes for parityBufferPool of %d units\n",
  419                (int) (raidPtr->parityBufferPool.totalBuffers *
  420                       sizeof(caddr_t)),
raidPtr->parityBufferPool.totalBuffers);
RF_Malloc(raidPtr->parityBufferPool.buffers,
raidPtr->parityBufferPool.totalBuffers * sizeof(caddr_t),
  424                   (caddr_t *));
  425         if (raidPtr->parityBufferPool.buffers == NULL) {
rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
rf_cond_destroy(&raidPtr->parityBufferPool.cond);
  428                 return (ENOMEM);
  429         }
  430         for (i = 0; i < raidPtr->parityBufferPool.totalBuffers; i++) {
printf("Allocating %d bytes for parityBufferPool#%d\n",
  432                        (int) (raidPtr->parityBufferPool.bufferSize *
  433                               sizeof(char)), i);
RF_Malloc(raidPtr->parityBufferPool.buffers[i],
raidPtr->parityBufferPool.bufferSize * sizeof(char),
  436                           (caddr_t));
  437                 if (raidPtr->parityBufferPool.buffers == NULL) {
rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
rf_cond_destroy(&raidPtr->parityBufferPool.cond);
  440                         for (j = 0; j < i; j++) {
RF_Free(raidPtr->parityBufferPool.buffers[i],
raidPtr->regionBufferPool.bufferSize *
  443                                         sizeof(char));
  444                         }
RF_Free(raidPtr->parityBufferPool.buffers,
raidPtr->regionBufferPool.totalBuffers *
  447                                 sizeof(caddr_t));
  448                         return (ENOMEM);
  449                 }
printf("parityBufferPool.buffers[%d] = %lx\n", i,
  451                     (long) raidPtr->parityBufferPool.buffers[i]);
  452         }
rc = rf_ShutdownCreate(listp,
rf_ShutdownParityLoggingParityBufferPool,
raidPtr);
  456         if (rc) {
RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
  458                              " rc=%d\n", __FILE__, __LINE__, rc);
rf_ShutdownParityLoggingParityBufferPool(raidPtr);
  460                 return (rc);
  461         }
  462         /* Initialize parityLogDiskQueue. */
rc = rf_create_managed_mutex(listp,
  464                                      &raidPtr->parityLogDiskQueue.mutex);
  465         if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
  468                 return (rc);
  469         }
rc = rf_create_managed_cond(listp, &raidPtr->parityLogDiskQueue.cond);
  471         if (rc) {
RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
  474                 return (rc);
  475         }
raidPtr->parityLogDiskQueue.flushQueue = NULL;
raidPtr->parityLogDiskQueue.reintQueue = NULL;
raidPtr->parityLogDiskQueue.bufHead = NULL;
raidPtr->parityLogDiskQueue.bufTail = NULL;
raidPtr->parityLogDiskQueue.reintHead = NULL;
raidPtr->parityLogDiskQueue.reintTail = NULL;
raidPtr->parityLogDiskQueue.logBlockHead = NULL;
raidPtr->parityLogDiskQueue.logBlockTail = NULL;
raidPtr->parityLogDiskQueue.reintBlockHead = NULL;
raidPtr->parityLogDiskQueue.reintBlockTail = NULL;
raidPtr->parityLogDiskQueue.freeDataList = NULL;
raidPtr->parityLogDiskQueue.freeCommonList = NULL;
rc = rf_ShutdownCreate(listp,
rf_ShutdownParityLoggingDiskQueue,
raidPtr);
  492         if (rc) {
RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
  494                              " rc=%d\n", __FILE__, __LINE__, rc);
  495                 return (rc);
  496         }
  497         for (i = 0; i < rf_numParityRegions; i++) {
rc = rf_mutex_init(&raidPtr->regionInfo[i].mutex);
  499                 if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d"
  501                                      " rc=%d\n", __FILE__, __LINE__, rc);
  502                         for (j = 0; j < i; j++)
rf_FreeRegionInfo(raidPtr, j);
RF_Free(raidPtr->regionInfo,
  505                                 (rf_numParityRegions *
  506                                  sizeof(RF_RegionInfo_t)));
  507                         return (ENOMEM);
  508                 }
rc = rf_mutex_init(&raidPtr->regionInfo[i].reintMutex);
  510                 if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d"
  512                                      " rc=%d\n", __FILE__, __LINE__, rc);
rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
  514                         for (j = 0; j < i; j++)
rf_FreeRegionInfo(raidPtr, j);
RF_Free(raidPtr->regionInfo,
  517                                 (rf_numParityRegions *
  518                                  sizeof(RF_RegionInfo_t)));
  519                         return (ENOMEM);
  520                 }
raidPtr->regionInfo[i].reintInProgress = RF_FALSE;
raidPtr->regionInfo[i].regionStartAddr =
raidPtr->regionLogCapacity * i;
raidPtr->regionInfo[i].parityStartAddr =
raidPtr->regionParityRange * i;
  526                 if (i < rf_numParityRegions - 1) {
raidPtr->regionInfo[i].capacity =
raidPtr->regionLogCapacity;
raidPtr->regionInfo[i].numSectorsParity =
raidPtr->regionParityRange;
  531                 } else {
raidPtr->regionInfo[i].capacity = lastRegionCapacity;
raidPtr->regionInfo[i].numSectorsParity =
raidPtr->sectorsPerDisk -
raidPtr->regionParityRange * i;
  536                         if (raidPtr->regionInfo[i].numSectorsParity >
maxRegionParityRange)
maxRegionParityRange =
raidPtr->regionInfo[i].numSectorsParity;
  540                 }
raidPtr->regionInfo[i].diskCount = 0;
RF_ASSERT(raidPtr->regionInfo[i].capacity +
raidPtr->regionInfo[i].regionStartAddr <=
totalLogCapacity);
RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr +
raidPtr->regionInfo[i].numSectorsParity <=
raidPtr->sectorsPerDisk);
printf("Allocating %d bytes for region %d\n",
  549                        (int) (raidPtr->regionInfo[i].capacity *
  550                            sizeof(RF_DiskMap_t)), i);
RF_Malloc(raidPtr->regionInfo[i].diskMap,
  552                           (raidPtr->regionInfo[i].capacity *
  553                            sizeof(RF_DiskMap_t)),
  554                           (RF_DiskMap_t *));
  555                 if (raidPtr->regionInfo[i].diskMap == NULL) {
rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
rf_mutex_destroy(&raidPtr->regionInfo[i].reintMutex);
  558                         for (j = 0; j < i; j++)
rf_FreeRegionInfo(raidPtr, j);
RF_Free(raidPtr->regionInfo,
  561                                 (rf_numParityRegions *
  562                                  sizeof(RF_RegionInfo_t)));
  563                         return (ENOMEM);
  564                 }
raidPtr->regionInfo[i].loggingEnabled = RF_FALSE;
raidPtr->regionInfo[i].coreLog = NULL;
  567         }
rc = rf_ShutdownCreate(listp,
rf_ShutdownParityLoggingRegionInfo,
raidPtr);
  571         if (rc) {
RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
  573                              " rc=%d\n", __FILE__, __LINE__, rc);
rf_ShutdownParityLoggingRegionInfo(raidPtr);
  575                 return (rc);
  576         }
RF_ASSERT(raidPtr->parityLogDiskQueue.threadState == 0);
raidPtr->parityLogDiskQueue.threadState = RF_PLOG_CREATED;
rc = RF_CREATE_THREAD(raidPtr->pLogDiskThreadHandle,
rf_ParityLoggingDiskManager, raidPtr, "rf_log");
  581         if (rc) {
raidPtr->parityLogDiskQueue.threadState = 0;
RF_ERRORMSG3("Unable to create parity logging disk thread"
  584                              " file %s line %d rc=%d\n",
__FILE__, __LINE__, rc);
  586                 return (ENOMEM);
  587         }
  588         /* Wait for thread to start. */
RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
  590         while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_RUNNING)) {
RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
raidPtr->parityLogDiskQueue.mutex);
  593         }
RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
rc = rf_ShutdownCreate(listp, rf_ShutdownParityLogging, raidPtr);
  597         if (rc) {
RF_ERRORMSG1("Got rc=%d adding parity logging shutdown"
  599                              " event.\n", rc);
rf_ShutdownParityLogging(raidPtr);
  601                 return (rc);
  602         }
  603         if (rf_parityLogDebug) {
printf("\t\t\tsize of disk log in sectors: %d\n",
  605                        (int) totalLogCapacity);
printf("\t\t\ttotal number of parity regions is %d\n",
  607                        (int) rf_numParityRegions);
printf("\t\t\tnominal sectors of log per parity region is %d\n",
  609                        (int) raidPtr->regionLogCapacity);
printf("\t\t\tnominal region fragmentation is %d sectors\n",
  611                        (int) fragmentation);
printf("\t\t\ttotal number of parity logs is %d\n",
raidPtr->numParityLogs);
printf("\t\t\tparity log size is %d sectors\n",
raidPtr->numSectorsPerLog);
printf("\t\t\ttotal in-core log space is %d bytes\n",
  617                        (int) rf_totalInCoreLogCapacity);
  618         }
rf_EnableParityLogging(raidPtr);
  621         return (0);
  622 }
  625 void
rf_FreeRegionInfo(RF_Raid_t *raidPtr, RF_RegionId_t regionID)
  627 {
RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
RF_Free(raidPtr->regionInfo[regionID].diskMap,
  630                 (raidPtr->regionInfo[regionID].capacity *
  631                  sizeof(RF_DiskMap_t)));
  632         if (!rf_forceParityLogReint && raidPtr->regionInfo[regionID].coreLog) {
rf_ReleaseParityLogs(raidPtr,
raidPtr->regionInfo[regionID].coreLog);
raidPtr->regionInfo[regionID].coreLog = NULL;
  636         } else {
RF_ASSERT(raidPtr->regionInfo[regionID].coreLog == NULL);
RF_ASSERT(raidPtr->regionInfo[regionID].diskCount == 0);
  639         }
RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
rf_mutex_destroy(&raidPtr->regionInfo[regionID].mutex);
rf_mutex_destroy(&raidPtr->regionInfo[regionID].reintMutex);
  643 }
  646 void
rf_FreeParityLogQueue(RF_Raid_t *raidPtr, RF_ParityLogQueue_t *queue)
  648 {
RF_ParityLog_t *l1, *l2;
RF_LOCK_MUTEX(queue->mutex);
l1 = queue->parityLogs;
  653         while (l1) {
l2 = l1;
l1 = l2->next;
RF_Free(l2->records, (raidPtr->numSectorsPerLog *
  657                                       sizeof(RF_ParityLogRecord_t)));
RF_Free(l2, sizeof(RF_ParityLog_t));
  659         }
RF_UNLOCK_MUTEX(queue->mutex);
rf_mutex_destroy(&queue->mutex);
  662 }
  665 void
rf_FreeRegionBufferQueue(RF_RegionBufferQueue_t *queue)
  667 {
  668         int i;
RF_LOCK_MUTEX(queue->mutex);
  671         if (queue->availableBuffers != queue->totalBuffers) {
printf("Attempt to free region queue that is still in use !\n");
RF_ASSERT(0);
  674         }
  675         for (i = 0; i < queue->totalBuffers; i++)
RF_Free(queue->buffers[i], queue->bufferSize);
RF_Free(queue->buffers, queue->totalBuffers * sizeof(caddr_t));
RF_UNLOCK_MUTEX(queue->mutex);
rf_mutex_destroy(&queue->mutex);
  680 }
  683 void
rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t arg)
  685 {
RF_Raid_t *raidPtr;
RF_RegionId_t i;
raidPtr = (RF_Raid_t *) arg;
  690         if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLoggingRegionInfo\n",
raidPtr->raidid);
  693         }
  694         /* Free region information structs. */
  695         for (i = 0; i < rf_numParityRegions; i++)
rf_FreeRegionInfo(raidPtr, i);
RF_Free(raidPtr->regionInfo, (rf_numParityRegions *
  698                                       sizeof(raidPtr->regionInfo)));
raidPtr->regionInfo = NULL;
  700 }
  703 void
rf_ShutdownParityLoggingPool(RF_ThreadArg_t arg)
  705 {
RF_Raid_t *raidPtr;
raidPtr = (RF_Raid_t *) arg;
  709         if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLoggingPool\n", raidPtr->raidid);
  711         }
  712         /* Free contents of parityLogPool. */
rf_FreeParityLogQueue(raidPtr, &raidPtr->parityLogPool);
RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
  716 }
  719 void
rf_ShutdownParityLoggingRegionBufferPool(RF_ThreadArg_t arg)
  721 {
RF_Raid_t *raidPtr;
raidPtr = (RF_Raid_t *) arg;
  725         if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLoggingRegionBufferPool\n",
raidPtr->raidid);
  728         }
rf_FreeRegionBufferQueue(&raidPtr->regionBufferPool);
  730 }
  733 void
rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t arg)
  735 {
RF_Raid_t *raidPtr;
raidPtr = (RF_Raid_t *) arg;
  739         if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLoggingParityBufferPool\n",
raidPtr->raidid);
  742         }
rf_FreeRegionBufferQueue(&raidPtr->parityBufferPool);
  744 }
  747 void
rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t arg)
  749 {
RF_ParityLogData_t *d;
RF_CommonLogData_t *c;
RF_Raid_t *raidPtr;
raidPtr = (RF_Raid_t *) arg;
  755         if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLoggingDiskQueue\n",
raidPtr->raidid);
  758         }
  759         /* Free disk manager stuff. */
RF_ASSERT(raidPtr->parityLogDiskQueue.bufHead == NULL);
RF_ASSERT(raidPtr->parityLogDiskQueue.bufTail == NULL);
RF_ASSERT(raidPtr->parityLogDiskQueue.reintHead == NULL);
RF_ASSERT(raidPtr->parityLogDiskQueue.reintTail == NULL);
  764         while (raidPtr->parityLogDiskQueue.freeDataList) {
d = raidPtr->parityLogDiskQueue.freeDataList;
raidPtr->parityLogDiskQueue.freeDataList =
raidPtr->parityLogDiskQueue.freeDataList->next;
RF_Free(d, sizeof(RF_ParityLogData_t));
  769         }
  770         while (raidPtr->parityLogDiskQueue.freeCommonList) {
c = raidPtr->parityLogDiskQueue.freeCommonList;
rf_mutex_destroy(&c->mutex);
raidPtr->parityLogDiskQueue.freeCommonList =
raidPtr->parityLogDiskQueue.freeCommonList->next;
RF_Free(c, sizeof(RF_CommonLogData_t));
  776         }
  777 }
  780 void
rf_ShutdownParityLogging(RF_ThreadArg_t arg)
  782 {
RF_Raid_t *raidPtr;
raidPtr = (RF_Raid_t *) arg;
  786         if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLogging\n", raidPtr->raidid);
  788         }
  789         /* Shutdown disk thread. */
  790         /*
  791          * This has the desirable side-effect of forcing all regions to be
  792          * reintegrated. This is necessary since all parity log maps are
  793          * currently held in volatile memory.
  794          */
RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_TERMINATE;
RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
  800         /*
  801          * pLogDiskThread will now terminate when queues are cleared.
  802          * Now wait for it to be done.
  803          */
RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
  805         while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_SHUTDOWN)) {
RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
raidPtr->parityLogDiskQueue.mutex);
  808         }
RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
  810         if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLogging done"
  812                        " (thread completed)\n", raidPtr->raidid);
  813         }
  814 }
  817 int
rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t *raidPtr)
  819 {
  820         return (20);
  821 }
RF_HeadSepLimit_t
rf_GetDefaultHeadSepLimitParityLogging(RF_Raid_t *raidPtr)
  826 {
  827         return (10);
  828 }
  831 /* Return the region ID for a given RAID address. */
RF_RegionId_t
rf_MapRegionIDParityLogging(RF_Raid_t *raidPtr, RF_SectorNum_t address)
  834 {
RF_RegionId_t regionID;
  837         /* regionID = address / (raidPtr->regionParityRange *
  838          *     raidPtr->Layout.numDataCol); */
regionID = address / raidPtr->regionParityRange;
  840         if (regionID == rf_numParityRegions) {
  841                 /* Last region may be larger than other regions. */
regionID--;
  843         }
RF_ASSERT(address >= raidPtr->regionInfo[regionID].parityStartAddr);
RF_ASSERT(address < raidPtr->regionInfo[regionID].parityStartAddr +
raidPtr->regionInfo[regionID].numSectorsParity);
RF_ASSERT(regionID < rf_numParityRegions);
  848         return (regionID);
  849 }
  852 /* Given a logical RAID sector, determine physical disk address of data. */
  853 void
rf_MapSectorParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
  856 {
RF_StripeNum_t SUID = raidSector /
raidPtr->Layout.sectorsPerStripeUnit;
  859         *row = 0;
  860         /* *col = (SUID % (raidPtr->numCol -
  861          *     raidPtr->Layout.numParityLogCol)); */
  862         *col = SUID % raidPtr->Layout.numDataCol;
  863         *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr->Layout.sectorsPerStripeUnit +
  865             (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
  866 }
  869 /* Given a logical RAID sector, determine physical disk address of parity. */
  870 void
rf_MapParityParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
  873 {
RF_StripeNum_t SUID = raidSector /
raidPtr->Layout.sectorsPerStripeUnit;
  877         *row = 0;
  878         /* *col =
  879          *     raidPtr->Layout.numDataCol-(SUID / raidPtr->Layout.numDataCol) %
  880          *      (raidPtr->numCol - raidPtr->Layout.numParityLogCol); */
  881         *col = raidPtr->Layout.numDataCol;
  882         *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr->Layout.sectorsPerStripeUnit +
  884             (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
  885 }
  888 /*
  889  * Given a regionID and sector offset, determine the physical disk address
  890  * of the parity log.
  891  */
  892 void
rf_MapLogParityLogging(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
RF_SectorNum_t regionOffset, RF_RowCol_t *row, RF_RowCol_t *col,
RF_SectorNum_t *startSector)
  896 {
  897         *row = 0;
  898         *col = raidPtr->numCol - 1;
  899         *startSector =
raidPtr->regionInfo[regionID].regionStartAddr + regionOffset;
  901 }
  904 /*
  905  * Given a regionID, determine the physical disk address of the logged
  906  * parity for that region.
  907  */
  908 void
rf_MapRegionParity(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *startSector,
RF_SectorCount_t *numSector)
  912 {
  913         *row = 0;
  914         *col = raidPtr->numCol - 2;
  915         *startSector = raidPtr->regionInfo[regionID].parityStartAddr;
  916         *numSector = raidPtr->regionInfo[regionID].numSectorsParity;
  917 }
  920 /*
  921  * Given a logical RAID address, determine the participating disks in
  922  * the stripe.
  923  */
  924 void
rf_IdentifyStripeParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
RF_RowCol_t **diskids, RF_RowCol_t *outRow)
  927 {
RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
addr);
RF_ParityLoggingConfigInfo_t *info = (RF_ParityLoggingConfigInfo_t *)
raidPtr->Layout.layoutSpecificInfo;
  932         *outRow = 0;
  933         *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
  934 }
  937 void
rf_MapSIDToPSIDParityLogging(RF_RaidLayout_t *layoutPtr,
RF_StripeNum_t stripeID, RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
  940 {
  941         *which_ru = 0;
  942         *psID = stripeID;
  943 }
  946 /*
  947  * Select an algorithm for performing an access. Returns two pointers,
  948  * one to a function that will return information about the DAG, and
  949  * another to a function that will create the dag.
  950  */
  951 void
rf_ParityLoggingDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
RF_AccessStripeMap_t *asmp, RF_VoidFuncPtr *createFunc)
  954 {
RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
RF_PhysDiskAddr_t *failedPDA = NULL;
RF_RowCol_t frow, fcol;
RF_RowStatus_t rstat;
  959         int prior_recon;
RF_ASSERT(RF_IO_IS_R_OR_W(type));
  963         if (asmp->numDataFailed + asmp->numParityFailed > 1) {
RF_ERRORMSG("Multiple disks failed in a single group !"
  965                             "  Aborting I/O operation.\n");
  966                  /* *infoFunc = */ *createFunc = NULL;
  967                 return;
  968         } else
  969                 if (asmp->numDataFailed + asmp->numParityFailed == 1) {
  971                         /*
  972                          * If under recon & already reconstructed, redirect
  973                          * the access to the spare drive and eliminate the
  974                          * failure indication.
  975                          */
failedPDA = asmp->failedPDAs[0];
frow = failedPDA->row;
fcol = failedPDA->col;
rstat = raidPtr->status[failedPDA->row];
prior_recon = (rstat == rf_rs_reconfigured) ||
  981                             ((rstat == rf_rs_reconstructing) ?
rf_CheckRUReconstructed(raidPtr->reconControl[frow]
  983                               ->reconMap, failedPDA->startSector) : 0);
  984                         if (prior_recon) {
RF_RowCol_t or = failedPDA->row;
RF_RowCol_t oc = failedPDA->col;
RF_SectorNum_t oo = failedPDA->startSector;
  988                                 if (layoutPtr->map->flags &
RF_DISTRIBUTE_SPARE) {
  990                                         /* Redirect to dist spare space. */
  992                                         if (failedPDA == asmp->parityInfo) {
  994                                                 /* Parity has failed. */
  995                                                 (layoutPtr->map->MapParity)
  996                                                     (raidPtr,
failedPDA->raidAddress,
  998                                                      &failedPDA->row,
  999                                                      &failedPDA->col,
 1000                                                      &failedPDA->startSector,
RF_REMAP);
 1003                                                 if (asmp->parityInfo->next) {
 1004                                                         /*
 1005                                                          * Redir 2nd component,
 1006                                                          * if any.
 1007                                                          */
RF_PhysDiskAddr_t *p =
asmp->parityInfo->next;
RF_SectorNum_t SUoffs =
p->startSector %
layoutPtr->sectorsPerStripeUnit;
p->row = failedPDA->row;
p->col = failedPDA->col;
 1015                                                         /*
 1016                                                          * Cheating:
 1017                                                          * startSector is not
 1018                                                          * really a RAID
 1019                                                          * address.
 1020                                                          */
p->startSector =
rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
failedPDA->startSector) + SUoffs;
 1024                                                 }
 1025                                         } else
 1026                                                 if (asmp->parityInfo->next &&
failedPDA ==
asmp->parityInfo->next) {
 1029                                                         /*
 1030                                                          * Should not ever
 1031                                                          * happen.
 1032                                                          */
RF_ASSERT(0);
 1034                                                 } else {
 1035                                                         /* Data has failed. */
 1036                                                         (layoutPtr->map
 1037                                                          ->MapSector)
 1038                                                             (raidPtr,
failedPDA->raidAddress,
 1040                                                             &failedPDA->row,
 1041                                                             &failedPDA->col,
 1042                                                         &failedPDA->startSector,
RF_REMAP);
 1044                                                 }
 1046                                 } else {
 1047                                         /* Redirect to dedicated spare space. */
failedPDA->row =
raidPtr->Disks[frow][fcol].spareRow;
failedPDA->col =
raidPtr->Disks[frow][fcol].spareCol;
 1054                                         /*
 1055                                          * The parity may have two distinct
 1056                                          * components, both of which may need
 1057                                          * to be redirected.
 1058                                          */
 1059                                         if (asmp->parityInfo->next) {
 1060                                                 if (failedPDA ==
asmp->parityInfo) {
failedPDA->next->row =
failedPDA->row;
failedPDA->next->col =
failedPDA->col;
 1066                                                 } else {
 1067                                                         if (failedPDA ==
asmp->parityInfo
 1069                                                              ->next) {
 1070                                                                 /*
 1071                                                                  * Paranoid:
 1072                                                                  * Should never
 1073                                                                  * occur.
 1074                                                                  */
asmp->parityInfo
 1076                                                                 ->row =
failedPDA->row;
asmp->parityInfo
 1079                                                                 ->col =
failedPDA->col;
 1081                                                         }
 1082                                                 }
 1083                                         }
 1084                                 }
RF_ASSERT(failedPDA->col != -1);
 1088                                 if (rf_dagDebug || rf_mapDebug) {
printf("raid%d: Redirected type '%c'"
 1090                                                " r %d c %d o %ld -> r %d c %d"
 1091                                                " o %ld\n", raidPtr->raidid,
type, or, oc, (long) oo,
failedPDA->row, failedPDA->col,
 1094                                                (long) failedPDA->startSector);
 1095                                 }
asmp->numDataFailed = asmp->numParityFailed = 0;
 1097                         }
 1098                 }
 1099         if (type == RF_IO_TYPE_READ) {
 1101                 if (asmp->numDataFailed == 0)
 1102                         *createFunc =
 1103                             (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;
 1104                 else
 1105                         *createFunc =
 1106                             (RF_VoidFuncPtr) rf_CreateRaidFiveDegradedReadDAG;
 1108         } else {
 1111                 /*
 1112                  * If mirroring, always use large writes. If the access
 1113                  * requires two distinct parity updates, always do a small
 1114                  * write. If the stripe contains a failure but the access
 1115                  * does not, do a small write. The first conditional
 1116                  * (numStripeUnitsAccessed <= numDataCol/2) uses a
 1117                  * less-than-or-equal rather than just a less-than because
 1118                  * when G is 3 or 4, numDataCol/2 is 1, and I want
 1119                  * single-stripe-unit updates to use just one disk.
 1120                  */
 1121                 if ((asmp->numDataFailed + asmp->numParityFailed) == 0) {
 1122                         if (((asmp->numStripeUnitsAccessed <=
 1123                               (layoutPtr->numDataCol / 2)) &&
 1124                              (layoutPtr->numDataCol != 1)) ||
 1125                             (asmp->parityInfo->next != NULL) ||
rf_CheckStripeForFailures(raidPtr, asmp)) {
 1127                                 *createFunc = (RF_VoidFuncPtr)
rf_CreateParityLoggingSmallWriteDAG;
 1129                         } else
 1130                                 *createFunc = (RF_VoidFuncPtr)
rf_CreateParityLoggingLargeWriteDAG;
 1132                 } else
 1133                         if (asmp->numParityFailed == 1)
 1134                                 *createFunc = (RF_VoidFuncPtr)
rf_CreateNonRedundantWriteDAG;
 1136                         else
 1137                                 if (asmp->numStripeUnitsAccessed != 1 &&
failedPDA->numSector !=
layoutPtr->sectorsPerStripeUnit)
 1140                                         *createFunc = NULL;
 1141                                 else
 1142                                         *createFunc = (RF_VoidFuncPtr)
rf_CreateDegradedWriteDAG;
 1144         }
 1145 }
 1146 #endif  /* RF_INCLUDE_PARITYLOGGING > 0 */