root/dev/raidframe/rf_revent.c

DEFINITIONS

1. rf_ShutdownReconEvent
2. rf_ConfigureReconEvent
3. rf_GetNextReconEvent
4. rf_CauseReconEvent
5. GetReconEventDesc
6. rf_FreeReconEventDesc

    1 /*      $OpenBSD: rf_revent.c,v 1.10 2002/12/16 07:01:05 tdeval Exp $   */
    2 /*      $NetBSD: rf_revent.c,v 1.7 2000/05/30 02:04:29 oster Exp $      */
    4 /*
    5  * Copyright (c) 1995 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Author:
    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  */
   31 /*
   32  * revent.c -- Reconstruction event handling code.
   33  */
   35 #include <sys/errno.h>
   37 #include "rf_raid.h"
   38 #include "rf_revent.h"
   39 #include "rf_etimer.h"
   40 #include "rf_general.h"
   41 #include "rf_freelist.h"
   42 #include "rf_desc.h"
   43 #include "rf_shutdown.h"
   45 static RF_FreeList_t *rf_revent_freelist;
   46 #define RF_MAX_FREE_REVENT      128
   47 #define RF_REVENT_INC             8
   48 #define RF_REVENT_INITIAL         8
   52 #include <sys/proc.h>
   53 #include <sys/kernel.h>
   55 #define DO_WAIT(_rc)                                                    \
tsleep(&(_rc)->eventQueue, PRIBIO, "RAIDframe eventq", 0)
   58 #define DO_SIGNAL(_rc)  wakeup(&(_rc)->eventQueue)
   61 void rf_ShutdownReconEvent(void *);
RF_ReconEvent_t *GetReconEventDesc(RF_RowCol_t, RF_RowCol_t, void *,
RF_Revent_t);
   66 void
rf_ShutdownReconEvent(void *ignored)
   68 {
RF_FREELIST_DESTROY(rf_revent_freelist, next, (RF_ReconEvent_t *));
   70 }
   72 int
rf_ConfigureReconEvent(RF_ShutdownList_t **listp)
   74 {
   75         int rc;
RF_FREELIST_CREATE(rf_revent_freelist, RF_MAX_FREE_REVENT,
RF_REVENT_INC, sizeof(RF_ReconEvent_t));
   79         if (rf_revent_freelist == NULL)
   80                 return (ENOMEM);
rc = rf_ShutdownCreate(listp, rf_ShutdownReconEvent, NULL);
   82         if (rc) {
RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
   84                     " rc=%d\n", __FILE__, __LINE__, rc);
rf_ShutdownReconEvent(NULL);
   86                 return (rc);
   87         }
RF_FREELIST_PRIME(rf_revent_freelist, RF_REVENT_INITIAL, next,
   89             (RF_ReconEvent_t *));
   90         return (0);
   91 }
   93 /*
   94  * Returns the next reconstruction event, blocking the calling thread
   95  * until one becomes available. Will now return null if it is blocked
   96  * or will return an event if it is not.
   97  */
RF_ReconEvent_t *
rf_GetNextReconEvent(RF_RaidReconDesc_t *reconDesc, RF_RowCol_t row,
  101     void (*continueFunc) (void *), void *continueArg)
  102 {
RF_Raid_t *raidPtr = reconDesc->raidPtr;
RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
RF_ReconEvent_t *event;
RF_ASSERT(row >= 0 && row <= raidPtr->numRow);
RF_LOCK_MUTEX(rctrl->eq_mutex);
  109         /* q NULL and count==0 must be equivalent conditions. */
RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
rctrl->continueFunc = continueFunc;
rctrl->continueArg = continueArg;
  115         /*
  116          * mpsleep timeout value: secs = timo_val/hz. 'ticks' here is
  117          * defined as cycle-counter ticks, not softclock ticks.
  118          */
  120 #define MAX_RECON_EXEC_USECS            (100 * 1000)    /* 100 ms */
  121 #define RECON_DELAY_MS                  25
  122 #define RECON_TIMO                      ((RECON_DELAY_MS * hz) / 1000)
  124         /*
  125          * We are not pre-emptible in the kernel, but we don't want to run
  126          * forever. If we run w/o blocking for more than MAX_RECON_EXEC_USECS
  127          * delay for RECON_DELAY_MS before continuing. This may murder us with
  128          * context switches, so we may need to increase both the
  129          * MAX...TICKS and the RECON_DELAY_MS.
  130          */
  131         if (reconDesc->reconExecTimerRunning) {
  132                 int status;
RF_ETIMER_STOP(reconDesc->recon_exec_timer);
RF_ETIMER_EVAL(reconDesc->recon_exec_timer);
reconDesc->reconExecTicks +=
RF_ETIMER_VAL_US(reconDesc->recon_exec_timer);
  138                 if (reconDesc->reconExecTicks > reconDesc->maxReconExecTicks)
reconDesc->maxReconExecTicks =
reconDesc->reconExecTicks;
  141                 if (reconDesc->reconExecTicks >= MAX_RECON_EXEC_USECS) {
  142                         /* We've been running too long - sleep. */
  143 #if RF_RECON_STATS > 0
reconDesc->numReconExecDelays++;
  145 #endif /* RF_RECON_STATS > 0 */
status = tsleep(&reconDesc->reconExecTicks,
PRIBIO, "recon delay", RECON_TIMO);
RF_ASSERT(status == EWOULDBLOCK);
reconDesc->reconExecTicks = 0;
  150                 }
  151         }
  152         while (!rctrl->eventQueue) {
  153 #if RF_RECON_STATS > 0
reconDesc->numReconEventWaits++;
  155 #endif                          /* RF_RECON_STATS > 0 */
DO_WAIT(rctrl);
reconDesc->reconExecTicks = 0;  /* We've just waited. */
  158         }
RF_ETIMER_START(reconDesc->recon_exec_timer);
reconDesc->reconExecTimerRunning = 1;
event = rctrl->eventQueue;
rctrl->eventQueue = event->next;
event->next = NULL;
rctrl->eq_count--;
  168         /* q NULL and count==0 must be equivalent conditions. */
RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
RF_UNLOCK_MUTEX(rctrl->eq_mutex);
  171         return (event);
  172 }
  174 /* Enqueues a reconstruction event on the indicated queue. */
  175 void
rf_CauseReconEvent(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
  177     void *arg, RF_Revent_t type)
  178 {
RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
RF_ReconEvent_t *event = GetReconEventDesc(row, col, arg, type);
  182         if (type == RF_REVENT_BUFCLEAR) {
RF_ASSERT(col != rctrl->fcol);
  184         }
RF_ASSERT(row >= 0 && row <= raidPtr->numRow && col >= 0 &&
col <= raidPtr->numCol);
RF_LOCK_MUTEX(rctrl->eq_mutex);
  188         /* q NULL and count==0 must be equivalent conditions. */
RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
event->next = rctrl->eventQueue;
rctrl->eventQueue = event;
rctrl->eq_count++;
RF_UNLOCK_MUTEX(rctrl->eq_mutex);
DO_SIGNAL(rctrl);
  196 }
  198 /* Allocates and initializes a recon event descriptor. */
RF_ReconEvent_t *
GetReconEventDesc(RF_RowCol_t row, RF_RowCol_t col, void *arg, RF_Revent_t type)
  201 {
RF_ReconEvent_t *t;
RF_FREELIST_GET(rf_revent_freelist, t, next, (RF_ReconEvent_t *));
  205         if (t == NULL)
  206                 return (NULL);
t->col = col;
t->arg = arg;
t->type = type;
  210         return (t);
  211 }
  213 void
rf_FreeReconEventDesc(RF_ReconEvent_t *event)
  215 {
RF_FREELIST_FREE(rf_revent_freelist, event, next);
  217 }