Annotation of sys/dev/raidframe/rf_revent.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 3:
! 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: */
! 30:
! 31: /*
! 32: * revent.c -- Reconstruction event handling code.
! 33: */
! 34:
! 35: #include <sys/errno.h>
! 36:
! 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"
! 44:
! 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
! 49:
! 50:
! 51:
! 52: #include <sys/proc.h>
! 53: #include <sys/kernel.h>
! 54:
! 55: #define DO_WAIT(_rc) \
! 56: tsleep(&(_rc)->eventQueue, PRIBIO, "RAIDframe eventq", 0)
! 57:
! 58: #define DO_SIGNAL(_rc) wakeup(&(_rc)->eventQueue)
! 59:
! 60:
! 61: void rf_ShutdownReconEvent(void *);
! 62:
! 63: RF_ReconEvent_t *GetReconEventDesc(RF_RowCol_t, RF_RowCol_t, void *,
! 64: RF_Revent_t);
! 65:
! 66: void
! 67: rf_ShutdownReconEvent(void *ignored)
! 68: {
! 69: RF_FREELIST_DESTROY(rf_revent_freelist, next, (RF_ReconEvent_t *));
! 70: }
! 71:
! 72: int
! 73: rf_ConfigureReconEvent(RF_ShutdownList_t **listp)
! 74: {
! 75: int rc;
! 76:
! 77: RF_FREELIST_CREATE(rf_revent_freelist, RF_MAX_FREE_REVENT,
! 78: RF_REVENT_INC, sizeof(RF_ReconEvent_t));
! 79: if (rf_revent_freelist == NULL)
! 80: return (ENOMEM);
! 81: rc = rf_ShutdownCreate(listp, rf_ShutdownReconEvent, NULL);
! 82: if (rc) {
! 83: RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
! 84: " rc=%d\n", __FILE__, __LINE__, rc);
! 85: rf_ShutdownReconEvent(NULL);
! 86: return (rc);
! 87: }
! 88: RF_FREELIST_PRIME(rf_revent_freelist, RF_REVENT_INITIAL, next,
! 89: (RF_ReconEvent_t *));
! 90: return (0);
! 91: }
! 92:
! 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: */
! 98:
! 99: RF_ReconEvent_t *
! 100: rf_GetNextReconEvent(RF_RaidReconDesc_t *reconDesc, RF_RowCol_t row,
! 101: void (*continueFunc) (void *), void *continueArg)
! 102: {
! 103: RF_Raid_t *raidPtr = reconDesc->raidPtr;
! 104: RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
! 105: RF_ReconEvent_t *event;
! 106:
! 107: RF_ASSERT(row >= 0 && row <= raidPtr->numRow);
! 108: RF_LOCK_MUTEX(rctrl->eq_mutex);
! 109: /* q NULL and count==0 must be equivalent conditions. */
! 110: RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
! 111:
! 112: rctrl->continueFunc = continueFunc;
! 113: rctrl->continueArg = continueArg;
! 114:
! 115: /*
! 116: * mpsleep timeout value: secs = timo_val/hz. 'ticks' here is
! 117: * defined as cycle-counter ticks, not softclock ticks.
! 118: */
! 119:
! 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)
! 123:
! 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;
! 133:
! 134: RF_ETIMER_STOP(reconDesc->recon_exec_timer);
! 135: RF_ETIMER_EVAL(reconDesc->recon_exec_timer);
! 136: reconDesc->reconExecTicks +=
! 137: RF_ETIMER_VAL_US(reconDesc->recon_exec_timer);
! 138: if (reconDesc->reconExecTicks > reconDesc->maxReconExecTicks)
! 139: reconDesc->maxReconExecTicks =
! 140: reconDesc->reconExecTicks;
! 141: if (reconDesc->reconExecTicks >= MAX_RECON_EXEC_USECS) {
! 142: /* We've been running too long - sleep. */
! 143: #if RF_RECON_STATS > 0
! 144: reconDesc->numReconExecDelays++;
! 145: #endif /* RF_RECON_STATS > 0 */
! 146: status = tsleep(&reconDesc->reconExecTicks,
! 147: PRIBIO, "recon delay", RECON_TIMO);
! 148: RF_ASSERT(status == EWOULDBLOCK);
! 149: reconDesc->reconExecTicks = 0;
! 150: }
! 151: }
! 152: while (!rctrl->eventQueue) {
! 153: #if RF_RECON_STATS > 0
! 154: reconDesc->numReconEventWaits++;
! 155: #endif /* RF_RECON_STATS > 0 */
! 156: DO_WAIT(rctrl);
! 157: reconDesc->reconExecTicks = 0; /* We've just waited. */
! 158: }
! 159:
! 160: RF_ETIMER_START(reconDesc->recon_exec_timer);
! 161: reconDesc->reconExecTimerRunning = 1;
! 162:
! 163: event = rctrl->eventQueue;
! 164: rctrl->eventQueue = event->next;
! 165: event->next = NULL;
! 166: rctrl->eq_count--;
! 167:
! 168: /* q NULL and count==0 must be equivalent conditions. */
! 169: RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
! 170: RF_UNLOCK_MUTEX(rctrl->eq_mutex);
! 171: return (event);
! 172: }
! 173:
! 174: /* Enqueues a reconstruction event on the indicated queue. */
! 175: void
! 176: rf_CauseReconEvent(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
! 177: void *arg, RF_Revent_t type)
! 178: {
! 179: RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
! 180: RF_ReconEvent_t *event = GetReconEventDesc(row, col, arg, type);
! 181:
! 182: if (type == RF_REVENT_BUFCLEAR) {
! 183: RF_ASSERT(col != rctrl->fcol);
! 184: }
! 185: RF_ASSERT(row >= 0 && row <= raidPtr->numRow && col >= 0 &&
! 186: col <= raidPtr->numCol);
! 187: RF_LOCK_MUTEX(rctrl->eq_mutex);
! 188: /* q NULL and count==0 must be equivalent conditions. */
! 189: RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
! 190: event->next = rctrl->eventQueue;
! 191: rctrl->eventQueue = event;
! 192: rctrl->eq_count++;
! 193: RF_UNLOCK_MUTEX(rctrl->eq_mutex);
! 194:
! 195: DO_SIGNAL(rctrl);
! 196: }
! 197:
! 198: /* Allocates and initializes a recon event descriptor. */
! 199: RF_ReconEvent_t *
! 200: GetReconEventDesc(RF_RowCol_t row, RF_RowCol_t col, void *arg, RF_Revent_t type)
! 201: {
! 202: RF_ReconEvent_t *t;
! 203:
! 204: RF_FREELIST_GET(rf_revent_freelist, t, next, (RF_ReconEvent_t *));
! 205: if (t == NULL)
! 206: return (NULL);
! 207: t->col = col;
! 208: t->arg = arg;
! 209: t->type = type;
! 210: return (t);
! 211: }
! 212:
! 213: void
! 214: rf_FreeReconEventDesc(RF_ReconEvent_t *event)
! 215: {
! 216: RF_FREELIST_FREE(rf_revent_freelist, event, next);
! 217: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_revent.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe