rf_reconstruct.c revision 1.58 1 1.58 oster /* $NetBSD: rf_reconstruct.c,v 1.58 2003/12/29 03:33:48 oster Exp $ */
2 1.1 oster /*
3 1.1 oster * Copyright (c) 1995 Carnegie-Mellon University.
4 1.1 oster * All rights reserved.
5 1.1 oster *
6 1.1 oster * Author: Mark Holland
7 1.1 oster *
8 1.1 oster * Permission to use, copy, modify and distribute this software and
9 1.1 oster * its documentation is hereby granted, provided that both the copyright
10 1.1 oster * notice and this permission notice appear in all copies of the
11 1.1 oster * software, derivative works or modified versions, and any portions
12 1.1 oster * thereof, and that both notices appear in supporting documentation.
13 1.1 oster *
14 1.1 oster * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15 1.1 oster * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
16 1.1 oster * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17 1.1 oster *
18 1.1 oster * Carnegie Mellon requests users of this software to return to
19 1.1 oster *
20 1.1 oster * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU
21 1.1 oster * School of Computer Science
22 1.1 oster * Carnegie Mellon University
23 1.1 oster * Pittsburgh PA 15213-3890
24 1.1 oster *
25 1.1 oster * any improvements or extensions that they make and grant Carnegie the
26 1.1 oster * rights to redistribute these changes.
27 1.1 oster */
28 1.1 oster
29 1.1 oster /************************************************************
30 1.1 oster *
31 1.1 oster * rf_reconstruct.c -- code to perform on-line reconstruction
32 1.1 oster *
33 1.1 oster ************************************************************/
34 1.31 lukem
35 1.31 lukem #include <sys/cdefs.h>
36 1.58 oster __KERNEL_RCSID(0, "$NetBSD: rf_reconstruct.c,v 1.58 2003/12/29 03:33:48 oster Exp $");
37 1.1 oster
38 1.1 oster #include <sys/time.h>
39 1.1 oster #include <sys/buf.h>
40 1.1 oster #include <sys/errno.h>
41 1.5 oster
42 1.5 oster #include <sys/param.h>
43 1.5 oster #include <sys/systm.h>
44 1.5 oster #include <sys/proc.h>
45 1.5 oster #include <sys/ioctl.h>
46 1.5 oster #include <sys/fcntl.h>
47 1.5 oster #include <sys/vnode.h>
48 1.30 oster #include <dev/raidframe/raidframevar.h>
49 1.5 oster
50 1.1 oster #include "rf_raid.h"
51 1.1 oster #include "rf_reconutil.h"
52 1.1 oster #include "rf_revent.h"
53 1.1 oster #include "rf_reconbuffer.h"
54 1.1 oster #include "rf_acctrace.h"
55 1.1 oster #include "rf_etimer.h"
56 1.1 oster #include "rf_dag.h"
57 1.1 oster #include "rf_desc.h"
58 1.36 oster #include "rf_debugprint.h"
59 1.1 oster #include "rf_general.h"
60 1.1 oster #include "rf_driver.h"
61 1.1 oster #include "rf_utils.h"
62 1.1 oster #include "rf_shutdown.h"
63 1.1 oster
64 1.1 oster #include "rf_kintf.h"
65 1.1 oster
66 1.1 oster /* setting these to -1 causes them to be set to their default values if not set by debug options */
67 1.1 oster
68 1.41 oster #if RF_DEBUG_RECON
69 1.1 oster #define Dprintf(s) if (rf_reconDebug) rf_debug_printf(s,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)
70 1.1 oster #define Dprintf1(s,a) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
71 1.1 oster #define Dprintf2(s,a,b) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
72 1.1 oster #define Dprintf3(s,a,b,c) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL)
73 1.1 oster #define Dprintf4(s,a,b,c,d) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),NULL,NULL,NULL,NULL)
74 1.1 oster #define Dprintf5(s,a,b,c,d,e) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),NULL,NULL,NULL)
75 1.1 oster #define Dprintf6(s,a,b,c,d,e,f) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),NULL,NULL)
76 1.1 oster #define Dprintf7(s,a,b,c,d,e,f,g) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),(void *)((unsigned long)g),NULL)
77 1.1 oster
78 1.1 oster #define DDprintf1(s,a) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
79 1.1 oster #define DDprintf2(s,a,b) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
80 1.33 oster
81 1.41 oster #else /* RF_DEBUG_RECON */
82 1.33 oster
83 1.33 oster #define Dprintf(s) {}
84 1.33 oster #define Dprintf1(s,a) {}
85 1.33 oster #define Dprintf2(s,a,b) {}
86 1.33 oster #define Dprintf3(s,a,b,c) {}
87 1.33 oster #define Dprintf4(s,a,b,c,d) {}
88 1.33 oster #define Dprintf5(s,a,b,c,d,e) {}
89 1.33 oster #define Dprintf6(s,a,b,c,d,e,f) {}
90 1.33 oster #define Dprintf7(s,a,b,c,d,e,f,g) {}
91 1.33 oster
92 1.33 oster #define DDprintf1(s,a) {}
93 1.33 oster #define DDprintf2(s,a,b) {}
94 1.33 oster
95 1.41 oster #endif /* RF_DEBUG_RECON */
96 1.33 oster
97 1.1 oster
98 1.58 oster static struct pool rf_recond_pool;
99 1.1 oster #define RF_MAX_FREE_RECOND 4
100 1.1 oster #define RF_RECOND_INC 1
101 1.1 oster
102 1.4 oster static RF_RaidReconDesc_t *
103 1.4 oster AllocRaidReconDesc(RF_Raid_t * raidPtr,
104 1.57 oster RF_RowCol_t col, RF_RaidDisk_t * spareDiskPtr,
105 1.57 oster int numDisksDone, RF_RowCol_t scol);
106 1.4 oster static void FreeReconDesc(RF_RaidReconDesc_t * reconDesc);
107 1.4 oster static int
108 1.57 oster ProcessReconEvent(RF_Raid_t * raidPtr, RF_ReconEvent_t * event);
109 1.4 oster static int
110 1.57 oster IssueNextReadRequest(RF_Raid_t * raidPtr, RF_RowCol_t col);
111 1.57 oster static int TryToRead(RF_Raid_t * raidPtr, RF_RowCol_t col);
112 1.4 oster static int
113 1.4 oster ComputePSDiskOffsets(RF_Raid_t * raidPtr, RF_StripeNum_t psid,
114 1.57 oster RF_RowCol_t col, RF_SectorNum_t * outDiskOffset,
115 1.57 oster RF_SectorNum_t * outFailedDiskSectorOffset,
116 1.4 oster RF_RowCol_t * spCol, RF_SectorNum_t * spOffset);
117 1.57 oster static int IssueNextWriteRequest(RF_Raid_t * raidPtr);
118 1.1 oster static int ReconReadDoneProc(void *arg, int status);
119 1.1 oster static int ReconWriteDoneProc(void *arg, int status);
120 1.4 oster static void
121 1.57 oster CheckForNewMinHeadSep(RF_Raid_t * raidPtr, RF_HeadSepLimit_t hsCtr);
122 1.4 oster static int
123 1.4 oster CheckHeadSeparation(RF_Raid_t * raidPtr, RF_PerDiskReconCtrl_t * ctrl,
124 1.57 oster RF_RowCol_t col, RF_HeadSepLimit_t hsCtr,
125 1.4 oster RF_ReconUnitNum_t which_ru);
126 1.4 oster static int
127 1.4 oster CheckForcedOrBlockedReconstruction(RF_Raid_t * raidPtr,
128 1.4 oster RF_ReconParityStripeStatus_t * pssPtr, RF_PerDiskReconCtrl_t * ctrl,
129 1.57 oster RF_RowCol_t col, RF_StripeNum_t psid,
130 1.4 oster RF_ReconUnitNum_t which_ru);
131 1.1 oster static void ForceReconReadDoneProc(void *arg, int status);
132 1.1 oster
133 1.1 oster static void rf_ShutdownReconstruction(void *);
134 1.1 oster
135 1.1 oster struct RF_ReconDoneProc_s {
136 1.4 oster void (*proc) (RF_Raid_t *, void *);
137 1.4 oster void *arg;
138 1.4 oster RF_ReconDoneProc_t *next;
139 1.1 oster };
140 1.1 oster
141 1.4 oster static void
142 1.4 oster SignalReconDone(RF_Raid_t * raidPtr)
143 1.1 oster {
144 1.4 oster RF_ReconDoneProc_t *p;
145 1.1 oster
146 1.4 oster RF_LOCK_MUTEX(raidPtr->recon_done_proc_mutex);
147 1.4 oster for (p = raidPtr->recon_done_procs; p; p = p->next) {
148 1.4 oster p->proc(raidPtr, p->arg);
149 1.4 oster }
150 1.4 oster RF_UNLOCK_MUTEX(raidPtr->recon_done_proc_mutex);
151 1.1 oster }
152 1.1 oster
153 1.13 oster /**************************************************************************
154 1.1 oster *
155 1.1 oster * sets up the parameters that will be used by the reconstruction process
156 1.1 oster * currently there are none, except for those that the layout-specific
157 1.1 oster * configuration (e.g. rf_ConfigureDeclustered) routine sets up.
158 1.1 oster *
159 1.1 oster * in the kernel, we fire off the recon thread.
160 1.1 oster *
161 1.13 oster **************************************************************************/
162 1.4 oster static void
163 1.4 oster rf_ShutdownReconstruction(ignored)
164 1.4 oster void *ignored;
165 1.4 oster {
166 1.58 oster pool_destroy(&rf_recond_pool);
167 1.4 oster }
168 1.4 oster
169 1.4 oster int
170 1.4 oster rf_ConfigureReconstruction(listp)
171 1.4 oster RF_ShutdownList_t **listp;
172 1.4 oster {
173 1.4 oster int rc;
174 1.4 oster
175 1.58 oster pool_init(&rf_recond_pool, sizeof(RF_RaidReconDesc_t), 0, 0, 0,
176 1.58 oster "rf_recond_pl", NULL);
177 1.4 oster rc = rf_ShutdownCreate(listp, rf_ShutdownReconstruction, NULL);
178 1.4 oster if (rc) {
179 1.36 oster rf_print_unable_to_add_shutdown(__FILE__, __LINE__, rc);
180 1.4 oster rf_ShutdownReconstruction(NULL);
181 1.4 oster return (rc);
182 1.4 oster }
183 1.4 oster return (0);
184 1.4 oster }
185 1.4 oster
186 1.4 oster static RF_RaidReconDesc_t *
187 1.57 oster AllocRaidReconDesc(raidPtr, col, spareDiskPtr, numDisksDone, scol)
188 1.4 oster RF_Raid_t *raidPtr;
189 1.4 oster RF_RowCol_t col;
190 1.4 oster RF_RaidDisk_t *spareDiskPtr;
191 1.4 oster int numDisksDone;
192 1.4 oster RF_RowCol_t scol;
193 1.1 oster {
194 1.1 oster
195 1.4 oster RF_RaidReconDesc_t *reconDesc;
196 1.4 oster
197 1.58 oster reconDesc = pool_get(&rf_recond_pool, PR_WAITOK); /* XXX WAITOK?? */
198 1.4 oster
199 1.4 oster reconDesc->raidPtr = raidPtr;
200 1.4 oster reconDesc->col = col;
201 1.4 oster reconDesc->spareDiskPtr = spareDiskPtr;
202 1.4 oster reconDesc->numDisksDone = numDisksDone;
203 1.4 oster reconDesc->scol = scol;
204 1.4 oster reconDesc->state = 0;
205 1.4 oster reconDesc->next = NULL;
206 1.1 oster
207 1.4 oster return (reconDesc);
208 1.1 oster }
209 1.1 oster
210 1.4 oster static void
211 1.4 oster FreeReconDesc(reconDesc)
212 1.4 oster RF_RaidReconDesc_t *reconDesc;
213 1.1 oster {
214 1.1 oster #if RF_RECON_STATS > 0
215 1.50 oster printf("raid%d: %lu recon event waits, %lu recon delays\n",
216 1.50 oster reconDesc->raidPtr->raidid,
217 1.50 oster (long) reconDesc->numReconEventWaits,
218 1.50 oster (long) reconDesc->numReconExecDelays);
219 1.4 oster #endif /* RF_RECON_STATS > 0 */
220 1.50 oster printf("raid%d: %lu max exec ticks\n",
221 1.50 oster reconDesc->raidPtr->raidid,
222 1.50 oster (long) reconDesc->maxReconExecTicks);
223 1.1 oster #if (RF_RECON_STATS > 0) || defined(KERNEL)
224 1.4 oster printf("\n");
225 1.4 oster #endif /* (RF_RECON_STATS > 0) || KERNEL */
226 1.58 oster pool_put(&rf_recond_pool, reconDesc);
227 1.1 oster }
228 1.1 oster
229 1.1 oster
230 1.13 oster /*****************************************************************************
231 1.1 oster *
232 1.1 oster * primary routine to reconstruct a failed disk. This should be called from
233 1.1 oster * within its own thread. It won't return until reconstruction completes,
234 1.1 oster * fails, or is aborted.
235 1.13 oster *****************************************************************************/
236 1.4 oster int
237 1.57 oster rf_ReconstructFailedDisk(raidPtr, col)
238 1.4 oster RF_Raid_t *raidPtr;
239 1.4 oster RF_RowCol_t col;
240 1.4 oster {
241 1.52 jdolecek const RF_LayoutSW_t *lp;
242 1.4 oster int rc;
243 1.4 oster
244 1.4 oster lp = raidPtr->Layout.map;
245 1.4 oster if (lp->SubmitReconBuffer) {
246 1.4 oster /*
247 1.4 oster * The current infrastructure only supports reconstructing one
248 1.4 oster * disk at a time for each array.
249 1.4 oster */
250 1.4 oster RF_LOCK_MUTEX(raidPtr->mutex);
251 1.4 oster while (raidPtr->reconInProgress) {
252 1.4 oster RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex);
253 1.4 oster }
254 1.4 oster raidPtr->reconInProgress++;
255 1.4 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
256 1.57 oster rc = rf_ReconstructFailedDiskBasic(raidPtr, col);
257 1.6 oster RF_LOCK_MUTEX(raidPtr->mutex);
258 1.6 oster raidPtr->reconInProgress--;
259 1.6 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
260 1.4 oster } else {
261 1.4 oster RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n",
262 1.4 oster lp->parityConfig);
263 1.4 oster rc = EIO;
264 1.4 oster }
265 1.4 oster RF_SIGNAL_COND(raidPtr->waitForReconCond);
266 1.4 oster return (rc);
267 1.4 oster }
268 1.4 oster
269 1.4 oster int
270 1.57 oster rf_ReconstructFailedDiskBasic(raidPtr, col)
271 1.4 oster RF_Raid_t *raidPtr;
272 1.4 oster RF_RowCol_t col;
273 1.4 oster {
274 1.5 oster RF_ComponentLabel_t c_label;
275 1.4 oster RF_RaidDisk_t *spareDiskPtr = NULL;
276 1.4 oster RF_RaidReconDesc_t *reconDesc;
277 1.57 oster RF_RowCol_t scol;
278 1.4 oster int numDisksDone = 0, rc;
279 1.4 oster
280 1.4 oster /* first look for a spare drive onto which to reconstruct the data */
281 1.4 oster /* spare disk descriptors are stored in row 0. This may have to
282 1.4 oster * change eventually */
283 1.4 oster
284 1.4 oster RF_LOCK_MUTEX(raidPtr->mutex);
285 1.57 oster RF_ASSERT(raidPtr->Disks[col].status == rf_ds_failed);
286 1.4 oster
287 1.4 oster if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
288 1.57 oster if (raidPtr->status != rf_rs_degraded) {
289 1.57 oster RF_ERRORMSG1("Unable to reconstruct disk at col %d because status not degraded\n", col);
290 1.4 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
291 1.4 oster return (EINVAL);
292 1.4 oster }
293 1.4 oster scol = (-1);
294 1.4 oster } else {
295 1.4 oster for (scol = raidPtr->numCol; scol < raidPtr->numCol + raidPtr->numSpare; scol++) {
296 1.57 oster if (raidPtr->Disks[scol].status == rf_ds_spare) {
297 1.57 oster spareDiskPtr = &raidPtr->Disks[scol];
298 1.4 oster spareDiskPtr->status = rf_ds_used_spare;
299 1.4 oster break;
300 1.4 oster }
301 1.4 oster }
302 1.4 oster if (!spareDiskPtr) {
303 1.57 oster RF_ERRORMSG1("Unable to reconstruct disk at col %d because no spares are available\n", col);
304 1.4 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
305 1.4 oster return (ENOSPC);
306 1.4 oster }
307 1.57 oster printf("RECON: initiating reconstruction on col %d -> spare at col %d\n", col, scol);
308 1.4 oster }
309 1.4 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
310 1.1 oster
311 1.57 oster reconDesc = AllocRaidReconDesc((void *) raidPtr, col, spareDiskPtr, numDisksDone, scol);
312 1.4 oster raidPtr->reconDesc = (void *) reconDesc;
313 1.1 oster #if RF_RECON_STATS > 0
314 1.4 oster reconDesc->hsStallCount = 0;
315 1.4 oster reconDesc->numReconExecDelays = 0;
316 1.4 oster reconDesc->numReconEventWaits = 0;
317 1.4 oster #endif /* RF_RECON_STATS > 0 */
318 1.4 oster reconDesc->reconExecTimerRunning = 0;
319 1.4 oster reconDesc->reconExecTicks = 0;
320 1.4 oster reconDesc->maxReconExecTicks = 0;
321 1.4 oster rc = rf_ContinueReconstructFailedDisk(reconDesc);
322 1.5 oster
323 1.5 oster if (!rc) {
324 1.5 oster /* fix up the component label */
325 1.5 oster /* Don't actually need the read here.. */
326 1.5 oster raidread_component_label(
327 1.57 oster raidPtr->raid_cinfo[scol].ci_dev,
328 1.57 oster raidPtr->raid_cinfo[scol].ci_vp,
329 1.5 oster &c_label);
330 1.5 oster
331 1.15 oster raid_init_component_label( raidPtr, &c_label);
332 1.57 oster c_label.row = 0;
333 1.5 oster c_label.column = col;
334 1.5 oster c_label.clean = RF_RAID_DIRTY;
335 1.5 oster c_label.status = rf_ds_optimal;
336 1.57 oster c_label.partitionSize = raidPtr->Disks[scol].partitionSize;
337 1.15 oster
338 1.28 oster /* We've just done a rebuild based on all the other
339 1.28 oster disks, so at this point the parity is known to be
340 1.28 oster clean, even if it wasn't before. */
341 1.28 oster
342 1.28 oster /* XXX doesn't hold for RAID 6!!*/
343 1.28 oster
344 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
345 1.28 oster raidPtr->parity_good = RF_RAID_CLEAN;
346 1.48 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
347 1.28 oster
348 1.15 oster /* XXXX MORE NEEDED HERE */
349 1.5 oster
350 1.5 oster raidwrite_component_label(
351 1.57 oster raidPtr->raid_cinfo[scol].ci_dev,
352 1.57 oster raidPtr->raid_cinfo[scol].ci_vp,
353 1.5 oster &c_label);
354 1.5 oster
355 1.49 oster
356 1.49 oster rf_update_component_labels(raidPtr,
357 1.49 oster RF_NORMAL_COMPONENT_UPDATE);
358 1.49 oster
359 1.5 oster }
360 1.5 oster return (rc);
361 1.5 oster }
362 1.5 oster
363 1.5 oster /*
364 1.5 oster
365 1.5 oster Allow reconstructing a disk in-place -- i.e. component /dev/sd2e goes AWOL,
366 1.5 oster and you don't get a spare until the next Monday. With this function
367 1.5 oster (and hot-swappable drives) you can now put your new disk containing
368 1.5 oster /dev/sd2e on the bus, scsictl it alive, and then use raidctl(8) to
369 1.5 oster rebuild the data "on the spot".
370 1.5 oster
371 1.5 oster */
372 1.5 oster
373 1.5 oster int
374 1.57 oster rf_ReconstructInPlace(raidPtr, col)
375 1.5 oster RF_Raid_t *raidPtr;
376 1.5 oster RF_RowCol_t col;
377 1.5 oster {
378 1.5 oster RF_RaidDisk_t *spareDiskPtr = NULL;
379 1.5 oster RF_RaidReconDesc_t *reconDesc;
380 1.52 jdolecek const RF_LayoutSW_t *lp;
381 1.5 oster RF_ComponentLabel_t c_label;
382 1.5 oster int numDisksDone = 0, rc;
383 1.5 oster struct partinfo dpart;
384 1.5 oster struct vnode *vp;
385 1.5 oster struct vattr va;
386 1.56 fvdl struct proc *proc;
387 1.5 oster int retcode;
388 1.21 oster int ac;
389 1.5 oster
390 1.5 oster lp = raidPtr->Layout.map;
391 1.5 oster if (lp->SubmitReconBuffer) {
392 1.5 oster /*
393 1.5 oster * The current infrastructure only supports reconstructing one
394 1.5 oster * disk at a time for each array.
395 1.5 oster */
396 1.5 oster RF_LOCK_MUTEX(raidPtr->mutex);
397 1.5 oster
398 1.57 oster if (raidPtr->Disks[col].status != rf_ds_failed) {
399 1.5 oster /* "It's gone..." */
400 1.5 oster raidPtr->numFailures++;
401 1.57 oster raidPtr->Disks[col].status = rf_ds_failed;
402 1.57 oster raidPtr->status = rf_rs_degraded;
403 1.48 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
404 1.26 oster rf_update_component_labels(raidPtr,
405 1.26 oster RF_NORMAL_COMPONENT_UPDATE);
406 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
407 1.5 oster }
408 1.5 oster
409 1.5 oster while (raidPtr->reconInProgress) {
410 1.5 oster RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex);
411 1.5 oster }
412 1.5 oster
413 1.6 oster raidPtr->reconInProgress++;
414 1.6 oster
415 1.5 oster
416 1.5 oster /* first look for a spare drive onto which to reconstruct
417 1.5 oster the data. spare disk descriptors are stored in row 0.
418 1.5 oster This may have to change eventually */
419 1.5 oster
420 1.5 oster /* Actually, we don't care if it's failed or not...
421 1.5 oster On a RAID set with correct parity, this function
422 1.5 oster should be callable on any component without ill affects. */
423 1.57 oster /* RF_ASSERT(raidPtr->Disks[col].status == rf_ds_failed);
424 1.5 oster */
425 1.5 oster
426 1.5 oster if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
427 1.57 oster RF_ERRORMSG1("Unable to reconstruct to disk at col %d: operation not supported for RF_DISTRIBUTE_SPARE\n", col);
428 1.5 oster
429 1.6 oster raidPtr->reconInProgress--;
430 1.5 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
431 1.5 oster return (EINVAL);
432 1.5 oster }
433 1.5 oster
434 1.56 fvdl proc = raidPtr->engine_thread;
435 1.5 oster
436 1.5 oster /* This device may have been opened successfully the
437 1.5 oster first time. Close it before trying to open it again.. */
438 1.5 oster
439 1.57 oster if (raidPtr->raid_cinfo[col].ci_vp != NULL) {
440 1.37 oster #if 0
441 1.5 oster printf("Closed the open device: %s\n",
442 1.57 oster raidPtr->Disks[col].devname);
443 1.37 oster #endif
444 1.57 oster vp = raidPtr->raid_cinfo[col].ci_vp;
445 1.57 oster ac = raidPtr->Disks[col].auto_configured;
446 1.48 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
447 1.21 oster rf_close_component(raidPtr, vp, ac);
448 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
449 1.57 oster raidPtr->raid_cinfo[col].ci_vp = NULL;
450 1.5 oster }
451 1.20 oster /* note that this disk was *not* auto_configured (any longer)*/
452 1.57 oster raidPtr->Disks[col].auto_configured = 0;
453 1.20 oster
454 1.37 oster #if 0
455 1.5 oster printf("About to (re-)open the device for rebuilding: %s\n",
456 1.57 oster raidPtr->Disks[col].devname);
457 1.37 oster #endif
458 1.48 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
459 1.57 oster retcode = raidlookup(raidPtr->Disks[col].devname,
460 1.56 fvdl proc, &vp);
461 1.48 oster
462 1.5 oster if (retcode) {
463 1.5 oster printf("raid%d: rebuilding: raidlookup on device: %s failed: %d!\n",raidPtr->raidid,
464 1.57 oster raidPtr->Disks[col].devname, retcode);
465 1.5 oster
466 1.39 oster /* the component isn't responding properly...
467 1.6 oster must be still dead :-( */
468 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
469 1.6 oster raidPtr->reconInProgress--;
470 1.5 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
471 1.5 oster return(retcode);
472 1.5 oster
473 1.5 oster } else {
474 1.5 oster
475 1.5 oster /* Ok, so we can at least do a lookup...
476 1.5 oster How about actually getting a vp for it? */
477 1.5 oster
478 1.56 fvdl if ((retcode = VOP_GETATTR(vp, &va, proc->p_ucred,
479 1.56 fvdl proc)) != 0) {
480 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
481 1.6 oster raidPtr->reconInProgress--;
482 1.5 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
483 1.5 oster return(retcode);
484 1.5 oster }
485 1.53 dsl retcode = VOP_IOCTL(vp, DIOCGPART, &dpart,
486 1.56 fvdl FREAD, proc->p_ucred, proc);
487 1.5 oster if (retcode) {
488 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
489 1.6 oster raidPtr->reconInProgress--;
490 1.5 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
491 1.5 oster return(retcode);
492 1.5 oster }
493 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
494 1.57 oster raidPtr->Disks[col].blockSize =
495 1.5 oster dpart.disklab->d_secsize;
496 1.5 oster
497 1.57 oster raidPtr->Disks[col].numBlocks =
498 1.5 oster dpart.part->p_size - rf_protectedSectors;
499 1.5 oster
500 1.57 oster raidPtr->raid_cinfo[col].ci_vp = vp;
501 1.57 oster raidPtr->raid_cinfo[col].ci_dev = va.va_rdev;
502 1.5 oster
503 1.57 oster raidPtr->Disks[col].dev = va.va_rdev;
504 1.5 oster
505 1.5 oster /* we allow the user to specify that only a
506 1.5 oster fraction of the disks should be used this is
507 1.5 oster just for debug: it speeds up
508 1.5 oster * the parity scan */
509 1.57 oster raidPtr->Disks[col].numBlocks =
510 1.57 oster raidPtr->Disks[col].numBlocks *
511 1.5 oster rf_sizePercentage / 100;
512 1.48 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
513 1.5 oster }
514 1.5 oster
515 1.5 oster
516 1.5 oster
517 1.57 oster spareDiskPtr = &raidPtr->Disks[col];
518 1.5 oster spareDiskPtr->status = rf_ds_used_spare;
519 1.5 oster
520 1.57 oster printf("raid%d: initiating in-place reconstruction on column %d\n", raidPtr->raidid, col);
521 1.5 oster
522 1.57 oster reconDesc = AllocRaidReconDesc((void *) raidPtr, col,
523 1.5 oster spareDiskPtr, numDisksDone,
524 1.57 oster col);
525 1.5 oster raidPtr->reconDesc = (void *) reconDesc;
526 1.5 oster #if RF_RECON_STATS > 0
527 1.5 oster reconDesc->hsStallCount = 0;
528 1.5 oster reconDesc->numReconExecDelays = 0;
529 1.5 oster reconDesc->numReconEventWaits = 0;
530 1.5 oster #endif /* RF_RECON_STATS > 0 */
531 1.5 oster reconDesc->reconExecTimerRunning = 0;
532 1.5 oster reconDesc->reconExecTicks = 0;
533 1.5 oster reconDesc->maxReconExecTicks = 0;
534 1.5 oster rc = rf_ContinueReconstructFailedDisk(reconDesc);
535 1.6 oster
536 1.6 oster RF_LOCK_MUTEX(raidPtr->mutex);
537 1.6 oster raidPtr->reconInProgress--;
538 1.6 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
539 1.6 oster
540 1.5 oster } else {
541 1.5 oster RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n",
542 1.5 oster lp->parityConfig);
543 1.5 oster rc = EIO;
544 1.5 oster }
545 1.5 oster
546 1.5 oster if (!rc) {
547 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
548 1.5 oster /* Need to set these here, as at this point it'll be claiming
549 1.5 oster that the disk is in rf_ds_spared! But we know better :-) */
550 1.5 oster
551 1.57 oster raidPtr->Disks[col].status = rf_ds_optimal;
552 1.57 oster raidPtr->status = rf_rs_optimal;
553 1.48 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
554 1.5 oster
555 1.5 oster /* fix up the component label */
556 1.5 oster /* Don't actually need the read here.. */
557 1.57 oster raidread_component_label(raidPtr->raid_cinfo[col].ci_dev,
558 1.57 oster raidPtr->raid_cinfo[col].ci_vp,
559 1.5 oster &c_label);
560 1.16 oster
561 1.48 oster RF_LOCK_MUTEX(raidPtr->mutex);
562 1.16 oster raid_init_component_label(raidPtr, &c_label);
563 1.16 oster
564 1.57 oster c_label.row = 0;
565 1.5 oster c_label.column = col;
566 1.28 oster
567 1.28 oster /* We've just done a rebuild based on all the other
568 1.28 oster disks, so at this point the parity is known to be
569 1.28 oster clean, even if it wasn't before. */
570 1.28 oster
571 1.28 oster /* XXX doesn't hold for RAID 6!!*/
572 1.28 oster
573 1.28 oster raidPtr->parity_good = RF_RAID_CLEAN;
574 1.48 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
575 1.28 oster
576 1.57 oster raidwrite_component_label(raidPtr->raid_cinfo[col].ci_dev,
577 1.57 oster raidPtr->raid_cinfo[col].ci_vp,
578 1.5 oster &c_label);
579 1.49 oster
580 1.49 oster rf_update_component_labels(raidPtr,
581 1.49 oster RF_NORMAL_COMPONENT_UPDATE);
582 1.5 oster
583 1.5 oster }
584 1.5 oster RF_SIGNAL_COND(raidPtr->waitForReconCond);
585 1.4 oster return (rc);
586 1.4 oster }
587 1.4 oster
588 1.4 oster
589 1.4 oster int
590 1.4 oster rf_ContinueReconstructFailedDisk(reconDesc)
591 1.4 oster RF_RaidReconDesc_t *reconDesc;
592 1.4 oster {
593 1.4 oster RF_Raid_t *raidPtr = reconDesc->raidPtr;
594 1.4 oster RF_RowCol_t col = reconDesc->col;
595 1.4 oster RF_RowCol_t scol = reconDesc->scol;
596 1.4 oster RF_ReconMap_t *mapPtr;
597 1.46 oster RF_ReconCtrl_t *tmp_reconctrl;
598 1.4 oster RF_ReconEvent_t *event;
599 1.4 oster struct timeval etime, elpsd;
600 1.4 oster unsigned long xor_s, xor_resid_us;
601 1.54 simonb int i, ds;
602 1.4 oster
603 1.4 oster switch (reconDesc->state) {
604 1.4 oster
605 1.4 oster
606 1.4 oster case 0:
607 1.4 oster
608 1.4 oster raidPtr->accumXorTimeUs = 0;
609 1.4 oster
610 1.4 oster /* create one trace record per physical disk */
611 1.4 oster RF_Malloc(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
612 1.4 oster
613 1.4 oster /* quiesce the array prior to starting recon. this is needed
614 1.4 oster * to assure no nasty interactions with pending user writes.
615 1.4 oster * We need to do this before we change the disk or row status. */
616 1.4 oster reconDesc->state = 1;
617 1.4 oster
618 1.4 oster Dprintf("RECON: begin request suspend\n");
619 1.54 simonb rf_SuspendNewRequestsAndWait(raidPtr);
620 1.4 oster Dprintf("RECON: end request suspend\n");
621 1.4 oster rf_StartUserStats(raidPtr); /* zero out the stats kept on
622 1.4 oster * user accs */
623 1.4 oster
624 1.4 oster /* fall through to state 1 */
625 1.4 oster
626 1.4 oster case 1:
627 1.4 oster
628 1.46 oster /* allocate our RF_ReconCTRL_t before we protect raidPtr->reconControl[row] */
629 1.57 oster tmp_reconctrl = rf_MakeReconControl(reconDesc, col, scol);
630 1.46 oster
631 1.4 oster RF_LOCK_MUTEX(raidPtr->mutex);
632 1.4 oster
633 1.4 oster /* create the reconstruction control pointer and install it in
634 1.4 oster * the right slot */
635 1.57 oster raidPtr->reconControl = tmp_reconctrl;
636 1.57 oster mapPtr = raidPtr->reconControl->reconMap;
637 1.57 oster raidPtr->status = rf_rs_reconstructing;
638 1.57 oster raidPtr->Disks[col].status = rf_ds_reconstructing;
639 1.57 oster raidPtr->Disks[col].spareCol = scol;
640 1.4 oster
641 1.4 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
642 1.4 oster
643 1.57 oster RF_GETTIME(raidPtr->reconControl->starttime);
644 1.4 oster
645 1.4 oster /* now start up the actual reconstruction: issue a read for
646 1.4 oster * each surviving disk */
647 1.14 oster
648 1.4 oster reconDesc->numDisksDone = 0;
649 1.4 oster for (i = 0; i < raidPtr->numCol; i++) {
650 1.4 oster if (i != col) {
651 1.4 oster /* find and issue the next I/O on the
652 1.4 oster * indicated disk */
653 1.57 oster if (IssueNextReadRequest(raidPtr, i)) {
654 1.57 oster Dprintf1("RECON: done issuing for c%d\n", i);
655 1.4 oster reconDesc->numDisksDone++;
656 1.4 oster }
657 1.4 oster }
658 1.4 oster }
659 1.4 oster
660 1.4 oster case 2:
661 1.4 oster Dprintf("RECON: resume requests\n");
662 1.4 oster rf_ResumeNewRequests(raidPtr);
663 1.4 oster
664 1.4 oster
665 1.4 oster reconDesc->state = 3;
666 1.4 oster
667 1.4 oster case 3:
668 1.4 oster
669 1.4 oster /* process reconstruction events until all disks report that
670 1.4 oster * they've completed all work */
671 1.57 oster mapPtr = raidPtr->reconControl->reconMap;
672 1.4 oster
673 1.4 oster
674 1.4 oster
675 1.4 oster while (reconDesc->numDisksDone < raidPtr->numCol - 1) {
676 1.4 oster
677 1.57 oster event = rf_GetNextReconEvent(reconDesc, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc);
678 1.4 oster RF_ASSERT(event);
679 1.4 oster
680 1.57 oster if (ProcessReconEvent(raidPtr, event))
681 1.4 oster reconDesc->numDisksDone++;
682 1.57 oster raidPtr->reconControl->numRUsTotal =
683 1.24 oster mapPtr->totalRUs;
684 1.57 oster raidPtr->reconControl->numRUsComplete =
685 1.24 oster mapPtr->totalRUs -
686 1.23 oster rf_UnitsLeftToReconstruct(mapPtr);
687 1.23 oster
688 1.57 oster raidPtr->reconControl->percentComplete =
689 1.57 oster (raidPtr->reconControl->numRUsComplete * 100 / raidPtr->reconControl->numRUsTotal);
690 1.41 oster #if RF_DEBUG_RECON
691 1.4 oster if (rf_prReconSched) {
692 1.57 oster rf_PrintReconSchedule(raidPtr->reconControl->reconMap, &(raidPtr->reconControl->starttime));
693 1.4 oster }
694 1.41 oster #endif
695 1.4 oster }
696 1.4 oster
697 1.4 oster
698 1.4 oster
699 1.4 oster reconDesc->state = 4;
700 1.4 oster
701 1.4 oster
702 1.4 oster case 4:
703 1.57 oster mapPtr = raidPtr->reconControl->reconMap;
704 1.4 oster if (rf_reconDebug) {
705 1.4 oster printf("RECON: all reads completed\n");
706 1.4 oster }
707 1.4 oster /* at this point all the reads have completed. We now wait
708 1.4 oster * for any pending writes to complete, and then we're done */
709 1.4 oster
710 1.57 oster while (rf_UnitsLeftToReconstruct(raidPtr->reconControl->reconMap) > 0) {
711 1.4 oster
712 1.57 oster event = rf_GetNextReconEvent(reconDesc, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc);
713 1.4 oster RF_ASSERT(event);
714 1.4 oster
715 1.57 oster (void) ProcessReconEvent(raidPtr, event); /* ignore return code */
716 1.57 oster raidPtr->reconControl->percentComplete = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs);
717 1.41 oster #if RF_DEBUG_RECON
718 1.4 oster if (rf_prReconSched) {
719 1.57 oster rf_PrintReconSchedule(raidPtr->reconControl->reconMap, &(raidPtr->reconControl->starttime));
720 1.4 oster }
721 1.41 oster #endif
722 1.4 oster }
723 1.4 oster reconDesc->state = 5;
724 1.4 oster
725 1.4 oster case 5:
726 1.4 oster /* Success: mark the dead disk as reconstructed. We quiesce
727 1.4 oster * the array here to assure no nasty interactions with pending
728 1.4 oster * user accesses when we free up the psstatus structure as
729 1.4 oster * part of FreeReconControl() */
730 1.4 oster
731 1.4 oster reconDesc->state = 6;
732 1.4 oster
733 1.54 simonb rf_SuspendNewRequestsAndWait(raidPtr);
734 1.4 oster rf_StopUserStats(raidPtr);
735 1.4 oster rf_PrintUserStats(raidPtr); /* print out the stats on user
736 1.4 oster * accs accumulated during
737 1.4 oster * recon */
738 1.4 oster
739 1.4 oster /* fall through to state 6 */
740 1.4 oster case 6:
741 1.4 oster
742 1.4 oster
743 1.4 oster
744 1.4 oster RF_LOCK_MUTEX(raidPtr->mutex);
745 1.4 oster raidPtr->numFailures--;
746 1.4 oster ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE);
747 1.57 oster raidPtr->Disks[col].status = (ds) ? rf_ds_dist_spared : rf_ds_spared;
748 1.57 oster raidPtr->status = (ds) ? rf_rs_reconfigured : rf_rs_optimal;
749 1.4 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
750 1.4 oster RF_GETTIME(etime);
751 1.57 oster RF_TIMEVAL_DIFF(&(raidPtr->reconControl->starttime), &etime, &elpsd);
752 1.4 oster
753 1.4 oster /* XXX -- why is state 7 different from state 6 if there is no
754 1.4 oster * return() here? -- XXX Note that I set elpsd above & use it
755 1.4 oster * below, so if you put a return here you'll have to fix this.
756 1.4 oster * (also, FreeReconControl is called below) */
757 1.4 oster
758 1.4 oster case 7:
759 1.4 oster
760 1.4 oster rf_ResumeNewRequests(raidPtr);
761 1.4 oster
762 1.57 oster printf("raid%d: Reconstruction of disk at col %d completed\n",
763 1.57 oster raidPtr->raidid, col);
764 1.4 oster xor_s = raidPtr->accumXorTimeUs / 1000000;
765 1.4 oster xor_resid_us = raidPtr->accumXorTimeUs % 1000000;
766 1.37 oster printf("raid%d: Recon time was %d.%06d seconds, accumulated XOR time was %ld us (%ld.%06ld)\n",
767 1.37 oster raidPtr->raidid,
768 1.37 oster (int) elpsd.tv_sec, (int) elpsd.tv_usec,
769 1.37 oster raidPtr->accumXorTimeUs, xor_s, xor_resid_us);
770 1.37 oster printf("raid%d: (start time %d sec %d usec, end time %d sec %d usec)\n",
771 1.37 oster raidPtr->raidid,
772 1.57 oster (int) raidPtr->reconControl->starttime.tv_sec,
773 1.57 oster (int) raidPtr->reconControl->starttime.tv_usec,
774 1.37 oster (int) etime.tv_sec, (int) etime.tv_usec);
775 1.14 oster
776 1.1 oster #if RF_RECON_STATS > 0
777 1.37 oster printf("raid%d: Total head-sep stall count was %d\n",
778 1.37 oster raidPtr->raidid, (int) reconDesc->hsStallCount);
779 1.4 oster #endif /* RF_RECON_STATS > 0 */
780 1.57 oster rf_FreeReconControl(raidPtr);
781 1.4 oster RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t));
782 1.4 oster FreeReconDesc(reconDesc);
783 1.4 oster
784 1.4 oster }
785 1.1 oster
786 1.4 oster SignalReconDone(raidPtr);
787 1.4 oster return (0);
788 1.1 oster }
789 1.13 oster /*****************************************************************************
790 1.1 oster * do the right thing upon each reconstruction event.
791 1.13 oster * returns nonzero if and only if there is nothing left unread on the
792 1.13 oster * indicated disk
793 1.13 oster *****************************************************************************/
794 1.4 oster static int
795 1.57 oster ProcessReconEvent(raidPtr, event)
796 1.4 oster RF_Raid_t *raidPtr;
797 1.4 oster RF_ReconEvent_t *event;
798 1.4 oster {
799 1.4 oster int retcode = 0, submitblocked;
800 1.4 oster RF_ReconBuffer_t *rbuf;
801 1.4 oster RF_SectorCount_t sectorsPerRU;
802 1.4 oster
803 1.4 oster Dprintf1("RECON: ProcessReconEvent type %d\n", event->type);
804 1.4 oster switch (event->type) {
805 1.4 oster
806 1.4 oster /* a read I/O has completed */
807 1.4 oster case RF_REVENT_READDONE:
808 1.57 oster rbuf = raidPtr->reconControl->perDiskInfo[event->col].rbuf;
809 1.57 oster Dprintf2("RECON: READDONE EVENT: col %d psid %ld\n",
810 1.57 oster event->col, rbuf->parityStripeID);
811 1.4 oster Dprintf7("RECON: done read psid %ld buf %lx %02x %02x %02x %02x %02x\n",
812 1.4 oster rbuf->parityStripeID, rbuf->buffer, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff,
813 1.4 oster rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff);
814 1.4 oster rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
815 1.4 oster submitblocked = rf_SubmitReconBuffer(rbuf, 0, 0);
816 1.4 oster Dprintf1("RECON: submitblocked=%d\n", submitblocked);
817 1.4 oster if (!submitblocked)
818 1.57 oster retcode = IssueNextReadRequest(raidPtr, event->col);
819 1.4 oster break;
820 1.4 oster
821 1.4 oster /* a write I/O has completed */
822 1.4 oster case RF_REVENT_WRITEDONE:
823 1.40 oster #if RF_DEBUG_RECON
824 1.4 oster if (rf_floatingRbufDebug) {
825 1.4 oster rf_CheckFloatingRbufCount(raidPtr, 1);
826 1.4 oster }
827 1.38 oster #endif
828 1.4 oster sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
829 1.4 oster rbuf = (RF_ReconBuffer_t *) event->arg;
830 1.4 oster rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
831 1.4 oster Dprintf3("RECON: WRITEDONE EVENT: psid %d ru %d (%d %% complete)\n",
832 1.57 oster rbuf->parityStripeID, rbuf->which_ru, raidPtr->reconControl->percentComplete);
833 1.57 oster rf_ReconMapUpdate(raidPtr, raidPtr->reconControl->reconMap,
834 1.4 oster rbuf->failedDiskSectorOffset, rbuf->failedDiskSectorOffset + sectorsPerRU - 1);
835 1.57 oster rf_RemoveFromActiveReconTable(raidPtr, rbuf->parityStripeID, rbuf->which_ru);
836 1.4 oster
837 1.4 oster if (rbuf->type == RF_RBUF_TYPE_FLOATING) {
838 1.57 oster RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
839 1.4 oster raidPtr->numFullReconBuffers--;
840 1.57 oster rf_ReleaseFloatingReconBuffer(raidPtr, rbuf);
841 1.57 oster RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
842 1.4 oster } else
843 1.4 oster if (rbuf->type == RF_RBUF_TYPE_FORCED)
844 1.4 oster rf_FreeReconBuffer(rbuf);
845 1.4 oster else
846 1.4 oster RF_ASSERT(0);
847 1.4 oster break;
848 1.4 oster
849 1.4 oster case RF_REVENT_BUFCLEAR: /* A buffer-stall condition has been
850 1.4 oster * cleared */
851 1.57 oster Dprintf1("RECON: BUFCLEAR EVENT: col %d\n", event->col);
852 1.57 oster submitblocked = rf_SubmitReconBuffer(raidPtr->reconControl->perDiskInfo[event->col].rbuf, 0, (int) (long) event->arg);
853 1.4 oster RF_ASSERT(!submitblocked); /* we wouldn't have gotten the
854 1.4 oster * BUFCLEAR event if we
855 1.4 oster * couldn't submit */
856 1.57 oster retcode = IssueNextReadRequest(raidPtr, event->col);
857 1.4 oster break;
858 1.4 oster
859 1.4 oster case RF_REVENT_BLOCKCLEAR: /* A user-write reconstruction
860 1.4 oster * blockage has been cleared */
861 1.57 oster DDprintf1("RECON: BLOCKCLEAR EVENT: col %d\n", event->col);
862 1.57 oster retcode = TryToRead(raidPtr, event->col);
863 1.4 oster break;
864 1.4 oster
865 1.4 oster case RF_REVENT_HEADSEPCLEAR: /* A max-head-separation
866 1.4 oster * reconstruction blockage has been
867 1.4 oster * cleared */
868 1.57 oster Dprintf1("RECON: HEADSEPCLEAR EVENT: col %d\n", event->col);
869 1.57 oster retcode = TryToRead(raidPtr, event->col);
870 1.4 oster break;
871 1.4 oster
872 1.4 oster /* a buffer has become ready to write */
873 1.4 oster case RF_REVENT_BUFREADY:
874 1.57 oster Dprintf1("RECON: BUFREADY EVENT: col %d\n", event->col);
875 1.57 oster retcode = IssueNextWriteRequest(raidPtr);
876 1.40 oster #if RF_DEBUG_RECON
877 1.4 oster if (rf_floatingRbufDebug) {
878 1.4 oster rf_CheckFloatingRbufCount(raidPtr, 1);
879 1.4 oster }
880 1.38 oster #endif
881 1.4 oster break;
882 1.4 oster
883 1.4 oster /* we need to skip the current RU entirely because it got
884 1.4 oster * recon'd while we were waiting for something else to happen */
885 1.4 oster case RF_REVENT_SKIP:
886 1.57 oster DDprintf1("RECON: SKIP EVENT: col %d\n", event->col);
887 1.57 oster retcode = IssueNextReadRequest(raidPtr, event->col);
888 1.4 oster break;
889 1.4 oster
890 1.4 oster /* a forced-reconstruction read access has completed. Just
891 1.4 oster * submit the buffer */
892 1.4 oster case RF_REVENT_FORCEDREADDONE:
893 1.4 oster rbuf = (RF_ReconBuffer_t *) event->arg;
894 1.4 oster rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
895 1.57 oster DDprintf1("RECON: FORCEDREADDONE EVENT: col %d\n", event->col);
896 1.4 oster submitblocked = rf_SubmitReconBuffer(rbuf, 1, 0);
897 1.4 oster RF_ASSERT(!submitblocked);
898 1.4 oster break;
899 1.4 oster
900 1.4 oster default:
901 1.4 oster RF_PANIC();
902 1.4 oster }
903 1.4 oster rf_FreeReconEventDesc(event);
904 1.4 oster return (retcode);
905 1.1 oster }
906 1.13 oster /*****************************************************************************
907 1.1 oster *
908 1.13 oster * find the next thing that's needed on the indicated disk, and issue
909 1.13 oster * a read request for it. We assume that the reconstruction buffer
910 1.13 oster * associated with this process is free to receive the data. If
911 1.13 oster * reconstruction is blocked on the indicated RU, we issue a
912 1.13 oster * blockage-release request instead of a physical disk read request.
913 1.13 oster * If the current disk gets too far ahead of the others, we issue a
914 1.13 oster * head-separation wait request and return.
915 1.13 oster *
916 1.13 oster * ctrl->{ru_count, curPSID, diskOffset} and
917 1.22 soren * rbuf->failedDiskSectorOffset are maintained to point to the unit
918 1.13 oster * we're currently accessing. Note that this deviates from the
919 1.13 oster * standard C idiom of having counters point to the next thing to be
920 1.13 oster * accessed. This allows us to easily retry when we're blocked by
921 1.13 oster * head separation or reconstruction-blockage events.
922 1.1 oster *
923 1.13 oster * returns nonzero if and only if there is nothing left unread on the
924 1.13 oster * indicated disk
925 1.13 oster *
926 1.13 oster *****************************************************************************/
927 1.4 oster static int
928 1.57 oster IssueNextReadRequest(raidPtr, col)
929 1.4 oster RF_Raid_t *raidPtr;
930 1.4 oster RF_RowCol_t col;
931 1.4 oster {
932 1.57 oster RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl->perDiskInfo[col];
933 1.4 oster RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
934 1.4 oster RF_ReconBuffer_t *rbuf = ctrl->rbuf;
935 1.4 oster RF_ReconUnitCount_t RUsPerPU = layoutPtr->SUsPerPU / layoutPtr->SUsPerRU;
936 1.4 oster RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
937 1.4 oster int do_new_check = 0, retcode = 0, status;
938 1.4 oster
939 1.4 oster /* if we are currently the slowest disk, mark that we have to do a new
940 1.4 oster * check */
941 1.57 oster if (ctrl->headSepCounter <= raidPtr->reconControl->minHeadSepCounter)
942 1.4 oster do_new_check = 1;
943 1.4 oster
944 1.4 oster while (1) {
945 1.4 oster
946 1.4 oster ctrl->ru_count++;
947 1.4 oster if (ctrl->ru_count < RUsPerPU) {
948 1.4 oster ctrl->diskOffset += sectorsPerRU;
949 1.4 oster rbuf->failedDiskSectorOffset += sectorsPerRU;
950 1.4 oster } else {
951 1.4 oster ctrl->curPSID++;
952 1.4 oster ctrl->ru_count = 0;
953 1.4 oster /* code left over from when head-sep was based on
954 1.4 oster * parity stripe id */
955 1.57 oster if (ctrl->curPSID >= raidPtr->reconControl->lastPSID) {
956 1.57 oster CheckForNewMinHeadSep(raidPtr, ++(ctrl->headSepCounter));
957 1.4 oster return (1); /* finito! */
958 1.4 oster }
959 1.4 oster /* find the disk offsets of the start of the parity
960 1.4 oster * stripe on both the current disk and the failed
961 1.4 oster * disk. skip this entire parity stripe if either disk
962 1.4 oster * does not appear in the indicated PS */
963 1.57 oster status = ComputePSDiskOffsets(raidPtr, ctrl->curPSID, col, &ctrl->diskOffset, &rbuf->failedDiskSectorOffset,
964 1.57 oster &rbuf->spCol, &rbuf->spOffset);
965 1.4 oster if (status) {
966 1.4 oster ctrl->ru_count = RUsPerPU - 1;
967 1.4 oster continue;
968 1.4 oster }
969 1.4 oster }
970 1.4 oster rbuf->which_ru = ctrl->ru_count;
971 1.4 oster
972 1.4 oster /* skip this RU if it's already been reconstructed */
973 1.57 oster if (rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, rbuf->failedDiskSectorOffset)) {
974 1.4 oster Dprintf2("Skipping psid %ld ru %d: already reconstructed\n", ctrl->curPSID, ctrl->ru_count);
975 1.4 oster continue;
976 1.4 oster }
977 1.4 oster break;
978 1.4 oster }
979 1.4 oster ctrl->headSepCounter++;
980 1.4 oster if (do_new_check)
981 1.57 oster CheckForNewMinHeadSep(raidPtr, ctrl->headSepCounter); /* update min if needed */
982 1.4 oster
983 1.4 oster
984 1.4 oster /* at this point, we have definitely decided what to do, and we have
985 1.4 oster * only to see if we can actually do it now */
986 1.4 oster rbuf->parityStripeID = ctrl->curPSID;
987 1.4 oster rbuf->which_ru = ctrl->ru_count;
988 1.29 thorpej memset((char *) &raidPtr->recon_tracerecs[col], 0,
989 1.29 thorpej sizeof(raidPtr->recon_tracerecs[col]));
990 1.4 oster raidPtr->recon_tracerecs[col].reconacc = 1;
991 1.4 oster RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
992 1.57 oster retcode = TryToRead(raidPtr, col);
993 1.4 oster return (retcode);
994 1.1 oster }
995 1.13 oster
996 1.13 oster /*
997 1.13 oster * tries to issue the next read on the indicated disk. We may be
998 1.13 oster * blocked by (a) the heads being too far apart, or (b) recon on the
999 1.13 oster * indicated RU being blocked due to a write by a user thread. In
1000 1.13 oster * this case, we issue a head-sep or blockage wait request, which will
1001 1.13 oster * cause this same routine to be invoked again later when the blockage
1002 1.13 oster * has cleared.
1003 1.1 oster */
1004 1.13 oster
1005 1.4 oster static int
1006 1.57 oster TryToRead(raidPtr, col)
1007 1.4 oster RF_Raid_t *raidPtr;
1008 1.4 oster RF_RowCol_t col;
1009 1.4 oster {
1010 1.57 oster RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl->perDiskInfo[col];
1011 1.4 oster RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
1012 1.4 oster RF_StripeNum_t psid = ctrl->curPSID;
1013 1.4 oster RF_ReconUnitNum_t which_ru = ctrl->ru_count;
1014 1.4 oster RF_DiskQueueData_t *req;
1015 1.4 oster int status, created = 0;
1016 1.4 oster RF_ReconParityStripeStatus_t *pssPtr;
1017 1.4 oster
1018 1.4 oster /* if the current disk is too far ahead of the others, issue a
1019 1.4 oster * head-separation wait and return */
1020 1.57 oster if (CheckHeadSeparation(raidPtr, ctrl, col, ctrl->headSepCounter, which_ru))
1021 1.4 oster return (0);
1022 1.57 oster RF_LOCK_PSS_MUTEX(raidPtr, psid);
1023 1.57 oster pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl->pssTable, psid, which_ru, RF_PSS_CREATE, &created);
1024 1.4 oster
1025 1.4 oster /* if recon is blocked on the indicated parity stripe, issue a
1026 1.4 oster * block-wait request and return. this also must mark the indicated RU
1027 1.4 oster * in the stripe as under reconstruction if not blocked. */
1028 1.57 oster status = CheckForcedOrBlockedReconstruction(raidPtr, pssPtr, ctrl, col, psid, which_ru);
1029 1.4 oster if (status == RF_PSS_RECON_BLOCKED) {
1030 1.4 oster Dprintf2("RECON: Stalling psid %ld ru %d: recon blocked\n", psid, which_ru);
1031 1.4 oster goto out;
1032 1.4 oster } else
1033 1.4 oster if (status == RF_PSS_FORCED_ON_WRITE) {
1034 1.57 oster rf_CauseReconEvent(raidPtr, col, NULL, RF_REVENT_SKIP);
1035 1.4 oster goto out;
1036 1.4 oster }
1037 1.4 oster /* make one last check to be sure that the indicated RU didn't get
1038 1.4 oster * reconstructed while we were waiting for something else to happen.
1039 1.4 oster * This is unfortunate in that it causes us to make this check twice
1040 1.4 oster * in the normal case. Might want to make some attempt to re-work
1041 1.4 oster * this so that we only do this check if we've definitely blocked on
1042 1.4 oster * one of the above checks. When this condition is detected, we may
1043 1.4 oster * have just created a bogus status entry, which we need to delete. */
1044 1.57 oster if (rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, ctrl->rbuf->failedDiskSectorOffset)) {
1045 1.4 oster Dprintf2("RECON: Skipping psid %ld ru %d: prior recon after stall\n", psid, which_ru);
1046 1.4 oster if (created)
1047 1.57 oster rf_PSStatusDelete(raidPtr, raidPtr->reconControl->pssTable, pssPtr);
1048 1.57 oster rf_CauseReconEvent(raidPtr, col, NULL, RF_REVENT_SKIP);
1049 1.4 oster goto out;
1050 1.4 oster }
1051 1.4 oster /* found something to read. issue the I/O */
1052 1.57 oster Dprintf4("RECON: Read for psid %ld on col %d offset %ld buf %lx\n",
1053 1.57 oster psid, col, ctrl->diskOffset, ctrl->rbuf->buffer);
1054 1.4 oster RF_ETIMER_STOP(raidPtr->recon_tracerecs[col].recon_timer);
1055 1.4 oster RF_ETIMER_EVAL(raidPtr->recon_tracerecs[col].recon_timer);
1056 1.4 oster raidPtr->recon_tracerecs[col].specific.recon.recon_start_to_fetch_us =
1057 1.4 oster RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[col].recon_timer);
1058 1.4 oster RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
1059 1.4 oster
1060 1.4 oster /* should be ok to use a NULL proc pointer here, all the bufs we use
1061 1.4 oster * should be in kernel space */
1062 1.4 oster req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, ctrl->diskOffset, sectorsPerRU, ctrl->rbuf->buffer, psid, which_ru,
1063 1.4 oster ReconReadDoneProc, (void *) ctrl, NULL, &raidPtr->recon_tracerecs[col], (void *) raidPtr, 0, NULL);
1064 1.4 oster
1065 1.4 oster RF_ASSERT(req); /* XXX -- fix this -- XXX */
1066 1.4 oster
1067 1.4 oster ctrl->rbuf->arg = (void *) req;
1068 1.57 oster rf_DiskIOEnqueue(&raidPtr->Queues[col], req, RF_IO_RECON_PRIORITY);
1069 1.4 oster pssPtr->issued[col] = 1;
1070 1.1 oster
1071 1.1 oster out:
1072 1.57 oster RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1073 1.4 oster return (0);
1074 1.1 oster }
1075 1.1 oster
1076 1.1 oster
1077 1.13 oster /*
1078 1.13 oster * given a parity stripe ID, we want to find out whether both the
1079 1.13 oster * current disk and the failed disk exist in that parity stripe. If
1080 1.13 oster * not, we want to skip this whole PS. If so, we want to find the
1081 1.13 oster * disk offset of the start of the PS on both the current disk and the
1082 1.13 oster * failed disk.
1083 1.13 oster *
1084 1.13 oster * this works by getting a list of disks comprising the indicated
1085 1.13 oster * parity stripe, and searching the list for the current and failed
1086 1.13 oster * disks. Once we've decided they both exist in the parity stripe, we
1087 1.13 oster * need to decide whether each is data or parity, so that we'll know
1088 1.13 oster * which mapping function to call to get the corresponding disk
1089 1.1 oster * offsets.
1090 1.1 oster *
1091 1.13 oster * this is kind of unpleasant, but doing it this way allows the
1092 1.13 oster * reconstruction code to use parity stripe IDs rather than physical
1093 1.13 oster * disks address to march through the failed disk, which greatly
1094 1.13 oster * simplifies a lot of code, as well as eliminating the need for a
1095 1.13 oster * reverse-mapping function. I also think it will execute faster,
1096 1.13 oster * since the calls to the mapping module are kept to a minimum.
1097 1.1 oster *
1098 1.13 oster * ASSUMES THAT THE STRIPE IDENTIFIER IDENTIFIES THE DISKS COMPRISING
1099 1.13 oster * THE STRIPE IN THE CORRECT ORDER */
1100 1.13 oster
1101 1.13 oster
1102 1.4 oster static int
1103 1.4 oster ComputePSDiskOffsets(
1104 1.4 oster RF_Raid_t * raidPtr, /* raid descriptor */
1105 1.4 oster RF_StripeNum_t psid, /* parity stripe identifier */
1106 1.57 oster RF_RowCol_t col, /* column of disk to find the offsets for */
1107 1.4 oster RF_SectorNum_t * outDiskOffset,
1108 1.4 oster RF_SectorNum_t * outFailedDiskSectorOffset,
1109 1.57 oster RF_RowCol_t * spCol, /* OUT: col of spare unit for failed unit */
1110 1.4 oster RF_SectorNum_t * spOffset)
1111 1.4 oster { /* OUT: offset into disk containing spare unit */
1112 1.4 oster RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
1113 1.57 oster RF_RowCol_t fcol = raidPtr->reconControl->fcol;
1114 1.4 oster RF_RaidAddr_t sosRaidAddress; /* start-of-stripe */
1115 1.4 oster RF_RowCol_t *diskids;
1116 1.4 oster u_int i, j, k, i_offset, j_offset;
1117 1.57 oster RF_RowCol_t pcol;
1118 1.57 oster int testcol;
1119 1.4 oster RF_SectorNum_t poffset;
1120 1.4 oster char i_is_parity = 0, j_is_parity = 0;
1121 1.4 oster RF_RowCol_t stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
1122 1.4 oster
1123 1.4 oster /* get a listing of the disks comprising that stripe */
1124 1.4 oster sosRaidAddress = rf_ParityStripeIDToRaidAddress(layoutPtr, psid);
1125 1.57 oster (layoutPtr->map->IdentifyStripe) (raidPtr, sosRaidAddress, &diskids);
1126 1.4 oster RF_ASSERT(diskids);
1127 1.4 oster
1128 1.4 oster /* reject this entire parity stripe if it does not contain the
1129 1.4 oster * indicated disk or it does not contain the failed disk */
1130 1.57 oster
1131 1.4 oster for (i = 0; i < stripeWidth; i++) {
1132 1.4 oster if (col == diskids[i])
1133 1.4 oster break;
1134 1.4 oster }
1135 1.4 oster if (i == stripeWidth)
1136 1.4 oster goto skipit;
1137 1.4 oster for (j = 0; j < stripeWidth; j++) {
1138 1.4 oster if (fcol == diskids[j])
1139 1.4 oster break;
1140 1.4 oster }
1141 1.4 oster if (j == stripeWidth) {
1142 1.4 oster goto skipit;
1143 1.4 oster }
1144 1.4 oster /* find out which disk the parity is on */
1145 1.57 oster (layoutPtr->map->MapParity) (raidPtr, sosRaidAddress, &pcol, &poffset, RF_DONT_REMAP);
1146 1.4 oster
1147 1.4 oster /* find out if either the current RU or the failed RU is parity */
1148 1.4 oster /* also, if the parity occurs in this stripe prior to the data and/or
1149 1.4 oster * failed col, we need to decrement i and/or j */
1150 1.4 oster for (k = 0; k < stripeWidth; k++)
1151 1.4 oster if (diskids[k] == pcol)
1152 1.4 oster break;
1153 1.4 oster RF_ASSERT(k < stripeWidth);
1154 1.4 oster i_offset = i;
1155 1.4 oster j_offset = j;
1156 1.4 oster if (k < i)
1157 1.4 oster i_offset--;
1158 1.4 oster else
1159 1.4 oster if (k == i) {
1160 1.4 oster i_is_parity = 1;
1161 1.4 oster i_offset = 0;
1162 1.4 oster } /* set offsets to zero to disable multiply
1163 1.4 oster * below */
1164 1.4 oster if (k < j)
1165 1.4 oster j_offset--;
1166 1.4 oster else
1167 1.4 oster if (k == j) {
1168 1.4 oster j_is_parity = 1;
1169 1.4 oster j_offset = 0;
1170 1.4 oster }
1171 1.4 oster /* at this point, [ij]_is_parity tells us whether the [current,failed]
1172 1.4 oster * disk is parity at the start of this RU, and, if data, "[ij]_offset"
1173 1.4 oster * tells us how far into the stripe the [current,failed] disk is. */
1174 1.4 oster
1175 1.4 oster /* call the mapping routine to get the offset into the current disk,
1176 1.4 oster * repeat for failed disk. */
1177 1.4 oster if (i_is_parity)
1178 1.57 oster layoutPtr->map->MapParity(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outDiskOffset, RF_DONT_REMAP);
1179 1.4 oster else
1180 1.57 oster layoutPtr->map->MapSector(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outDiskOffset, RF_DONT_REMAP);
1181 1.4 oster
1182 1.57 oster RF_ASSERT(col == testcol);
1183 1.4 oster
1184 1.4 oster if (j_is_parity)
1185 1.57 oster layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP);
1186 1.4 oster else
1187 1.57 oster layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP);
1188 1.57 oster RF_ASSERT(fcol == testcol);
1189 1.4 oster
1190 1.4 oster /* now locate the spare unit for the failed unit */
1191 1.4 oster if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) {
1192 1.4 oster if (j_is_parity)
1193 1.57 oster layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spCol, spOffset, RF_REMAP);
1194 1.4 oster else
1195 1.57 oster layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spCol, spOffset, RF_REMAP);
1196 1.4 oster } else {
1197 1.57 oster *spCol = raidPtr->reconControl->spareCol;
1198 1.4 oster *spOffset = *outFailedDiskSectorOffset;
1199 1.4 oster }
1200 1.4 oster
1201 1.4 oster return (0);
1202 1.1 oster
1203 1.1 oster skipit:
1204 1.57 oster Dprintf2("RECON: Skipping psid %ld: nothing needed from r%d c%d\n",
1205 1.57 oster psid, col);
1206 1.4 oster return (1);
1207 1.1 oster }
1208 1.4 oster /* this is called when a buffer has become ready to write to the replacement disk */
1209 1.4 oster static int
1210 1.57 oster IssueNextWriteRequest(raidPtr)
1211 1.4 oster RF_Raid_t *raidPtr;
1212 1.4 oster {
1213 1.4 oster RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
1214 1.4 oster RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
1215 1.57 oster RF_RowCol_t fcol = raidPtr->reconControl->fcol;
1216 1.4 oster RF_ReconBuffer_t *rbuf;
1217 1.4 oster RF_DiskQueueData_t *req;
1218 1.4 oster
1219 1.57 oster rbuf = rf_GetFullReconBuffer(raidPtr->reconControl);
1220 1.4 oster RF_ASSERT(rbuf); /* there must be one available, or we wouldn't
1221 1.4 oster * have gotten the event that sent us here */
1222 1.4 oster RF_ASSERT(rbuf->pssPtr);
1223 1.4 oster
1224 1.4 oster rbuf->pssPtr->writeRbuf = rbuf;
1225 1.4 oster rbuf->pssPtr = NULL;
1226 1.4 oster
1227 1.57 oster Dprintf6("RECON: New write (c %d offs %d) for psid %ld ru %d (failed disk offset %ld) buf %lx\n",
1228 1.57 oster rbuf->spCol, rbuf->spOffset, rbuf->parityStripeID,
1229 1.4 oster rbuf->which_ru, rbuf->failedDiskSectorOffset, rbuf->buffer);
1230 1.4 oster Dprintf6("RECON: new write psid %ld %02x %02x %02x %02x %02x\n",
1231 1.4 oster rbuf->parityStripeID, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff,
1232 1.4 oster rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff);
1233 1.4 oster
1234 1.4 oster /* should be ok to use a NULL b_proc here b/c all addrs should be in
1235 1.4 oster * kernel space */
1236 1.4 oster req = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, rbuf->spOffset,
1237 1.4 oster sectorsPerRU, rbuf->buffer,
1238 1.4 oster rbuf->parityStripeID, rbuf->which_ru,
1239 1.4 oster ReconWriteDoneProc, (void *) rbuf, NULL,
1240 1.4 oster &raidPtr->recon_tracerecs[fcol],
1241 1.4 oster (void *) raidPtr, 0, NULL);
1242 1.4 oster
1243 1.4 oster RF_ASSERT(req); /* XXX -- fix this -- XXX */
1244 1.1 oster
1245 1.4 oster rbuf->arg = (void *) req;
1246 1.57 oster rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spCol], req, RF_IO_RECON_PRIORITY);
1247 1.1 oster
1248 1.4 oster return (0);
1249 1.1 oster }
1250 1.13 oster
1251 1.13 oster /*
1252 1.13 oster * this gets called upon the completion of a reconstruction read
1253 1.13 oster * operation the arg is a pointer to the per-disk reconstruction
1254 1.13 oster * control structure for the process that just finished a read.
1255 1.1 oster *
1256 1.13 oster * called at interrupt context in the kernel, so don't do anything
1257 1.13 oster * illegal here.
1258 1.1 oster */
1259 1.4 oster static int
1260 1.4 oster ReconReadDoneProc(arg, status)
1261 1.4 oster void *arg;
1262 1.4 oster int status;
1263 1.4 oster {
1264 1.4 oster RF_PerDiskReconCtrl_t *ctrl = (RF_PerDiskReconCtrl_t *) arg;
1265 1.4 oster RF_Raid_t *raidPtr = ctrl->reconCtrl->reconDesc->raidPtr;
1266 1.4 oster
1267 1.4 oster if (status) {
1268 1.4 oster /*
1269 1.4 oster * XXX
1270 1.4 oster */
1271 1.4 oster printf("Recon read failed!\n");
1272 1.4 oster RF_PANIC();
1273 1.4 oster }
1274 1.4 oster RF_ETIMER_STOP(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1275 1.4 oster RF_ETIMER_EVAL(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1276 1.4 oster raidPtr->recon_tracerecs[ctrl->col].specific.recon.recon_fetch_to_return_us =
1277 1.4 oster RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1278 1.4 oster RF_ETIMER_START(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1279 1.4 oster
1280 1.57 oster rf_CauseReconEvent(raidPtr, ctrl->col, NULL, RF_REVENT_READDONE);
1281 1.4 oster return (0);
1282 1.1 oster }
1283 1.1 oster /* this gets called upon the completion of a reconstruction write operation.
1284 1.1 oster * the arg is a pointer to the rbuf that was just written
1285 1.1 oster *
1286 1.1 oster * called at interrupt context in the kernel, so don't do anything illegal here.
1287 1.1 oster */
1288 1.4 oster static int
1289 1.4 oster ReconWriteDoneProc(arg, status)
1290 1.4 oster void *arg;
1291 1.4 oster int status;
1292 1.4 oster {
1293 1.4 oster RF_ReconBuffer_t *rbuf = (RF_ReconBuffer_t *) arg;
1294 1.4 oster
1295 1.4 oster Dprintf2("Reconstruction completed on psid %ld ru %d\n", rbuf->parityStripeID, rbuf->which_ru);
1296 1.4 oster if (status) {
1297 1.4 oster printf("Recon write failed!\n"); /* fprintf(stderr,"Recon
1298 1.4 oster * write failed!\n"); */
1299 1.4 oster RF_PANIC();
1300 1.4 oster }
1301 1.57 oster rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->col, arg, RF_REVENT_WRITEDONE);
1302 1.4 oster return (0);
1303 1.1 oster }
1304 1.1 oster
1305 1.1 oster
1306 1.13 oster /*
1307 1.13 oster * computes a new minimum head sep, and wakes up anyone who needs to
1308 1.13 oster * be woken as a result
1309 1.13 oster */
1310 1.4 oster static void
1311 1.57 oster CheckForNewMinHeadSep(raidPtr, hsCtr)
1312 1.4 oster RF_Raid_t *raidPtr;
1313 1.4 oster RF_HeadSepLimit_t hsCtr;
1314 1.4 oster {
1315 1.57 oster RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl;
1316 1.4 oster RF_HeadSepLimit_t new_min;
1317 1.4 oster RF_RowCol_t i;
1318 1.4 oster RF_CallbackDesc_t *p;
1319 1.4 oster RF_ASSERT(hsCtr >= reconCtrlPtr->minHeadSepCounter); /* from the definition
1320 1.4 oster * of a minimum */
1321 1.4 oster
1322 1.4 oster
1323 1.4 oster RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
1324 1.4 oster
1325 1.4 oster new_min = ~(1L << (8 * sizeof(long) - 1)); /* 0x7FFF....FFF */
1326 1.4 oster for (i = 0; i < raidPtr->numCol; i++)
1327 1.4 oster if (i != reconCtrlPtr->fcol) {
1328 1.4 oster if (reconCtrlPtr->perDiskInfo[i].headSepCounter < new_min)
1329 1.4 oster new_min = reconCtrlPtr->perDiskInfo[i].headSepCounter;
1330 1.4 oster }
1331 1.4 oster /* set the new minimum and wake up anyone who can now run again */
1332 1.4 oster if (new_min != reconCtrlPtr->minHeadSepCounter) {
1333 1.4 oster reconCtrlPtr->minHeadSepCounter = new_min;
1334 1.4 oster Dprintf1("RECON: new min head pos counter val is %ld\n", new_min);
1335 1.4 oster while (reconCtrlPtr->headSepCBList) {
1336 1.4 oster if (reconCtrlPtr->headSepCBList->callbackArg.v > new_min)
1337 1.4 oster break;
1338 1.4 oster p = reconCtrlPtr->headSepCBList;
1339 1.4 oster reconCtrlPtr->headSepCBList = p->next;
1340 1.4 oster p->next = NULL;
1341 1.57 oster rf_CauseReconEvent(raidPtr, p->col, NULL, RF_REVENT_HEADSEPCLEAR);
1342 1.4 oster rf_FreeCallbackDesc(p);
1343 1.4 oster }
1344 1.1 oster
1345 1.4 oster }
1346 1.4 oster RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
1347 1.1 oster }
1348 1.13 oster
1349 1.13 oster /*
1350 1.13 oster * checks to see that the maximum head separation will not be violated
1351 1.13 oster * if we initiate a reconstruction I/O on the indicated disk.
1352 1.13 oster * Limiting the maximum head separation between two disks eliminates
1353 1.13 oster * the nasty buffer-stall conditions that occur when one disk races
1354 1.13 oster * ahead of the others and consumes all of the floating recon buffers.
1355 1.13 oster * This code is complex and unpleasant but it's necessary to avoid
1356 1.13 oster * some very nasty, albeit fairly rare, reconstruction behavior.
1357 1.1 oster *
1358 1.13 oster * returns non-zero if and only if we have to stop working on the
1359 1.13 oster * indicated disk due to a head-separation delay.
1360 1.1 oster */
1361 1.4 oster static int
1362 1.4 oster CheckHeadSeparation(
1363 1.4 oster RF_Raid_t * raidPtr,
1364 1.4 oster RF_PerDiskReconCtrl_t * ctrl,
1365 1.4 oster RF_RowCol_t col,
1366 1.4 oster RF_HeadSepLimit_t hsCtr,
1367 1.4 oster RF_ReconUnitNum_t which_ru)
1368 1.4 oster {
1369 1.57 oster RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl;
1370 1.4 oster RF_CallbackDesc_t *cb, *p, *pt;
1371 1.10 oster int retval = 0;
1372 1.4 oster
1373 1.4 oster /* if we're too far ahead of the slowest disk, stop working on this
1374 1.4 oster * disk until the slower ones catch up. We do this by scheduling a
1375 1.4 oster * wakeup callback for the time when the slowest disk has caught up.
1376 1.4 oster * We define "caught up" with 20% hysteresis, i.e. the head separation
1377 1.4 oster * must have fallen to at most 80% of the max allowable head
1378 1.4 oster * separation before we'll wake up.
1379 1.4 oster *
1380 1.4 oster */
1381 1.4 oster RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
1382 1.4 oster if ((raidPtr->headSepLimit >= 0) &&
1383 1.4 oster ((ctrl->headSepCounter - reconCtrlPtr->minHeadSepCounter) > raidPtr->headSepLimit)) {
1384 1.57 oster Dprintf5("raid%d: RECON: head sep stall: col %d hsCtr %ld minHSCtr %ld limit %ld\n",
1385 1.57 oster raidPtr->raidid, col, ctrl->headSepCounter,
1386 1.10 oster reconCtrlPtr->minHeadSepCounter,
1387 1.10 oster raidPtr->headSepLimit);
1388 1.4 oster cb = rf_AllocCallbackDesc();
1389 1.4 oster /* the minHeadSepCounter value we have to get to before we'll
1390 1.4 oster * wake up. build in 20% hysteresis. */
1391 1.4 oster cb->callbackArg.v = (ctrl->headSepCounter - raidPtr->headSepLimit + raidPtr->headSepLimit / 5);
1392 1.4 oster cb->col = col;
1393 1.4 oster cb->next = NULL;
1394 1.4 oster
1395 1.4 oster /* insert this callback descriptor into the sorted list of
1396 1.4 oster * pending head-sep callbacks */
1397 1.4 oster p = reconCtrlPtr->headSepCBList;
1398 1.4 oster if (!p)
1399 1.4 oster reconCtrlPtr->headSepCBList = cb;
1400 1.4 oster else
1401 1.4 oster if (cb->callbackArg.v < p->callbackArg.v) {
1402 1.4 oster cb->next = reconCtrlPtr->headSepCBList;
1403 1.4 oster reconCtrlPtr->headSepCBList = cb;
1404 1.4 oster } else {
1405 1.4 oster for (pt = p, p = p->next; p && (p->callbackArg.v < cb->callbackArg.v); pt = p, p = p->next);
1406 1.4 oster cb->next = p;
1407 1.4 oster pt->next = cb;
1408 1.4 oster }
1409 1.4 oster retval = 1;
1410 1.1 oster #if RF_RECON_STATS > 0
1411 1.4 oster ctrl->reconCtrl->reconDesc->hsStallCount++;
1412 1.4 oster #endif /* RF_RECON_STATS > 0 */
1413 1.4 oster }
1414 1.4 oster RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
1415 1.1 oster
1416 1.4 oster return (retval);
1417 1.1 oster }
1418 1.13 oster /*
1419 1.13 oster * checks to see if reconstruction has been either forced or blocked
1420 1.13 oster * by a user operation. if forced, we skip this RU entirely. else if
1421 1.13 oster * blocked, put ourselves on the wait list. else return 0.
1422 1.1 oster *
1423 1.13 oster * ASSUMES THE PSS MUTEX IS LOCKED UPON ENTRY
1424 1.1 oster */
1425 1.4 oster static int
1426 1.4 oster CheckForcedOrBlockedReconstruction(
1427 1.4 oster RF_Raid_t * raidPtr,
1428 1.4 oster RF_ReconParityStripeStatus_t * pssPtr,
1429 1.4 oster RF_PerDiskReconCtrl_t * ctrl,
1430 1.4 oster RF_RowCol_t col,
1431 1.4 oster RF_StripeNum_t psid,
1432 1.4 oster RF_ReconUnitNum_t which_ru)
1433 1.4 oster {
1434 1.4 oster RF_CallbackDesc_t *cb;
1435 1.4 oster int retcode = 0;
1436 1.4 oster
1437 1.4 oster if ((pssPtr->flags & RF_PSS_FORCED_ON_READ) || (pssPtr->flags & RF_PSS_FORCED_ON_WRITE))
1438 1.4 oster retcode = RF_PSS_FORCED_ON_WRITE;
1439 1.4 oster else
1440 1.4 oster if (pssPtr->flags & RF_PSS_RECON_BLOCKED) {
1441 1.57 oster Dprintf3("RECON: col %d blocked at psid %ld ru %d\n", col, psid, which_ru);
1442 1.4 oster cb = rf_AllocCallbackDesc(); /* append ourselves to
1443 1.4 oster * the blockage-wait
1444 1.4 oster * list */
1445 1.4 oster cb->col = col;
1446 1.4 oster cb->next = pssPtr->blockWaitList;
1447 1.4 oster pssPtr->blockWaitList = cb;
1448 1.4 oster retcode = RF_PSS_RECON_BLOCKED;
1449 1.4 oster }
1450 1.4 oster if (!retcode)
1451 1.4 oster pssPtr->flags |= RF_PSS_UNDER_RECON; /* mark this RU as under
1452 1.4 oster * reconstruction */
1453 1.4 oster
1454 1.4 oster return (retcode);
1455 1.1 oster }
1456 1.13 oster /*
1457 1.13 oster * if reconstruction is currently ongoing for the indicated stripeID,
1458 1.13 oster * reconstruction is forced to completion and we return non-zero to
1459 1.13 oster * indicate that the caller must wait. If not, then reconstruction is
1460 1.13 oster * blocked on the indicated stripe and the routine returns zero. If
1461 1.13 oster * and only if we return non-zero, we'll cause the cbFunc to get
1462 1.13 oster * invoked with the cbArg when the reconstruction has completed.
1463 1.1 oster */
1464 1.4 oster int
1465 1.4 oster rf_ForceOrBlockRecon(raidPtr, asmap, cbFunc, cbArg)
1466 1.4 oster RF_Raid_t *raidPtr;
1467 1.4 oster RF_AccessStripeMap_t *asmap;
1468 1.4 oster void (*cbFunc) (RF_Raid_t *, void *);
1469 1.4 oster void *cbArg;
1470 1.4 oster {
1471 1.4 oster RF_StripeNum_t stripeID = asmap->stripeID; /* the stripe ID we're
1472 1.4 oster * forcing recon on */
1473 1.4 oster RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU; /* num sects in one RU */
1474 1.4 oster RF_ReconParityStripeStatus_t *pssPtr; /* a pointer to the parity
1475 1.4 oster * stripe status structure */
1476 1.4 oster RF_StripeNum_t psid; /* parity stripe id */
1477 1.4 oster RF_SectorNum_t offset, fd_offset; /* disk offset, failed-disk
1478 1.4 oster * offset */
1479 1.4 oster RF_RowCol_t *diskids;
1480 1.4 oster RF_ReconUnitNum_t which_ru; /* RU within parity stripe */
1481 1.4 oster RF_RowCol_t fcol, diskno, i;
1482 1.4 oster RF_ReconBuffer_t *new_rbuf; /* ptr to newly allocated rbufs */
1483 1.4 oster RF_DiskQueueData_t *req;/* disk I/O req to be enqueued */
1484 1.4 oster RF_CallbackDesc_t *cb;
1485 1.4 oster int created = 0, nPromoted;
1486 1.4 oster
1487 1.4 oster psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru);
1488 1.4 oster
1489 1.57 oster RF_LOCK_PSS_MUTEX(raidPtr, psid);
1490 1.4 oster
1491 1.57 oster pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl->pssTable, psid, which_ru, RF_PSS_CREATE | RF_PSS_RECON_BLOCKED, &created);
1492 1.4 oster
1493 1.4 oster /* if recon is not ongoing on this PS, just return */
1494 1.4 oster if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) {
1495 1.57 oster RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1496 1.4 oster return (0);
1497 1.4 oster }
1498 1.4 oster /* otherwise, we have to wait for reconstruction to complete on this
1499 1.4 oster * RU. */
1500 1.4 oster /* In order to avoid waiting for a potentially large number of
1501 1.4 oster * low-priority accesses to complete, we force a normal-priority (i.e.
1502 1.4 oster * not low-priority) reconstruction on this RU. */
1503 1.4 oster if (!(pssPtr->flags & RF_PSS_FORCED_ON_WRITE) && !(pssPtr->flags & RF_PSS_FORCED_ON_READ)) {
1504 1.4 oster DDprintf1("Forcing recon on psid %ld\n", psid);
1505 1.4 oster pssPtr->flags |= RF_PSS_FORCED_ON_WRITE; /* mark this RU as under
1506 1.4 oster * forced recon */
1507 1.4 oster pssPtr->flags &= ~RF_PSS_RECON_BLOCKED; /* clear the blockage
1508 1.4 oster * that we just set */
1509 1.57 oster fcol = raidPtr->reconControl->fcol;
1510 1.4 oster
1511 1.4 oster /* get a listing of the disks comprising the indicated stripe */
1512 1.57 oster (raidPtr->Layout.map->IdentifyStripe) (raidPtr, asmap->raidAddress, &diskids);
1513 1.4 oster
1514 1.4 oster /* For previously issued reads, elevate them to normal
1515 1.4 oster * priority. If the I/O has already completed, it won't be
1516 1.4 oster * found in the queue, and hence this will be a no-op. For
1517 1.4 oster * unissued reads, allocate buffers and issue new reads. The
1518 1.4 oster * fact that we've set the FORCED bit means that the regular
1519 1.4 oster * recon procs will not re-issue these reqs */
1520 1.4 oster for (i = 0; i < raidPtr->Layout.numDataCol + raidPtr->Layout.numParityCol; i++)
1521 1.4 oster if ((diskno = diskids[i]) != fcol) {
1522 1.4 oster if (pssPtr->issued[diskno]) {
1523 1.57 oster nPromoted = rf_DiskIOPromote(&raidPtr->Queues[diskno], psid, which_ru);
1524 1.4 oster if (rf_reconDebug && nPromoted)
1525 1.57 oster printf("raid%d: promoted read from col %d\n", raidPtr->raidid, diskno);
1526 1.4 oster } else {
1527 1.57 oster new_rbuf = rf_MakeReconBuffer(raidPtr, diskno, RF_RBUF_TYPE_FORCED); /* create new buf */
1528 1.57 oster ComputePSDiskOffsets(raidPtr, psid, diskno, &offset, &fd_offset,
1529 1.57 oster &new_rbuf->spCol, &new_rbuf->spOffset); /* find offsets & spare
1530 1.4 oster * location */
1531 1.4 oster new_rbuf->parityStripeID = psid; /* fill in the buffer */
1532 1.4 oster new_rbuf->which_ru = which_ru;
1533 1.4 oster new_rbuf->failedDiskSectorOffset = fd_offset;
1534 1.4 oster new_rbuf->priority = RF_IO_NORMAL_PRIORITY;
1535 1.4 oster
1536 1.4 oster /* use NULL b_proc b/c all addrs
1537 1.4 oster * should be in kernel space */
1538 1.4 oster req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, offset + which_ru * sectorsPerRU, sectorsPerRU, new_rbuf->buffer,
1539 1.4 oster psid, which_ru, (int (*) (void *, int)) ForceReconReadDoneProc, (void *) new_rbuf, NULL,
1540 1.4 oster NULL, (void *) raidPtr, 0, NULL);
1541 1.4 oster
1542 1.4 oster RF_ASSERT(req); /* XXX -- fix this --
1543 1.4 oster * XXX */
1544 1.4 oster
1545 1.4 oster new_rbuf->arg = req;
1546 1.57 oster rf_DiskIOEnqueue(&raidPtr->Queues[diskno], req, RF_IO_NORMAL_PRIORITY); /* enqueue the I/O */
1547 1.57 oster Dprintf2("raid%d: Issued new read req on col %d\n", raidPtr->raidid, diskno);
1548 1.4 oster }
1549 1.4 oster }
1550 1.4 oster /* if the write is sitting in the disk queue, elevate its
1551 1.4 oster * priority */
1552 1.57 oster if (rf_DiskIOPromote(&raidPtr->Queues[fcol], psid, which_ru))
1553 1.57 oster printf("raid%d: promoted write to col %d\n",
1554 1.57 oster raidPtr->raidid, fcol);
1555 1.4 oster }
1556 1.4 oster /* install a callback descriptor to be invoked when recon completes on
1557 1.4 oster * this parity stripe. */
1558 1.4 oster cb = rf_AllocCallbackDesc();
1559 1.4 oster /* XXX the following is bogus.. These functions don't really match!!
1560 1.4 oster * GO */
1561 1.4 oster cb->callbackFunc = (void (*) (RF_CBParam_t)) cbFunc;
1562 1.4 oster cb->callbackArg.p = (void *) cbArg;
1563 1.4 oster cb->next = pssPtr->procWaitList;
1564 1.4 oster pssPtr->procWaitList = cb;
1565 1.10 oster DDprintf2("raid%d: Waiting for forced recon on psid %ld\n",
1566 1.10 oster raidPtr->raidid, psid);
1567 1.4 oster
1568 1.57 oster RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1569 1.4 oster return (1);
1570 1.1 oster }
1571 1.1 oster /* called upon the completion of a forced reconstruction read.
1572 1.1 oster * all we do is schedule the FORCEDREADONE event.
1573 1.1 oster * called at interrupt context in the kernel, so don't do anything illegal here.
1574 1.1 oster */
1575 1.4 oster static void
1576 1.4 oster ForceReconReadDoneProc(arg, status)
1577 1.4 oster void *arg;
1578 1.4 oster int status;
1579 1.4 oster {
1580 1.4 oster RF_ReconBuffer_t *rbuf = arg;
1581 1.4 oster
1582 1.4 oster if (status) {
1583 1.4 oster printf("Forced recon read failed!\n"); /* fprintf(stderr,"Forced
1584 1.4 oster * recon read
1585 1.4 oster * failed!\n"); */
1586 1.4 oster RF_PANIC();
1587 1.4 oster }
1588 1.57 oster rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->col, (void *) rbuf, RF_REVENT_FORCEDREADDONE);
1589 1.1 oster }
1590 1.1 oster /* releases a block on the reconstruction of the indicated stripe */
1591 1.4 oster int
1592 1.4 oster rf_UnblockRecon(raidPtr, asmap)
1593 1.4 oster RF_Raid_t *raidPtr;
1594 1.4 oster RF_AccessStripeMap_t *asmap;
1595 1.4 oster {
1596 1.4 oster RF_StripeNum_t stripeID = asmap->stripeID;
1597 1.4 oster RF_ReconParityStripeStatus_t *pssPtr;
1598 1.4 oster RF_ReconUnitNum_t which_ru;
1599 1.4 oster RF_StripeNum_t psid;
1600 1.10 oster int created = 0;
1601 1.4 oster RF_CallbackDesc_t *cb;
1602 1.4 oster
1603 1.4 oster psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru);
1604 1.57 oster RF_LOCK_PSS_MUTEX(raidPtr, psid);
1605 1.57 oster pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl->pssTable, psid, which_ru, RF_PSS_NONE, &created);
1606 1.4 oster
1607 1.4 oster /* When recon is forced, the pss desc can get deleted before we get
1608 1.4 oster * back to unblock recon. But, this can _only_ happen when recon is
1609 1.4 oster * forced. It would be good to put some kind of sanity check here, but
1610 1.4 oster * how to decide if recon was just forced or not? */
1611 1.4 oster if (!pssPtr) {
1612 1.4 oster /* printf("Warning: no pss descriptor upon unblock on psid %ld
1613 1.4 oster * RU %d\n",psid,which_ru); */
1614 1.43 oster #if (RF_DEBUG_RECON > 0) || (RF_DEBUG_PSS > 0)
1615 1.4 oster if (rf_reconDebug || rf_pssDebug)
1616 1.4 oster printf("Warning: no pss descriptor upon unblock on psid %ld RU %d\n", (long) psid, which_ru);
1617 1.43 oster #endif
1618 1.4 oster goto out;
1619 1.4 oster }
1620 1.4 oster pssPtr->blockCount--;
1621 1.10 oster Dprintf3("raid%d: unblocking recon on psid %ld: blockcount is %d\n",
1622 1.10 oster raidPtr->raidid, psid, pssPtr->blockCount);
1623 1.4 oster if (pssPtr->blockCount == 0) { /* if recon blockage has been released */
1624 1.4 oster
1625 1.4 oster /* unblock recon before calling CauseReconEvent in case
1626 1.4 oster * CauseReconEvent causes us to try to issue a new read before
1627 1.4 oster * returning here. */
1628 1.4 oster pssPtr->flags &= ~RF_PSS_RECON_BLOCKED;
1629 1.4 oster
1630 1.4 oster
1631 1.13 oster while (pssPtr->blockWaitList) {
1632 1.13 oster /* spin through the block-wait list and
1633 1.13 oster release all the waiters */
1634 1.4 oster cb = pssPtr->blockWaitList;
1635 1.4 oster pssPtr->blockWaitList = cb->next;
1636 1.4 oster cb->next = NULL;
1637 1.57 oster rf_CauseReconEvent(raidPtr, cb->col, NULL, RF_REVENT_BLOCKCLEAR);
1638 1.4 oster rf_FreeCallbackDesc(cb);
1639 1.4 oster }
1640 1.13 oster if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) {
1641 1.13 oster /* if no recon was requested while recon was blocked */
1642 1.57 oster rf_PSStatusDelete(raidPtr, raidPtr->reconControl->pssTable, pssPtr);
1643 1.4 oster }
1644 1.4 oster }
1645 1.1 oster out:
1646 1.57 oster RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1647 1.4 oster return (0);
1648 1.1 oster }
1649