root/dev/raidframe/rf_driver.c

DEFINITIONS

1. rf_BootRaidframe
2. rf_UnbootRaidframe
3. rf_UnconfigureArray
4. rf_Shutdown
5. rf_Configure
6. rf_init_rad
7. rf_clean_rad
8. rf_ShutdownRDFreeList
9. rf_ConfigureRDFreeList
10. rf_AllocRaidAccDesc
11. rf_FreeRaidAccDesc
12. rf_DoAccess
13. rf_SetReconfiguredMode
14. rf_FailDisk
15. rf_SignalQuiescenceLock
16. rf_SuspendNewRequestsAndWait
17. rf_ResumeNewRequests
18. rf_set_debug_option
19. rf_ConfigureDebug
20. rf_InitThroughputStats
21. rf_StartThroughputStats
22. rf_StopThroughputStats
23. rf_PrintThroughputStats
24. rf_StartUserStats
25. rf_StopUserStats
26. rf_UpdateUserStats
27. rf_PrintUserStats

    1 /*      $OpenBSD: rf_driver.c,v 1.11 2002/12/16 07:01:03 tdeval Exp $   */
    2 /*      $NetBSD: rf_driver.c,v 1.37 2000/06/04 02:05:13 oster Exp $     */
    4 /*
    5  * Copyright (c) 1999 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Greg Oster
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *      This product includes software developed by the NetBSD
   22  *      Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * Copyright (c) 1995 Carnegie-Mellon University.
   42  * All rights reserved.
   43  *
   44  * Author:      Mark Holland, Khalil Amiri, Claudson Bornstein,
   45  *              William V. Courtright II, Robby Findler, Daniel Stodolsky,
   46  *              Rachad Youssef, Jim Zelenka
   47  *
   48  * Permission to use, copy, modify and distribute this software and
   49  * its documentation is hereby granted, provided that both the copyright
   50  * notice and this permission notice appear in all copies of the
   51  * software, derivative works or modified versions, and any portions
   52  * thereof, and that both notices appear in supporting documentation.
   53  *
   54  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   55  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   56  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   57  *
   58  * Carnegie Mellon requests users of this software to return to
   59  *
   60  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   61  *  School of Computer Science
   62  *  Carnegie Mellon University
   63  *  Pittsburgh PA 15213-3890
   64  *
   65  * any improvements or extensions that they make and grant Carnegie the
   66  * rights to redistribute these changes.
   67  */
   69 /*****************************************************************************
   70  *
   71  * rf_driver.c -- Main setup, teardown, and access routines for the RAID
   72  *                driver
   73  *
   74  * All routines are prefixed with rf_ (RAIDframe), to avoid conficts.
   75  *
   76  *****************************************************************************/
   78 #include <sys/types.h>
   79 #include <sys/param.h>
   80 #include <sys/systm.h>
   81 #include <sys/ioctl.h>
   82 #include <sys/fcntl.h>
   83 #ifdef  __NetBSD__
   84 #include <sys/vnode.h>
   85 #endif
   88 #include "rf_archs.h"
   89 #include "rf_threadstuff.h"
   92 #include <sys/errno.h>
   94 #include "rf_raid.h"
   95 #include "rf_dag.h"
   96 #include "rf_aselect.h"
   97 #include "rf_diskqueue.h"
   98 #include "rf_parityscan.h"
   99 #include "rf_alloclist.h"
  100 #include "rf_dagutils.h"
  101 #include "rf_utils.h"
  102 #include "rf_etimer.h"
  103 #include "rf_acctrace.h"
  104 #include "rf_configure.h"
  105 #include "rf_general.h"
  106 #include "rf_desc.h"
  107 #include "rf_states.h"
  108 #include "rf_freelist.h"
  109 #include "rf_decluster.h"
  110 #include "rf_map.h"
  111 #include "rf_revent.h"
  112 #include "rf_callback.h"
  113 #include "rf_engine.h"
  114 #include "rf_memchunk.h"
  115 #include "rf_mcpair.h"
  116 #include "rf_nwayxor.h"
  117 #include "rf_debugprint.h"
  118 #include "rf_copyback.h"
  119 #include "rf_driver.h"
  120 #include "rf_options.h"
  121 #include "rf_shutdown.h"
  122 #include "rf_kintf.h"
  124 #include <sys/buf.h>
  126 /* rad == RF_RaidAccessDesc_t */
  127 static RF_FreeList_t *rf_rad_freelist;
  128 #define RF_MAX_FREE_RAD         128
  129 #define RF_RAD_INC               16
  130 #define RF_RAD_INITIAL           32
  132 /* Debug variables. */
  133 char    rf_panicbuf[2048];      /*
  134                                  * A buffer to hold an error msg when we panic.
  135                                  */
  137 /* Main configuration routines. */
  138 static int raidframe_booted = 0;
  140 void rf_ConfigureDebug(RF_Config_t *);
  141 void rf_set_debug_option(char *, long);
  142 void rf_UnconfigureArray(void);
  143 int  rf_init_rad(RF_RaidAccessDesc_t *);
  144 void rf_clean_rad(RF_RaidAccessDesc_t *);
  145 void rf_ShutdownRDFreeList(void *);
  146 int  rf_ConfigureRDFreeList(RF_ShutdownList_t **);
RF_DECLARE_MUTEX(rf_printf_mutex);      /*
  149                                          * Debug only: Avoids interleaved
  150                                          * printfs by different stripes.
  151                                          */
  153 #define SIGNAL_QUIESCENT_COND(_raid_)   wakeup(&((_raid_)->accesses_suspended))
  154 #define WAIT_FOR_QUIESCENCE(_raid_)                                     \
tsleep(&((_raid_)->accesses_suspended), PRIBIO, "RAIDframe quiesce", 0);
  157 #define IO_BUF_ERR(bp, err)                                             \
  158 do {                                                                    \
bp->b_flags |= B_ERROR;                                         \
bp->b_resid = bp->b_bcount;                                     \
bp->b_error = err;                                              \
biodone(bp);                                                    \
  163 } while (0)
  165 static int configureCount = 0;  /* Number of active configurations. */
  166 static int isconfigged = 0;     /*
  167                                  * Is basic RAIDframe (non per-array)
  168                                  * stuff configured ?
  169                                  */
RF_DECLARE_STATIC_MUTEX(configureMutex);        /*
  171                                                  * Used to lock the
  172                                                  * configuration stuff.
  173                                                  */
  174 static RF_ShutdownList_t *globalShutdown;       /* Non array-specific stuff. */
  175 int  rf_ConfigureRDFreeList(RF_ShutdownList_t **);
  178 /* Called at system boot time. */
  179 int
rf_BootRaidframe(void)
  181 {
  182         int rc;
  184         if (raidframe_booted)
  185                 return (EBUSY);
raidframe_booted = 1;
rc = rf_mutex_init(&configureMutex);
  189         if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
__FILE__, __LINE__, rc);
RF_PANIC();
  193         }
configureCount = 0;
isconfigged = 0;
globalShutdown = NULL;
  197         return (0);
  198 }
  201 /*
  202  * This function is really just for debugging user-level stuff: It
  203  * frees up all memory, other RAIDframe resources that might otherwise
  204  * be kept around. This is used with systems like "sentinel" to detect
  205  * memory leaks.
  206  */
  207 int
rf_UnbootRaidframe(void)
  209 {
  210         int rc;
RF_LOCK_MUTEX(configureMutex);
  213         if (configureCount) {
RF_UNLOCK_MUTEX(configureMutex);
  215                 return (EBUSY);
  216         }
raidframe_booted = 0;
RF_UNLOCK_MUTEX(configureMutex);
rc = rf_mutex_destroy(&configureMutex);
  220         if (rc) {
RF_ERRORMSG3("Unable to destroy mutex file %s line %d"
  222                     " rc=%d.\n", __FILE__, __LINE__, rc);
RF_PANIC();
  224         }
  225         return (0);
  226 }
  229 /*
  230  * Called whenever an array is shutdown.
  231  */
  232 void
rf_UnconfigureArray(void)
  234 {
  235         int rc;
RF_LOCK_MUTEX(configureMutex);
  238         if (--configureCount == 0) {    /*
  239                                          * If no active configurations, shut
  240                                          * everything down.
  241                                          */
isconfigged = 0;
rc = rf_ShutdownList(&globalShutdown);
  245                 if (rc) {
RF_ERRORMSG1("RAIDFRAME: unable to do global shutdown,"
  247                             " rc=%d.\n", rc);
  248                 }
  250                 /*
  251                  * We must wait until now, because the AllocList module
  252                  * uses the DebugMem module.
  253                  */
  254                 if (rf_memDebug)
rf_print_unfreed();
  256         }
RF_UNLOCK_MUTEX(configureMutex);
  258 }
  261 /*
  262  * Called to shut down an array.
  263  */
  264 int
rf_Shutdown(RF_Raid_t *raidPtr)
  266 {
  267         if (!raidPtr->valid) {
RF_ERRORMSG("Attempt to shut down unconfigured RAIDframe"
  269                     " driver. Aborting shutdown.\n");
  270                 return (EINVAL);
  271         }
  272         /*
  273          * Wait for outstanding IOs to land.
  274          * As described in rf_raid.h, we use the rad_freelist lock
  275          * to protect the per-array info about outstanding descs,
  276          * since we need to do freelist locking anyway, and this
  277          * cuts down on the amount of serialization we've got going
  278          * on.
  279          */
RF_FREELIST_DO_LOCK(rf_rad_freelist);
  281         if (raidPtr->waitShutdown) {
RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
  283                 return (EBUSY);
  284         }
raidPtr->waitShutdown = 1;
  286         while (raidPtr->nAccOutstanding) {
RF_WAIT_COND(raidPtr->outstandingCond, RF_FREELIST_MUTEX_OF(rf_rad_freelist));
  288         }
RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
  291         /* Wait for any parity re-writes to stop... */
  292         while (raidPtr->parity_rewrite_in_progress) {
printf("Waiting for parity re-write to exit...\n");
tsleep(&raidPtr->parity_rewrite_in_progress, PRIBIO,
  295                        "rfprwshutdown", 0);
  296         }
raidPtr->valid = 0;
rf_update_component_labels(raidPtr, RF_FINAL_COMPONENT_UPDATE);
rf_UnconfigureVnodes(raidPtr);
rf_ShutdownList(&raidPtr->shutdownList);
rf_UnconfigureArray();
  308         return (0);
  309 }
  311 #define DO_INIT_CONFIGURE(f)                                            \
  312 do {                                                                    \
rc = f (&globalShutdown);                                       \
  314         if (rc) {                                                       \
RF_ERRORMSG2("RAIDFRAME: failed %s with %d.\n",         \
RF_STRING(f), rc);                                  \
rf_ShutdownList(&globalShutdown);                       \
configureCount--;                                       \
RF_UNLOCK_MUTEX(configureMutex);                        \
  320                 return(rc);                                             \
  321         }                                                               \
  322 } while (0)
  324 #define DO_RAID_FAIL()                                                  \
  325 do {                                                                    \
rf_UnconfigureVnodes(raidPtr);                                  \
rf_ShutdownList(&raidPtr->shutdownList);                        \
rf_UnconfigureArray();                                          \
  329 } while (0)
  331 #define DO_RAID_INIT_CONFIGURE(f)                                       \
  332 do {                                                                    \
rc = (f)(&raidPtr->shutdownList, raidPtr, cfgPtr);              \
  334         if (rc) {                                                       \
RF_ERRORMSG2("RAIDFRAME: failed %s with %d.\n",         \
RF_STRING(f), rc);                                  \
DO_RAID_FAIL();                                         \
  338                 return(rc);                                             \
  339         }                                                               \
  340 } while (0)
  342 #define DO_RAID_MUTEX(_m_)                                              \
  343 do {                                                                    \
rc = rf_create_managed_mutex(&raidPtr->shutdownList, (_m_));    \
  345         if (rc) {                                                       \
RF_ERRORMSG3("Unable to init mutex file %s line %d"     \
  347                     " rc=%d.\n", __FILE__, __LINE__, rc);               \
DO_RAID_FAIL();                                         \
  349                 return(rc);                                             \
  350         }                                                               \
  351 } while (0)
  353 #define DO_RAID_COND(_c_)                                               \
  354 do {                                                                    \
rc = rf_create_managed_cond(&raidPtr->shutdownList, (_c_));     \
  356         if (rc) {                                                       \
RF_ERRORMSG3("Unable to init cond file %s line %d"      \
  358                     " rc=%d.\n", __FILE__, __LINE__, rc);               \
DO_RAID_FAIL();                                         \
  360                 return(rc);                                             \
  361         }                                                               \
  362 } while (0)
  364 int
rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac)
  366 {
RF_RowCol_t row, col;
  368         int i, rc;
  370         /*
  371          * XXX This check can probably be removed now, since
  372          * RAIDFRAME_CONFIGURE now checks to make sure that the
  373          * RAID set is not already valid.
  374          */
  375         if (raidPtr->valid) {
RF_ERRORMSG("RAIDframe configuration not shut down."
  377                     " Aborting configure.\n");
  378                 return (EINVAL);
  379         }
RF_LOCK_MUTEX(configureMutex);
configureCount++;
  382         if (isconfigged == 0) {
rc = rf_create_managed_mutex(&globalShutdown, &rf_printf_mutex);
  384                 if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d"
  386                             " rc=%d.\n", __FILE__, __LINE__, rc);
rf_ShutdownList(&globalShutdown);
  388                         return (rc);
  389                 }
  390                 /* Initialize globals. */
  391 #ifdef  RAIDDEBUG
printf("RAIDFRAME: protectedSectors is %ld.\n",
rf_protectedSectors);
  394 #endif  /* RAIDDEBUG */
rf_clear_debug_print_buffer();
DO_INIT_CONFIGURE(rf_ConfigureAllocList);
  400                 /*
  401                  * Yes, this does make debugging general to the whole
  402                  * system instead of being array specific. Bummer, drag.
  403                  */
rf_ConfigureDebug(cfgPtr);
DO_INIT_CONFIGURE(rf_ConfigureDebugMem);
DO_INIT_CONFIGURE(rf_ConfigureAccessTrace);
DO_INIT_CONFIGURE(rf_ConfigureMapModule);
DO_INIT_CONFIGURE(rf_ConfigureReconEvent);
DO_INIT_CONFIGURE(rf_ConfigureCallback);
DO_INIT_CONFIGURE(rf_ConfigureMemChunk);
DO_INIT_CONFIGURE(rf_ConfigureRDFreeList);
DO_INIT_CONFIGURE(rf_ConfigureNWayXor);
DO_INIT_CONFIGURE(rf_ConfigureStripeLockFreeList);
DO_INIT_CONFIGURE(rf_ConfigureMCPair);
DO_INIT_CONFIGURE(rf_ConfigureDAGs);
DO_INIT_CONFIGURE(rf_ConfigureDAGFuncs);
DO_INIT_CONFIGURE(rf_ConfigureDebugPrint);
DO_INIT_CONFIGURE(rf_ConfigureReconstruction);
DO_INIT_CONFIGURE(rf_ConfigureCopyback);
DO_INIT_CONFIGURE(rf_ConfigureDiskQueueSystem);
isconfigged = 1;
  422         }
RF_UNLOCK_MUTEX(configureMutex);
DO_RAID_MUTEX(&raidPtr->mutex);
  426         /*
  427          * Set up the cleanup list. Do this after ConfigureDebug so that
  428          * value of memDebug will be set.
  429          */
rf_MakeAllocList(raidPtr->cleanupList);
  432         if (raidPtr->cleanupList == NULL) {
DO_RAID_FAIL();
  434                 return (ENOMEM);
  435         }
rc = rf_ShutdownCreate(&raidPtr->shutdownList,
  437             (void (*) (void *)) rf_FreeAllocList, raidPtr->cleanupList);
  438         if (rc) {
RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
  440                     " rc=%d.\n", __FILE__, __LINE__, rc);
DO_RAID_FAIL();
  442                 return (rc);
  443         }
raidPtr->numRow = cfgPtr->numRow;
raidPtr->numCol = cfgPtr->numCol;
raidPtr->numSpare = cfgPtr->numSpare;
  448         /*
  449          * XXX We don't even pretend to support more than one row in the
  450          * kernel...
  451          */
  452         if (raidPtr->numRow != 1) {
RF_ERRORMSG("Only one row supported in kernel.\n");
DO_RAID_FAIL();
  455                 return (EINVAL);
  456         }
RF_CallocAndAdd(raidPtr->status, raidPtr->numRow,
  458             sizeof(RF_RowStatus_t), (RF_RowStatus_t *), raidPtr->cleanupList);
  459         if (raidPtr->status == NULL) {
DO_RAID_FAIL();
  461                 return (ENOMEM);
  462         }
RF_CallocAndAdd(raidPtr->reconControl, raidPtr->numRow,
  464             sizeof(RF_ReconCtrl_t *), (RF_ReconCtrl_t **), raidPtr->cleanupList);
  465         if (raidPtr->reconControl == NULL) {
DO_RAID_FAIL();
  467                 return (ENOMEM);
  468         }
  469         for (i = 0; i < raidPtr->numRow; i++) {
raidPtr->status[i] = rf_rs_optimal;
raidPtr->reconControl[i] = NULL;
  472         }
DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine);
DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks);
DO_RAID_COND(&raidPtr->outstandingCond);
raidPtr->nAccOutstanding = 0;
raidPtr->waitShutdown = 0;
DO_RAID_MUTEX(&raidPtr->access_suspend_mutex);
DO_RAID_COND(&raidPtr->quiescent_cond);
DO_RAID_COND(&raidPtr->waitForReconCond);
DO_RAID_MUTEX(&raidPtr->recon_done_proc_mutex);
  489         if (ac != NULL) {
  490                 /*
  491                  * We have an AutoConfig structure... Don't do the
  492                  * normal disk configuration... call the auto config
  493                  * stuff.
  494                  */
rf_AutoConfigureDisks(raidPtr, cfgPtr, ac);
  496         } else {
DO_RAID_INIT_CONFIGURE(rf_ConfigureDisks);
DO_RAID_INIT_CONFIGURE(rf_ConfigureSpareDisks);
  499         }
  500         /*
  501          * Do this after ConfigureDisks & ConfigureSpareDisks to be sure
  502          * devno is set.
  503          */
DO_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueues);
DO_RAID_INIT_CONFIGURE(rf_ConfigureLayout);
DO_RAID_INIT_CONFIGURE(rf_ConfigurePSStatus);
  510         for (row = 0; row < raidPtr->numRow; row++) {
  511                 for (col = 0; col < raidPtr->numCol; col++) {
  512                         /*
  513                          * XXX Better distribution.
  514                          */
raidPtr->hist_diskreq[row][col] = 0;
  516                 }
  517         }
raidPtr->numNewFailures = 0;
raidPtr->copyback_in_progress = 0;
raidPtr->parity_rewrite_in_progress = 0;
raidPtr->recon_in_progress = 0;
raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs;
  525         /*
  526          * Autoconfigure and root_partition will actually get filled in
  527          * after the config is done.
  528          */
raidPtr->autoconfigure = 0;
raidPtr->root_partition = 0;
raidPtr->last_unit = raidPtr->raidid;
raidPtr->config_order = 0;
  534         if (rf_keepAccTotals) {
raidPtr->keep_acc_totals = 1;
  536         }
rf_StartUserStats(raidPtr);
raidPtr->valid = 1;
  540         return (0);
  541 }
  543 int
rf_init_rad(RF_RaidAccessDesc_t *desc)
  545 {
  546         int rc;
rc = rf_mutex_init(&desc->mutex);
  549         if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n", __FILE__,
__LINE__, rc);
  552                 return (rc);
  553         }
rc = rf_cond_init(&desc->cond);
  555         if (rc) {
RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d.\n", __FILE__,
__LINE__, rc);
rf_mutex_destroy(&desc->mutex);
  559                 return (rc);
  560         }
  561         return (0);
  562 }
  564 void
rf_clean_rad(RF_RaidAccessDesc_t *desc)
  566 {
rf_mutex_destroy(&desc->mutex);
rf_cond_destroy(&desc->cond);
  569 }
  571 void
rf_ShutdownRDFreeList(void *ignored)
  573 {
RF_FREELIST_DESTROY_CLEAN(rf_rad_freelist, next,
  575             (RF_RaidAccessDesc_t *), rf_clean_rad);
  576 }
  578 int
rf_ConfigureRDFreeList(RF_ShutdownList_t **listp)
  580 {
  581         int rc;
RF_FREELIST_CREATE(rf_rad_freelist, RF_MAX_FREE_RAD,
RF_RAD_INC, sizeof(RF_RaidAccessDesc_t));
  585         if (rf_rad_freelist == NULL) {
  586                 return (ENOMEM);
  587         }
rc = rf_ShutdownCreate(listp, rf_ShutdownRDFreeList, NULL);
  589         if (rc) {
RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d.\n", __FILE__,
__LINE__, rc);
rf_ShutdownRDFreeList(NULL);
  593                 return (rc);
  594         }
RF_FREELIST_PRIME_INIT(rf_rad_freelist, RF_RAD_INITIAL, next,
  596             (RF_RaidAccessDesc_t *), rf_init_rad);
  597         return (0);
  598 }
RF_RaidAccessDesc_t *
rf_AllocRaidAccDesc(
RF_Raid_t                    *raidPtr,
RF_IoType_t                   type,
RF_RaidAddr_t                 raidAddress,
RF_SectorCount_t              numBlocks,
caddr_t                       bufPtr,
  607     void                         *bp,
RF_DagHeader_t              **paramDAG,
RF_AccessStripeMapHeader_t  **paramASM,
RF_RaidAccessFlags_t          flags,
  611     void                        (*cbF) (struct buf *),
  612     void                         *cbA,
RF_AccessState_t             *states
  614 )
  615 {
RF_RaidAccessDesc_t *desc;
RF_FREELIST_GET_INIT_NOUNLOCK(rf_rad_freelist, desc, next,
  619             (RF_RaidAccessDesc_t *), rf_init_rad);
  620         if (raidPtr->waitShutdown) {
  621                 /*
  622                  * Actually, we're shutting the array down. Free the desc
  623                  * and return NULL.
  624                  */
RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
RF_FREELIST_FREE_CLEAN(rf_rad_freelist, desc, next,
rf_clean_rad);
  628                 return (NULL);
  629         }
raidPtr->nAccOutstanding++;
RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
desc->raidPtr = (void *) raidPtr;
desc->type = type;
desc->raidAddress = raidAddress;
desc->numBlocks = numBlocks;
desc->bufPtr = bufPtr;
desc->bp = bp;
desc->paramDAG = paramDAG;
desc->paramASM = paramASM;
desc->flags = flags;
desc->states = states;
desc->state = 0;
desc->status = 0;
bzero((char *) &desc->tracerec, sizeof(RF_AccTraceEntry_t));
desc->callbackFunc = (void (*) (RF_CBParam_t)) cbF;     /* XXX */
desc->callbackArg = cbA;
desc->next = NULL;
desc->head = desc;
desc->numPending = 0;
desc->cleanupList = NULL;
rf_MakeAllocList(desc->cleanupList);
  654         return (desc);
  655 }
  657 void
rf_FreeRaidAccDesc(RF_RaidAccessDesc_t * desc)
  659 {
RF_Raid_t *raidPtr = desc->raidPtr;
RF_ASSERT(desc);
rf_FreeAllocList(desc->cleanupList);
RF_FREELIST_FREE_CLEAN_NOUNLOCK(rf_rad_freelist, desc, next, rf_clean_rad);
raidPtr->nAccOutstanding--;
  667         if (raidPtr->waitShutdown) {
RF_SIGNAL_COND(raidPtr->outstandingCond);
  669         }
RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
  671 }
  674 /********************************************************************
  675  * Main routine for performing an access.
  676  * Accesses are retried until a DAG can not be selected. This occurs
  677  * when either the DAG library is incomplete or there are too many
  678  * failures in a parity group.
  679  ********************************************************************/
  680 int
rf_DoAccess(
RF_Raid_t                    *raidPtr,
RF_IoType_t                   type,         /* Should be read or write. */
  684     int                           async_flag,   /*
  685                                                  * Should be RF_TRUE
  686                                                  * or RF_FALSE.
  687                                                  */
RF_RaidAddr_t                 raidAddress,
RF_SectorCount_t              numBlocks,
caddr_t                       bufPtr,
  691     void                         *bp_in,        /*
  692                                                  * It's a buf pointer.
  693                                                  * void * to facilitate
  694                                                  * ignoring it outside
  695                                                  * the kernel.
  696                                                  */
RF_DagHeader_t              **paramDAG,
RF_AccessStripeMapHeader_t  **paramASM,
RF_RaidAccessFlags_t          flags,
RF_RaidAccessDesc_t         **paramDesc,
  701     void                        (*cbF) (struct buf *),
  702     void                         *cbA
  703 )
  704 {
RF_RaidAccessDesc_t *desc;
caddr_t lbufPtr = bufPtr;
  707         struct buf *bp = (struct buf *) bp_in;
raidAddress += rf_raidSectorOffset;
  711         if (!raidPtr->valid) {
RF_ERRORMSG("RAIDframe driver not successfully configured."
  713                     " Rejecting access.\n");
IO_BUF_ERR(bp, EINVAL);
  715                 return (EINVAL);
  716         }
  718         if (rf_accessDebug) {
printf("logBytes is: %d %d %d.\n", raidPtr->raidid,
raidPtr->logBytesPerSector,
  722                     (int) rf_RaidAddressToByte(raidPtr, numBlocks));
printf("raid%d: %s raidAddr %d (stripeid %d-%d) numBlocks %d (%d bytes) buf 0x%lx.\n", raidPtr->raidid,
  724                     (type == RF_IO_TYPE_READ) ? "READ" : "WRITE", (int) raidAddress,
  725                     (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress),
  726                     (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress + numBlocks - 1),
  727                     (int) numBlocks,
  728                     (int) rf_RaidAddressToByte(raidPtr, numBlocks),
  729                     (long) bufPtr);
  730         }
  731         if (raidAddress + numBlocks > raidPtr->totalSectors) {
printf("DoAccess: raid addr %lu too large to access %lu sectors. Max legal addr is %lu.\n",
  734                     (u_long) raidAddress, (u_long) numBlocks, (u_long) raidPtr->totalSectors);
IO_BUF_ERR(bp, ENOSPC);
  737                         return (ENOSPC);
  738         }
desc = rf_AllocRaidAccDesc(raidPtr, type, raidAddress,
numBlocks, lbufPtr, bp, paramDAG, paramASM,
flags, cbF, cbA, raidPtr->Layout.map->states);
  743         if (desc == NULL) {
  744                 return (ENOMEM);
  745         }
RF_ETIMER_START(desc->tracerec.tot_timer);
desc->async_flag = async_flag;
rf_ContinueRaidAccess(desc);
  752         return (0);
  753 }
  756 /* Force the array into reconfigured mode without doing reconstruction. */
  757 int
rf_SetReconfiguredMode(RF_Raid_t *raidPtr, int row, int col)
  759 {
  760         if (!(raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
printf("Can't set reconfigured mode in dedicated-spare"
  762                     " array.\n");
RF_PANIC();
  764         }
RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr->numFailures++;
raidPtr->Disks[row][col].status = rf_ds_dist_spared;
raidPtr->status[row] = rf_rs_reconfigured;
rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
  770         /*
  771          * Install spare table only if declustering + distributed sparing
  772          * architecture.
  773          */
  774         if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED)
rf_InstallSpareTable(raidPtr, row, col);
RF_UNLOCK_MUTEX(raidPtr->mutex);
  777         return (0);
  778 }
  780 extern int fail_row, fail_col, fail_time;
  781 extern int delayed_recon;
  783 int
rf_FailDisk(RF_Raid_t *raidPtr, int frow, int fcol, int initRecon)
  785 {
printf("raid%d: Failing disk r%d c%d.\n", raidPtr->raidid, frow, fcol);
RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr->numFailures++;
raidPtr->Disks[frow][fcol].status = rf_ds_failed;
raidPtr->status[frow] = rf_rs_degraded;
rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
RF_UNLOCK_MUTEX(raidPtr->mutex);
  793         if (initRecon)
rf_ReconstructFailedDisk(raidPtr, frow, fcol);
  795         return (0);
  796 }
  799 /*
  800  * Releases a thread that is waiting for the array to become quiesced.
  801  * access_suspend_mutex should be locked upon calling this.
  802  */
  803 void
rf_SignalQuiescenceLock(RF_Raid_t *raidPtr, RF_RaidReconDesc_t *reconDesc)
  805 {
  806         if (rf_quiesceDebug) {
printf("raid%d: Signalling quiescence lock.\n",
raidPtr->raidid);
  809         }
raidPtr->access_suspend_release = 1;
  812         if (raidPtr->waiting_for_quiescence) {
SIGNAL_QUIESCENT_COND(raidPtr);
  814         }
  815 }
  818 /*
  819  * Suspends all new requests to the array. No effect on accesses that are
  820  * in flight.
  821  */
  822 int
rf_SuspendNewRequestsAndWait(RF_Raid_t *raidPtr)
  824 {
  825         if (rf_quiesceDebug)
printf("Suspending new reqs.\n");
RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr->accesses_suspended++;
raidPtr->waiting_for_quiescence = (raidPtr->accs_in_flight == 0) ? 0 : 1;
  832         if (raidPtr->waiting_for_quiescence) {
raidPtr->access_suspend_release = 0;
  834                 while (!raidPtr->access_suspend_release) {
printf("Suspending: Waiting for Quiescence.\n");
WAIT_FOR_QUIESCENCE(raidPtr);
raidPtr->waiting_for_quiescence = 0;
  838                 }
  839         }
printf("Quiescence reached...\n");
RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
  843         return (raidPtr->waiting_for_quiescence);
  844 }
  847 /* Wake up everyone waiting for quiescence to be released. */
  848 void
rf_ResumeNewRequests(RF_Raid_t *raidPtr)
  850 {
RF_CallbackDesc_t *t, *cb;
  853         if (rf_quiesceDebug)
printf("Resuming new reqs.\n");
RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr->accesses_suspended--;
  858         if (raidPtr->accesses_suspended == 0)
cb = raidPtr->quiesce_wait_list;
  860         else
cb = NULL;
raidPtr->quiesce_wait_list = NULL;
RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
  865         while (cb) {
t = cb;
cb = cb->next;
  868                 (t->callbackFunc) (t->callbackArg);
rf_FreeCallbackDesc(t);
  870         }
  871 }
  874 /*****************************************************************************
  875  *
  876  * Debug routines.
  877  *
  878  *****************************************************************************/
  880 void
rf_set_debug_option(char *name, long val)
  882 {
RF_DebugName_t *p;
  885         for (p = rf_debugNames; p->name; p++) {
  886                 if (!strcmp(p->name, name)) {
  887                         *(p->ptr) = val;
printf("[Set debug variable %s to %ld]\n", name, val);
  889                         return;
  890                 }
  891         }
RF_ERRORMSG1("Unknown debug string \"%s\"\n", name);
  893 }
  896 /* Would like to use sscanf here, but apparently not available in kernel. */
  897 /*ARGSUSED*/
  898 void
rf_ConfigureDebug(RF_Config_t *cfgPtr)
  900 {
  901         char *val_p, *name_p, *white_p;
  902         long val;
  903         int i;
rf_ResetDebugOptions();
  906         for (i = 0; cfgPtr->debugVars[i][0] && i < RF_MAXDBGV; i++) {
name_p = rf_find_non_white(&cfgPtr->debugVars[i][0]);
white_p = rf_find_white(name_p);        /*
  909                                                          * Skip to start of 2nd
  910                                                          * word.
  911                                                          */
val_p = rf_find_non_white(white_p);
  913                 if (*val_p == '0' && *(val_p + 1) == 'x')
val = rf_htoi(val_p + 2);
  915                 else
val = rf_atoi(val_p);
  917                 *white_p = '\0';
rf_set_debug_option(name_p, val);
  919         }
  920 }
  923 /* Performance monitoring stuff. */
  925 #if     !defined(_KERNEL) && !defined(SIMULATE)
  927 /*
  928  * Throughput stats currently only used in user-level RAIDframe.
  929  */
  931 int
  932 rf_InitThroughputStats(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
RF_Config_t *cfgPtr)
  934 {
  935         int rc;
  937         /* These used by user-level RAIDframe only. */
rc = rf_create_managed_mutex(listp, &raidPtr->throughputstats.mutex);
  939         if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
__FILE__, __LINE__, rc);
  942                 return (rc);
  943         }
raidPtr->throughputstats.sum_io_us = 0;
raidPtr->throughputstats.num_ios = 0;
raidPtr->throughputstats.num_out_ios = 0;
  947         return (0);
  948 }
  950 void
rf_StartThroughputStats(RF_Raid_t *raidPtr)
  952 {
RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
raidPtr->throughputstats.num_ios++;
raidPtr->throughputstats.num_out_ios++;
  956         if (raidPtr->throughputstats.num_out_ios == 1)
RF_GETTIME(raidPtr->throughputstats.start);
RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
  959 }
  961 void
  962 rf_StopThroughputStats(RF_Raid_t *raidPtr)
  963 {
  964         struct timeval diff;
RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
raidPtr->throughputstats.num_out_ios--;
  968         if (raidPtr->throughputstats.num_out_ios == 0) {
RF_GETTIME(raidPtr->throughputstats.stop);
RF_TIMEVAL_DIFF(&raidPtr->throughputstats.start,
  971                     &raidPtr->throughputstats.stop, &diff);
raidPtr->throughputstats.sum_io_us += RF_TIMEVAL_TO_US(diff);
  973         }
RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
  975 }
  977 void
  978 rf_PrintThroughputStats(RF_Raid_t *raidPtr)
  979 {
RF_ASSERT(raidPtr->throughputstats.num_out_ios == 0);
  981         if (raidPtr->throughputstats.sum_io_us != 0) {
printf("[Througphut: %8.2f IOs/second]\n",
raidPtr->throughputstats.num_ios /
  984                     (raidPtr->throughputstats.sum_io_us / 1000000.0));
  985         }
  986 }
  988 #endif  /* !_KERNEL && !SIMULATE */
  990 void
rf_StartUserStats(RF_Raid_t *raidPtr)
  992 {
RF_GETTIME(raidPtr->userstats.start);
raidPtr->userstats.sum_io_us = 0;
raidPtr->userstats.num_ios = 0;
raidPtr->userstats.num_sect_moved = 0;
  997 }
  999 void
rf_StopUserStats(RF_Raid_t *raidPtr)
 1001 {
RF_GETTIME(raidPtr->userstats.stop);
 1003 }
 1005 void
rf_UpdateUserStats(
RF_Raid_t   *raidPtr,
 1008     int          rt,            /* Response time in us. */
 1009     int          numsect        /* Number of sectors for this access. */
 1010 )
 1011 {
raidPtr->userstats.sum_io_us += rt;
raidPtr->userstats.num_ios++;
raidPtr->userstats.num_sect_moved += numsect;
 1015 }
 1017 void
rf_PrintUserStats(RF_Raid_t *raidPtr)
 1019 {
 1020         long    elapsed_us, mbs, mbs_frac;
 1021         struct timeval diff;
RF_TIMEVAL_DIFF(&raidPtr->userstats.start, &raidPtr->userstats.stop,
 1024             &diff);
elapsed_us = RF_TIMEVAL_TO_US(diff);
 1027         /* 2000 sectors per megabyte, 10000000 microseconds per second. */
 1028         if (elapsed_us)
mbs = (raidPtr->userstats.num_sect_moved / 2000) /
 1030                     (elapsed_us / 1000000);
 1031         else
mbs = 0;
 1034         /* This computes only the first digit of the fractional mb/s moved. */
 1035         if (elapsed_us) {
mbs_frac = ((raidPtr->userstats.num_sect_moved / 200) /
 1037                     (elapsed_us / 1000000)) - (mbs * 10);
 1038         } else {
mbs_frac = 0;
 1040         }
printf("Number of I/Os:             %ld\n",
raidPtr->userstats.num_ios);
printf("Elapsed time (us):          %ld\n",
elapsed_us);
printf("User I/Os per second:       %ld\n",
RF_DB0_CHECK(raidPtr->userstats.num_ios, (elapsed_us / 1000000)));
printf("Average user response time: %ld us\n",
RF_DB0_CHECK(raidPtr->userstats.sum_io_us,
raidPtr->userstats.num_ios));
printf("Total sectors moved:        %ld\n",
raidPtr->userstats.num_sect_moved);
printf("Average access size (sect): %ld\n",
RF_DB0_CHECK(raidPtr->userstats.num_sect_moved,
raidPtr->userstats.num_ios));
printf("Achieved data rate:         %ld.%ld MB/sec\n",
mbs, mbs_frac);
 1058 }