1 /* $NetBSD: rf_revent.c,v 1.6 2000/01/07 03:56:14 oster Exp $ */ 2 /* 3 * Copyright (c) 1995 Carnegie-Mellon University. 4 * All rights reserved. 5 * 6 * Author: 7 * 8 * Permission to use, copy, modify and distribute this software and 9 * its documentation is hereby granted, provided that both the copyright 10 * notice and this permission notice appear in all copies of the 11 * software, derivative works or modified versions, and any portions 12 * thereof, and that both notices appear in supporting documentation. 13 * 14 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 15 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 16 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 17 * 18 * Carnegie Mellon requests users of this software to return to 19 * 20 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 21 * School of Computer Science 22 * Carnegie Mellon University 23 * Pittsburgh PA 15213-3890 24 * 25 * any improvements or extensions that they make and grant Carnegie the 26 * rights to redistribute these changes. 27 */ 28 /* 29 * revent.c -- reconstruction event handling code 30 */ 31 32 #include <sys/errno.h> 33 34 #include "rf_raid.h" 35 #include "rf_revent.h" 36 #include "rf_etimer.h" 37 #include "rf_general.h" 38 #include "rf_freelist.h" 39 #include "rf_desc.h" 40 #include "rf_shutdown.h" 41 42 static RF_FreeList_t *rf_revent_freelist; 43 #define RF_MAX_FREE_REVENT 128 44 #define RF_REVENT_INC 8 45 #define RF_REVENT_INITIAL 8 46 47 48 49 #include <sys/proc.h> 50 51 extern int hz; 52 53 #define DO_WAIT(_rc) tsleep(&(_rc)->eventQueue, PRIBIO, "raidframe eventq", 0) 54 55 #define DO_SIGNAL(_rc) wakeup(&(_rc)->eventQueue) 56 57 58 static void rf_ShutdownReconEvent(void *); 59 60 static RF_ReconEvent_t * 61 GetReconEventDesc(RF_RowCol_t row, RF_RowCol_t col, 62 void *arg, RF_Revent_t type); 63 64 static void rf_ShutdownReconEvent(ignored) 65 void *ignored; 66 { 67 RF_FREELIST_DESTROY(rf_revent_freelist, next, (RF_ReconEvent_t *)); 68 } 69 70 int 71 rf_ConfigureReconEvent(listp) 72 RF_ShutdownList_t **listp; 73 { 74 int rc; 75 76 RF_FREELIST_CREATE(rf_revent_freelist, RF_MAX_FREE_REVENT, 77 RF_REVENT_INC, sizeof(RF_ReconEvent_t)); 78 if (rf_revent_freelist == NULL) 79 return (ENOMEM); 80 rc = rf_ShutdownCreate(listp, rf_ShutdownReconEvent, NULL); 81 if (rc) { 82 RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__, 83 __LINE__, rc); 84 rf_ShutdownReconEvent(NULL); 85 return (rc); 86 } 87 RF_FREELIST_PRIME(rf_revent_freelist, RF_REVENT_INITIAL, next, 88 (RF_ReconEvent_t *)); 89 return (0); 90 } 91 /* returns the next reconstruction event, blocking the calling thread until 92 * one becomes available 93 */ 94 95 /* will now return null if it is blocked or will return an event if it is not */ 96 97 RF_ReconEvent_t * 98 rf_GetNextReconEvent(reconDesc, row, continueFunc, continueArg) 99 RF_RaidReconDesc_t *reconDesc; 100 RF_RowCol_t row; 101 void (*continueFunc) (void *); 102 void *continueArg; 103 { 104 RF_Raid_t *raidPtr = reconDesc->raidPtr; 105 RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row]; 106 RF_ReconEvent_t *event; 107 108 RF_ASSERT(row >= 0 && row <= raidPtr->numRow); 109 RF_LOCK_MUTEX(rctrl->eq_mutex); 110 RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0)); /* q null and count==0 111 * must be equivalent 112 * conditions */ 113 114 115 rctrl->continueFunc = continueFunc; 116 rctrl->continueArg = continueArg; 117 118 119 /* mpsleep timeout value: secs = timo_val/hz. 'ticks' here is defined as cycle-counter ticks, not softclock ticks */ 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 /* we are not pre-emptible in the kernel, but we don't want to run 125 * forever. If we run w/o blocking for more than MAX_RECON_EXEC_TICKS 126 * ticks of the cycle counter, delay for RECON_DELAY before 127 * continuing. this may murder us with context switches, so we may 128 * need to increase both the MAX...TICKS and the RECON_DELAY_MS. */ 129 if (reconDesc->reconExecTimerRunning) { 130 int status; 131 132 RF_ETIMER_STOP(reconDesc->recon_exec_timer); 133 RF_ETIMER_EVAL(reconDesc->recon_exec_timer); 134 reconDesc->reconExecTicks += RF_ETIMER_VAL_US(reconDesc->recon_exec_timer); 135 if (reconDesc->reconExecTicks > reconDesc->maxReconExecTicks) 136 reconDesc->maxReconExecTicks = reconDesc->reconExecTicks; 137 if (reconDesc->reconExecTicks >= MAX_RECON_EXEC_USECS) { 138 /* we've been running too long. delay for 139 * RECON_DELAY_MS */ 140 #if RF_RECON_STATS > 0 141 reconDesc->numReconExecDelays++; 142 #endif /* RF_RECON_STATS > 0 */ 143 status = tsleep(&reconDesc->reconExecTicks, PRIBIO, "recon delay", RECON_TIMO); 144 RF_ASSERT(status == EWOULDBLOCK); 145 reconDesc->reconExecTicks = 0; 146 } 147 } 148 while (!rctrl->eventQueue) { 149 #if RF_RECON_STATS > 0 150 reconDesc->numReconEventWaits++; 151 #endif /* RF_RECON_STATS > 0 */ 152 DO_WAIT(rctrl); 153 reconDesc->reconExecTicks = 0; /* we've just waited */ 154 } 155 156 reconDesc->reconExecTimerRunning = 1; 157 RF_ETIMER_START(reconDesc->recon_exec_timer); 158 159 event = rctrl->eventQueue; 160 rctrl->eventQueue = event->next; 161 event->next = NULL; 162 rctrl->eq_count--; 163 RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0)); /* q null and count==0 164 * must be equivalent 165 * conditions */ 166 RF_UNLOCK_MUTEX(rctrl->eq_mutex); 167 return (event); 168 } 169 /* enqueues a reconstruction event on the indicated queue */ 170 void 171 rf_CauseReconEvent(raidPtr, row, col, arg, type) 172 RF_Raid_t *raidPtr; 173 RF_RowCol_t row; 174 RF_RowCol_t col; 175 void *arg; 176 RF_Revent_t type; 177 { 178 RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row]; 179 RF_ReconEvent_t *event = GetReconEventDesc(row, col, arg, type); 180 181 if (type == RF_REVENT_BUFCLEAR) { 182 RF_ASSERT(col != rctrl->fcol); 183 } 184 RF_ASSERT(row >= 0 && row <= raidPtr->numRow && col >= 0 && col <= raidPtr->numCol); 185 RF_LOCK_MUTEX(rctrl->eq_mutex); 186 RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0)); /* q null and count==0 187 * must be equivalent 188 * conditions */ 189 event->next = rctrl->eventQueue; 190 rctrl->eventQueue = event; 191 rctrl->eq_count++; 192 RF_UNLOCK_MUTEX(rctrl->eq_mutex); 193 194 DO_SIGNAL(rctrl); 195 } 196 /* allocates and initializes a recon event descriptor */ 197 static RF_ReconEvent_t * 198 GetReconEventDesc(row, col, arg, type) 199 RF_RowCol_t row; 200 RF_RowCol_t col; 201 void *arg; 202 RF_Revent_t type; 203 { 204 RF_ReconEvent_t *t; 205 206 RF_FREELIST_GET(rf_revent_freelist, t, next, (RF_ReconEvent_t *)); 207 if (t == NULL) 208 return (NULL); 209 t->col = col; 210 t->arg = arg; 211 t->type = type; 212 return (t); 213 } 214 215 void 216 rf_FreeReconEventDesc(event) 217 RF_ReconEvent_t *event; 218 { 219 RF_FREELIST_FREE(rf_revent_freelist, event, next); 220 } 221