1 /* $NetBSD: rf_reconstruct.c,v 1.129 2023/09/17 20:07:39 oster Exp $ */
2 /*
3 * Copyright (c) 1995 Carnegie-Mellon University.
4 * All rights reserved.
5 *
6 * Author: Mark Holland
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 /************************************************************
30 *
31 * rf_reconstruct.c -- code to perform on-line reconstruction
32 *
33 ************************************************************/
34
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: rf_reconstruct.c,v 1.129 2023/09/17 20:07:39 oster Exp $");
37
38 #include <sys/param.h>
39 #include <sys/time.h>
40 #include <sys/buf.h>
41 #include <sys/errno.h>
42 #include <sys/systm.h>
43 #include <sys/proc.h>
44 #include <sys/ioctl.h>
45 #include <sys/fcntl.h>
46 #include <sys/vnode.h>
47 #include <sys/namei.h> /* for pathbuf */
48 #include <dev/raidframe/raidframevar.h>
49
50 #include <miscfs/specfs/specdev.h> /* for v_rdev */
51
52 #include "rf_raid.h"
53 #include "rf_reconutil.h"
54 #include "rf_revent.h"
55 #include "rf_reconbuffer.h"
56 #include "rf_acctrace.h"
57 #include "rf_etimer.h"
58 #include "rf_dag.h"
59 #include "rf_desc.h"
60 #include "rf_debugprint.h"
61 #include "rf_general.h"
62 #include "rf_driver.h"
63 #include "rf_utils.h"
64 #include "rf_shutdown.h"
65
66 #include "rf_kintf.h"
67
68 /* setting these to -1 causes them to be set to their default values if not set by debug options */
69
70 #if RF_DEBUG_RECON
71 #define Dprintf(s) if (rf_reconDebug) rf_debug_printf(s,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)
72 #define Dprintf1(s,a) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
73 #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)
74 #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)
75 #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)
76 #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)
77 #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)
78 #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)
79
80 #define DDprintf1(s,a) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
81 #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)
82
83 #else /* RF_DEBUG_RECON */
84
85 #define Dprintf(s) {}
86 #define Dprintf1(s,a) {}
87 #define Dprintf2(s,a,b) {}
88 #define Dprintf3(s,a,b,c) {}
89 #define Dprintf4(s,a,b,c,d) {}
90 #define Dprintf5(s,a,b,c,d,e) {}
91 #define Dprintf6(s,a,b,c,d,e,f) {}
92 #define Dprintf7(s,a,b,c,d,e,f,g) {}
93
94 #define DDprintf1(s,a) {}
95 #define DDprintf2(s,a,b) {}
96
97 #endif /* RF_DEBUG_RECON */
98
99 #define RF_RECON_DONE_READS 1
100 #define RF_RECON_READ_ERROR 2
101 #define RF_RECON_WRITE_ERROR 3
102 #define RF_RECON_READ_STOPPED 4
103 #define RF_RECON_WRITE_DONE 5
104
105 #define RF_MAX_FREE_RECONBUFFER 32
106 #define RF_MIN_FREE_RECONBUFFER 16
107
108 static RF_RaidReconDesc_t *AllocRaidReconDesc(RF_Raid_t *, RF_RowCol_t,
109 RF_RaidDisk_t *, int, RF_RowCol_t);
110 static void FreeReconDesc(RF_RaidReconDesc_t *);
111 static int ProcessReconEvent(RF_Raid_t *, RF_ReconEvent_t *);
112 static int IssueNextReadRequest(RF_Raid_t *, RF_RowCol_t);
113 static int TryToRead(RF_Raid_t *, RF_RowCol_t);
114 static int ComputePSDiskOffsets(RF_Raid_t *, RF_StripeNum_t, RF_RowCol_t,
115 RF_SectorNum_t *, RF_SectorNum_t *, RF_RowCol_t *,
116 RF_SectorNum_t *);
117 static int IssueNextWriteRequest(RF_Raid_t *);
118 static void ReconReadDoneProc(void *, int);
119 static void ReconWriteDoneProc(void *, int);
120 static void CheckForNewMinHeadSep(RF_Raid_t *, RF_HeadSepLimit_t);
121 static int CheckHeadSeparation(RF_Raid_t *, RF_PerDiskReconCtrl_t *,
122 RF_RowCol_t, RF_HeadSepLimit_t,
123 RF_ReconUnitNum_t);
124 static int CheckForcedOrBlockedReconstruction(RF_Raid_t *,
125 RF_ReconParityStripeStatus_t *,
126 RF_PerDiskReconCtrl_t *,
127 RF_RowCol_t, RF_StripeNum_t,
128 RF_ReconUnitNum_t);
129 static void ForceReconReadDoneProc(void *, int);
130 static void rf_ShutdownReconstruction(void *);
131
132 struct RF_ReconDoneProc_s {
133 void (*proc) (RF_Raid_t *, void *);
134 void *arg;
135 RF_ReconDoneProc_t *next;
136 };
137
138 /**************************************************************************
139 *
140 * sets up the parameters that will be used by the reconstruction process
141 * currently there are none, except for those that the layout-specific
142 * configuration (e.g. rf_ConfigureDeclustered) routine sets up.
143 *
144 * in the kernel, we fire off the recon thread.
145 *
146 **************************************************************************/
147 static void
rf_ShutdownReconstruction(void * arg)148 rf_ShutdownReconstruction(void *arg)
149 {
150 RF_Raid_t *raidPtr;
151
152 raidPtr = (RF_Raid_t *) arg;
153
154 pool_destroy(&raidPtr->pools.reconbuffer);
155 }
156
157 int
rf_ConfigureReconstruction(RF_ShutdownList_t ** listp,RF_Raid_t * raidPtr,RF_Config_t * cfgPtr)158 rf_ConfigureReconstruction(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
159 RF_Config_t *cfgPtr)
160 {
161
162 rf_pool_init(raidPtr, raidPtr->poolNames.reconbuffer, &raidPtr->pools.reconbuffer, sizeof(RF_ReconBuffer_t),
163 "reconbuf", RF_MIN_FREE_RECONBUFFER, RF_MAX_FREE_RECONBUFFER);
164 rf_ShutdownCreate(listp, rf_ShutdownReconstruction, raidPtr);
165
166 return (0);
167 }
168
169 static RF_RaidReconDesc_t *
AllocRaidReconDesc(RF_Raid_t * raidPtr,RF_RowCol_t col,RF_RaidDisk_t * spareDiskPtr,int numDisksDone,RF_RowCol_t scol)170 AllocRaidReconDesc(RF_Raid_t *raidPtr, RF_RowCol_t col,
171 RF_RaidDisk_t *spareDiskPtr, int numDisksDone,
172 RF_RowCol_t scol)
173 {
174
175 RF_RaidReconDesc_t *reconDesc;
176
177 reconDesc = RF_Malloc(sizeof(*reconDesc));
178 reconDesc->raidPtr = raidPtr;
179 reconDesc->col = col;
180 reconDesc->spareDiskPtr = spareDiskPtr;
181 reconDesc->numDisksDone = numDisksDone;
182 reconDesc->scol = scol;
183 reconDesc->next = NULL;
184
185 return (reconDesc);
186 }
187
188 static void
FreeReconDesc(RF_RaidReconDesc_t * reconDesc)189 FreeReconDesc(RF_RaidReconDesc_t *reconDesc)
190 {
191 #if RF_RECON_STATS > 0
192 printf("raid%d: %lu recon event waits, %lu recon delays\n",
193 reconDesc->raidPtr->raidid,
194 (long) reconDesc->numReconEventWaits,
195 (long) reconDesc->numReconExecDelays);
196 #endif /* RF_RECON_STATS > 0 */
197 printf("raid%d: %lu max exec ticks\n",
198 reconDesc->raidPtr->raidid,
199 (long) reconDesc->maxReconExecTicks);
200 RF_Free(reconDesc, sizeof(RF_RaidReconDesc_t));
201 }
202
203
204 /*****************************************************************************
205 *
206 * primary routine to reconstruct a failed disk. This should be called from
207 * within its own thread. It won't return until reconstruction completes,
208 * fails, or is aborted.
209 *****************************************************************************/
210 int
rf_ReconstructFailedDisk(RF_Raid_t * raidPtr,RF_RowCol_t col)211 rf_ReconstructFailedDisk(RF_Raid_t *raidPtr, RF_RowCol_t col)
212 {
213 const RF_LayoutSW_t *lp;
214 int rc;
215
216 lp = raidPtr->Layout.map;
217 if (lp->SubmitReconBuffer) {
218 /*
219 * The current infrastructure only supports reconstructing one
220 * disk at a time for each array.
221 */
222 rf_lock_mutex2(raidPtr->mutex);
223 while (raidPtr->reconInProgress) {
224 rf_wait_cond2(raidPtr->waitForReconCond, raidPtr->mutex);
225 }
226 raidPtr->reconInProgress++;
227 rf_unlock_mutex2(raidPtr->mutex);
228 rc = rf_ReconstructFailedDiskBasic(raidPtr, col);
229 rf_lock_mutex2(raidPtr->mutex);
230 raidPtr->reconInProgress--;
231 } else {
232 RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n",
233 lp->parityConfig);
234 rc = EIO;
235 rf_lock_mutex2(raidPtr->mutex);
236 }
237 rf_signal_cond2(raidPtr->waitForReconCond);
238 rf_unlock_mutex2(raidPtr->mutex);
239 return (rc);
240 }
241
242 int
rf_ReconstructFailedDiskBasic(RF_Raid_t * raidPtr,RF_RowCol_t col)243 rf_ReconstructFailedDiskBasic(RF_Raid_t *raidPtr, RF_RowCol_t col)
244 {
245 RF_ComponentLabel_t *c_label;
246 RF_RaidDisk_t *spareDiskPtr = NULL;
247 RF_RaidReconDesc_t *reconDesc;
248 RF_RowCol_t scol;
249 int numDisksDone = 0, rc;
250
251 /* first look for a spare drive onto which to reconstruct the data */
252 /* spare disk descriptors are stored in row 0. This may have to
253 * change eventually */
254
255 rf_lock_mutex2(raidPtr->mutex);
256 RF_ASSERT(raidPtr->Disks[col].status == rf_ds_failed);
257 #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
258 if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
259 if (raidPtr->status != rf_rs_degraded) {
260 RF_ERRORMSG1("Unable to reconstruct disk at col %d because status not degraded\n", col);
261 rf_unlock_mutex2(raidPtr->mutex);
262 return (EINVAL);
263 }
264 scol = (-1);
265 } else {
266 #endif
267 for (scol = raidPtr->numCol; scol < raidPtr->numCol + raidPtr->numSpare; scol++) {
268 if (raidPtr->Disks[scol].status == rf_ds_spare) {
269 spareDiskPtr = &raidPtr->Disks[scol];
270 spareDiskPtr->status = rf_ds_rebuilding_spare;
271 break;
272 }
273 }
274 if (!spareDiskPtr) {
275 RF_ERRORMSG1("Unable to reconstruct disk at col %d because no spares are available\n", col);
276 rf_unlock_mutex2(raidPtr->mutex);
277 return (ENOSPC);
278 }
279 printf("RECON: initiating reconstruction on col %d -> spare at col %d\n", col, scol);
280 #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
281 }
282 #endif
283 rf_unlock_mutex2(raidPtr->mutex);
284
285 reconDesc = AllocRaidReconDesc((void *) raidPtr, col, spareDiskPtr, numDisksDone, scol);
286 raidPtr->reconDesc = (void *) reconDesc;
287 #if RF_RECON_STATS > 0
288 reconDesc->hsStallCount = 0;
289 reconDesc->numReconExecDelays = 0;
290 reconDesc->numReconEventWaits = 0;
291 #endif /* RF_RECON_STATS > 0 */
292 reconDesc->reconExecTimerRunning = 0;
293 reconDesc->reconExecTicks = 0;
294 reconDesc->maxReconExecTicks = 0;
295 rc = rf_ContinueReconstructFailedDisk(reconDesc);
296
297 if (!rc) {
298 /* fix up the component label. Note that at this point col and scol have swapped places. */
299 /* We need to read from the *spared* disk, but use that label for the real component */
300
301 c_label = raidget_component_label(raidPtr, col);
302
303 raid_init_component_label(raidPtr, c_label);
304 c_label->row = 0;
305 c_label->column = col;
306 c_label->clean = RF_RAID_DIRTY;
307 c_label->status = rf_ds_optimal;
308 rf_component_label_set_partitionsize(c_label,
309 raidPtr->Disks[col].partitionSize);
310
311 /* We've just done a rebuild based on all the other
312 disks, so at this point the parity is known to be
313 clean, even if it wasn't before. */
314
315 /* XXX doesn't hold for RAID 6!!*/
316
317 rf_lock_mutex2(raidPtr->mutex);
318 /* The failed disk has already been marked as rf_ds_spared
319 (or rf_ds_dist_spared) in
320 rf_ContinueReconstructFailedDisk()
321 so we just update the spare disk as being a used spare
322 */
323
324 raidPtr->parity_good = RF_RAID_CLEAN;
325 rf_unlock_mutex2(raidPtr->mutex);
326
327 /* XXXX MORE NEEDED HERE */
328 raidflush_component_label(raidPtr, col);
329 } else {
330 /* Reconstruct failed. */
331
332 rf_lock_mutex2(raidPtr->mutex);
333 /* Failed disk goes back to "failed" status */
334 raidPtr->Disks[col].status = rf_ds_failed;
335
336 /* Spare disk goes back to "spare" status. */
337 spareDiskPtr->status = rf_ds_spare;
338 rf_unlock_mutex2(raidPtr->mutex);
339
340 }
341 rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
342 return (rc);
343 }
344
345 /*
346
347 Allow reconstructing a disk in-place -- i.e. component /dev/sd2e goes AWOL,
348 and you don't get a spare until the next Monday. With this function
349 (and hot-swappable drives) you can now put your new disk containing
350 /dev/sd2e on the bus, scsictl it alive, and then use raidctl(8) to
351 rebuild the data "on the spot".
352
353 */
354
355 int
rf_ReconstructInPlace(RF_Raid_t * raidPtr,RF_RowCol_t col)356 rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col)
357 {
358 RF_RaidDisk_t *spareDiskPtr = NULL;
359 RF_RaidReconDesc_t *reconDesc;
360 const RF_LayoutSW_t *lp;
361 RF_ComponentLabel_t *c_label;
362 int numDisksDone = 0, rc;
363 uint64_t numsec;
364 unsigned int secsize;
365 struct pathbuf *pb;
366 struct vnode *vp;
367 int retcode;
368 int ac;
369
370 rf_lock_mutex2(raidPtr->mutex);
371 lp = raidPtr->Layout.map;
372 if (!lp->SubmitReconBuffer) {
373 RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n",
374 lp->parityConfig);
375 /* wakeup anyone who might be waiting to do a reconstruct */
376 rf_signal_cond2(raidPtr->waitForReconCond);
377 rf_unlock_mutex2(raidPtr->mutex);
378 return(EIO);
379 }
380
381 /*
382 * The current infrastructure only supports reconstructing one
383 * disk at a time for each array.
384 */
385
386 if (raidPtr->Disks[col].status != rf_ds_failed) {
387 /* "It's gone..." */
388 raidPtr->numFailures++;
389 raidPtr->Disks[col].status = rf_ds_failed;
390 raidPtr->status = rf_rs_degraded;
391 rf_unlock_mutex2(raidPtr->mutex);
392 rf_update_component_labels(raidPtr,
393 RF_NORMAL_COMPONENT_UPDATE);
394 rf_lock_mutex2(raidPtr->mutex);
395 }
396
397 while (raidPtr->reconInProgress) {
398 rf_wait_cond2(raidPtr->waitForReconCond, raidPtr->mutex);
399 }
400
401 raidPtr->reconInProgress++;
402
403 /* first look for a spare drive onto which to reconstruct the
404 data. spare disk descriptors are stored in row 0. This
405 may have to change eventually */
406
407 /* Actually, we don't care if it's failed or not... On a RAID
408 set with correct parity, this function should be callable
409 on any component without ill effects. */
410 /* RF_ASSERT(raidPtr->Disks[col].status == rf_ds_failed); */
411
412 #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
413 if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
414 RF_ERRORMSG1("Unable to reconstruct to disk at col %d: operation not supported for RF_DISTRIBUTE_SPARE\n", col);
415
416 raidPtr->reconInProgress--;
417 rf_signal_cond2(raidPtr->waitForReconCond);
418 rf_unlock_mutex2(raidPtr->mutex);
419 return (EINVAL);
420 }
421 #endif
422
423 /* This device may have been opened successfully the
424 first time. Close it before trying to open it again.. */
425
426 if (raidPtr->raid_cinfo[col].ci_vp != NULL) {
427 #if 0
428 printf("Closed the open device: %s\n",
429 raidPtr->Disks[col].devname);
430 #endif
431 vp = raidPtr->raid_cinfo[col].ci_vp;
432 ac = raidPtr->Disks[col].auto_configured;
433 rf_unlock_mutex2(raidPtr->mutex);
434 rf_close_component(raidPtr, vp, ac);
435 rf_lock_mutex2(raidPtr->mutex);
436 raidPtr->raid_cinfo[col].ci_vp = NULL;
437 }
438 /* note that this disk was *not* auto_configured (any longer)*/
439 raidPtr->Disks[col].auto_configured = 0;
440
441 #if 0
442 printf("About to (re-)open the device for rebuilding: %s\n",
443 raidPtr->Disks[col].devname);
444 #endif
445 rf_unlock_mutex2(raidPtr->mutex);
446 pb = pathbuf_create(raidPtr->Disks[col].devname);
447 if (pb == NULL) {
448 retcode = ENOMEM;
449 } else {
450 retcode = vn_bdev_openpath(pb, &vp, curlwp);
451 pathbuf_destroy(pb);
452 }
453
454 if (retcode) {
455 printf("raid%d: rebuilding: open device: %s failed: %d!\n",raidPtr->raidid,
456 raidPtr->Disks[col].devname, retcode);
457
458 /* the component isn't responding properly...
459 must be still dead :-( */
460 rf_lock_mutex2(raidPtr->mutex);
461 raidPtr->reconInProgress--;
462 rf_signal_cond2(raidPtr->waitForReconCond);
463 rf_unlock_mutex2(raidPtr->mutex);
464 return(retcode);
465 }
466
467 /* Ok, so we can at least do a lookup...
468 How about actually getting a vp for it? */
469
470 retcode = getdisksize(vp, &numsec, &secsize);
471 if (retcode) {
472 vn_close(vp, FREAD | FWRITE, kauth_cred_get());
473 rf_lock_mutex2(raidPtr->mutex);
474 raidPtr->reconInProgress--;
475 rf_signal_cond2(raidPtr->waitForReconCond);
476 rf_unlock_mutex2(raidPtr->mutex);
477 return(retcode);
478 }
479 rf_lock_mutex2(raidPtr->mutex);
480 raidPtr->Disks[col].blockSize = secsize;
481 raidPtr->Disks[col].numBlocks = numsec - rf_protectedSectors;
482
483 raidPtr->raid_cinfo[col].ci_vp = vp;
484 raidPtr->raid_cinfo[col].ci_dev = vp->v_rdev;
485
486 raidPtr->Disks[col].dev = vp->v_rdev;
487
488 /* we allow the user to specify that only a fraction
489 of the disks should be used this is just for debug:
490 it speeds up * the parity scan */
491 raidPtr->Disks[col].numBlocks = raidPtr->Disks[col].numBlocks *
492 rf_sizePercentage / 100;
493 rf_unlock_mutex2(raidPtr->mutex);
494
495 spareDiskPtr = &raidPtr->Disks[col];
496 spareDiskPtr->status = rf_ds_rebuilding_spare;
497
498 printf("raid%d: initiating in-place reconstruction on column %d\n",
499 raidPtr->raidid, col);
500
501 reconDesc = AllocRaidReconDesc((void *) raidPtr, col, spareDiskPtr,
502 numDisksDone, col);
503 raidPtr->reconDesc = (void *) reconDesc;
504 #if RF_RECON_STATS > 0
505 reconDesc->hsStallCount = 0;
506 reconDesc->numReconExecDelays = 0;
507 reconDesc->numReconEventWaits = 0;
508 #endif /* RF_RECON_STATS > 0 */
509 reconDesc->reconExecTimerRunning = 0;
510 reconDesc->reconExecTicks = 0;
511 reconDesc->maxReconExecTicks = 0;
512 rc = rf_ContinueReconstructFailedDisk(reconDesc);
513
514 if (!rc) {
515 rf_lock_mutex2(raidPtr->mutex);
516 /* Need to set these here, as at this point it'll be claiming
517 that the disk is in rf_ds_spared! But we know better :-) */
518
519 raidPtr->Disks[col].status = rf_ds_optimal;
520 raidPtr->status = rf_rs_optimal;
521 rf_unlock_mutex2(raidPtr->mutex);
522
523 /* fix up the component label */
524 c_label = raidget_component_label(raidPtr, col);
525
526 rf_lock_mutex2(raidPtr->mutex);
527 raid_init_component_label(raidPtr, c_label);
528
529 c_label->row = 0;
530 c_label->column = col;
531
532 /* We've just done a rebuild based on all the other
533 disks, so at this point the parity is known to be
534 clean, even if it wasn't before. */
535
536 /* XXX doesn't hold for RAID 6!!*/
537
538 raidPtr->parity_good = RF_RAID_CLEAN;
539 rf_unlock_mutex2(raidPtr->mutex);
540
541 raidflush_component_label(raidPtr, col);
542 } else {
543 /* Reconstruct-in-place failed. Disk goes back to
544 "failed" status, regardless of what it was before. */
545 rf_lock_mutex2(raidPtr->mutex);
546 raidPtr->Disks[col].status = rf_ds_failed;
547 rf_unlock_mutex2(raidPtr->mutex);
548 }
549
550 rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
551
552 rf_lock_mutex2(raidPtr->mutex);
553 raidPtr->reconInProgress--;
554 rf_signal_cond2(raidPtr->waitForReconCond);
555 rf_unlock_mutex2(raidPtr->mutex);
556
557 return (rc);
558 }
559
560
561 int
rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t * reconDesc)562 rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *reconDesc)
563 {
564 RF_Raid_t *raidPtr = reconDesc->raidPtr;
565 RF_RowCol_t col = reconDesc->col;
566 RF_RowCol_t scol = reconDesc->scol;
567 RF_ReconMap_t *mapPtr;
568 RF_ReconCtrl_t *tmp_reconctrl;
569 RF_ReconEvent_t *event;
570 RF_StripeCount_t incPSID,lastPSID,num_writes,pending_writes,prev;
571 #if RF_INCLUDE_RAID5_RS > 0
572 RF_StripeCount_t startPSID,endPSID,aPSID,bPSID,offPSID;
573 #endif
574 RF_ReconUnitCount_t RUsPerPU;
575 struct timeval etime, elpsd;
576 unsigned long xor_s, xor_resid_us;
577 int i, ds;
578 int status, done;
579 int recon_error, write_error;
580
581 raidPtr->accumXorTimeUs = 0;
582 #if RF_ACC_TRACE > 0
583 /* create one trace record per physical disk */
584 raidPtr->recon_tracerecs =
585 RF_Malloc(raidPtr->numCol * sizeof(*raidPtr->recon_tracerecs));
586 #endif
587
588 /* quiesce the array prior to starting recon. this is needed
589 * to assure no nasty interactions with pending user writes.
590 * We need to do this before we change the disk or row status. */
591
592 Dprintf("RECON: begin request suspend\n");
593 rf_SuspendNewRequestsAndWait(raidPtr);
594 Dprintf("RECON: end request suspend\n");
595
596 /* allocate our RF_ReconCTRL_t before we protect raidPtr->reconControl[row] */
597 tmp_reconctrl = rf_MakeReconControl(reconDesc, col, scol);
598
599 rf_lock_mutex2(raidPtr->mutex);
600
601 /* create the reconstruction control pointer and install it in
602 * the right slot */
603 raidPtr->reconControl = tmp_reconctrl;
604 mapPtr = raidPtr->reconControl->reconMap;
605 raidPtr->reconControl->numRUsTotal = mapPtr->totalRUs;
606 raidPtr->reconControl->numRUsComplete = 0;
607 raidPtr->status = rf_rs_reconstructing;
608 raidPtr->Disks[col].status = rf_ds_reconstructing;
609 raidPtr->Disks[col].spareCol = scol;
610
611 rf_unlock_mutex2(raidPtr->mutex);
612
613 RF_GETTIME(raidPtr->reconControl->starttime);
614
615 Dprintf("RECON: resume requests\n");
616 rf_ResumeNewRequests(raidPtr);
617
618
619 mapPtr = raidPtr->reconControl->reconMap;
620
621 incPSID = RF_RECONMAP_SIZE;
622 lastPSID = raidPtr->Layout.numStripe / raidPtr->Layout.SUsPerPU - 1;
623 RUsPerPU = raidPtr->Layout.SUsPerPU / raidPtr->Layout.SUsPerRU;
624 recon_error = 0;
625 write_error = 0;
626 pending_writes = incPSID;
627 raidPtr->reconControl->lastPSID = incPSID - 1;
628
629 /* bounds check raidPtr->reconControl->lastPSID and
630 pending_writes so that we don't attempt to wait for more IO
631 than can possibly happen */
632
633 if (raidPtr->reconControl->lastPSID > lastPSID)
634 raidPtr->reconControl->lastPSID = lastPSID;
635
636 if (pending_writes > lastPSID)
637 pending_writes = lastPSID + 1;
638
639 /* start the actual reconstruction */
640
641 done = 0;
642 while (!done) {
643
644 if (raidPtr->waitShutdown ||
645 raidPtr->abortRecon[col]) {
646 /*
647 * someone is unconfiguring this array
648 * or failed a component
649 *... bail on the reconstruct..
650 */
651 recon_error = 1;
652 raidPtr->abortRecon[col] = 0;
653 break;
654 }
655
656 num_writes = 0;
657
658 #if RF_INCLUDE_RAID5_RS > 0
659 /* For RAID5 with Rotated Spares we will be 'short'
660 some number of writes since no writes will get
661 issued for stripes where the spare is on the
662 component being rebuilt. Account for the shortage
663 here so that we don't hang indefinitely below
664 waiting for writes to complete that were never
665 scheduled.
666
667 XXX: Should be fixed for PARITY_DECLUSTERING and
668 others too!
669
670 */
671
672 if (raidPtr->Layout.numDataCol <
673 raidPtr->numCol - raidPtr->Layout.numParityCol) {
674 /* numDataCol is at least 2 less than numCol, so
675 should be RAID 5 with Rotated Spares */
676
677 /* XXX need to update for RAID 6 */
678
679 startPSID = raidPtr->reconControl->lastPSID - pending_writes + 1;
680 endPSID = raidPtr->reconControl->lastPSID;
681
682 offPSID = raidPtr->numCol - col - 1;
683
684 aPSID = startPSID - startPSID % raidPtr->numCol + offPSID;
685 if (aPSID < startPSID) {
686 aPSID += raidPtr->numCol;
687 }
688
689 bPSID = endPSID - ((endPSID - offPSID) % raidPtr->numCol);
690
691 if (aPSID < endPSID) {
692 num_writes = ((bPSID - aPSID) / raidPtr->numCol) + 1;
693 }
694
695 if ((aPSID == endPSID) && (bPSID == endPSID)) {
696 num_writes++;
697 }
698 }
699 #endif
700
701 /* issue a read for each surviving disk */
702
703 reconDesc->numDisksDone = 0;
704 for (i = 0; i < raidPtr->numCol; i++) {
705 if (i != col) {
706 /* find and issue the next I/O on the
707 * indicated disk */
708 if (IssueNextReadRequest(raidPtr, i)) {
709 Dprintf1("RECON: done issuing for c%d\n", i);
710 reconDesc->numDisksDone++;
711 }
712 }
713 }
714
715 /* process reconstruction events until all disks report that
716 * they've completed all work */
717
718 while (reconDesc->numDisksDone < raidPtr->numCol - 1) {
719
720 event = rf_GetNextReconEvent(reconDesc);
721 status = ProcessReconEvent(raidPtr, event);
722
723 /* the normal case is that a read completes, and all is well. */
724 if (status == RF_RECON_DONE_READS) {
725 reconDesc->numDisksDone++;
726 } else if ((status == RF_RECON_READ_ERROR) ||
727 (status == RF_RECON_WRITE_ERROR)) {
728 /* an error was encountered while reconstructing...
729 Pretend we've finished this disk.
730 */
731 recon_error = 1;
732 raidPtr->reconControl->error = 1;
733
734 /* bump the numDisksDone count for reads,
735 but not for writes */
736 if (status == RF_RECON_READ_ERROR)
737 reconDesc->numDisksDone++;
738
739 /* write errors are special -- when we are
740 done dealing with the reads that are
741 finished, we don't want to wait for any
742 writes */
743 if (status == RF_RECON_WRITE_ERROR) {
744 write_error = 1;
745 num_writes++;
746 }
747
748 } else if (status == RF_RECON_READ_STOPPED) {
749 /* count this component as being "done" */
750 reconDesc->numDisksDone++;
751 } else if (status == RF_RECON_WRITE_DONE) {
752 num_writes++;
753 }
754
755 if (recon_error) {
756 /* make sure any stragglers are woken up so that
757 their theads will complete, and we can get out
758 of here with all IO processed */
759
760 rf_WakeupHeadSepCBWaiters(raidPtr);
761 }
762
763 raidPtr->reconControl->numRUsTotal =
764 mapPtr->totalRUs;
765 raidPtr->reconControl->numRUsComplete =
766 mapPtr->totalRUs -
767 rf_UnitsLeftToReconstruct(mapPtr);
768
769 #if RF_DEBUG_RECON
770 raidPtr->reconControl->percentComplete =
771 (raidPtr->reconControl->numRUsComplete * 100 / raidPtr->reconControl->numRUsTotal);
772 if (rf_prReconSched) {
773 rf_PrintReconSchedule(raidPtr->reconControl->reconMap, &(raidPtr->reconControl->starttime));
774 }
775 #endif
776 }
777
778 /* reads done, wakeup any waiters, and then wait for writes */
779
780 rf_WakeupHeadSepCBWaiters(raidPtr);
781
782 while (!recon_error && (num_writes < pending_writes)) {
783 event = rf_GetNextReconEvent(reconDesc);
784 status = ProcessReconEvent(raidPtr, event);
785
786 if (status == RF_RECON_WRITE_ERROR) {
787 num_writes++;
788 recon_error = 1;
789 raidPtr->reconControl->error = 1;
790 /* an error was encountered at the very end... bail */
791 } else if (status == RF_RECON_WRITE_DONE) {
792 num_writes++;
793 } /* else it's something else, and we don't care */
794 }
795 if (recon_error ||
796 (raidPtr->reconControl->lastPSID == lastPSID)) {
797 done = 1;
798 break;
799 }
800
801 prev = raidPtr->reconControl->lastPSID;
802 raidPtr->reconControl->lastPSID += incPSID;
803
804 if (raidPtr->reconControl->lastPSID > lastPSID) {
805 pending_writes = lastPSID - prev;
806 raidPtr->reconControl->lastPSID = lastPSID;
807 }
808 /* back down curPSID to get ready for the next round... */
809 for (i = 0; i < raidPtr->numCol; i++) {
810 if (i != col) {
811 raidPtr->reconControl->perDiskInfo[i].curPSID--;
812 raidPtr->reconControl->perDiskInfo[i].ru_count = RUsPerPU - 1;
813 }
814 }
815 }
816
817 mapPtr = raidPtr->reconControl->reconMap;
818 if (rf_reconDebug) {
819 printf("RECON: all reads completed\n");
820 }
821 /* at this point all the reads have completed. We now wait
822 * for any pending writes to complete, and then we're done */
823
824 while (!recon_error && rf_UnitsLeftToReconstruct(raidPtr->reconControl->reconMap) > 0) {
825
826 event = rf_GetNextReconEvent(reconDesc);
827 status = ProcessReconEvent(raidPtr, event);
828
829 if (status == RF_RECON_WRITE_ERROR) {
830 recon_error = 1;
831 raidPtr->reconControl->error = 1;
832 /* an error was encountered at the very end... bail */
833 } else {
834 #if RF_DEBUG_RECON
835 raidPtr->reconControl->percentComplete = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs);
836 if (rf_prReconSched) {
837 rf_PrintReconSchedule(raidPtr->reconControl->reconMap, &(raidPtr->reconControl->starttime));
838 }
839 #endif
840 }
841 }
842
843 if (recon_error) {
844 /* we've encountered an error in reconstructing. */
845 printf("raid%d: reconstruction failed.\n", raidPtr->raidid);
846
847 /* we start by blocking IO to the RAID set. */
848 rf_SuspendNewRequestsAndWait(raidPtr);
849
850 rf_lock_mutex2(raidPtr->mutex);
851 /* mark set as being degraded, rather than
852 rf_rs_reconstructing as we were before the problem.
853 After this is done we can update status of the
854 component disks without worrying about someone
855 trying to read from a failed component.
856 */
857 raidPtr->status = rf_rs_degraded;
858 rf_unlock_mutex2(raidPtr->mutex);
859
860 /* resume IO */
861 rf_ResumeNewRequests(raidPtr);
862
863 /* At this point there are two cases:
864 1) If we've experienced a read error, then we've
865 already waited for all the reads we're going to get,
866 and we just need to wait for the writes.
867
868 2) If we've experienced a write error, we've also
869 already waited for all the reads to complete,
870 but there is little point in waiting for the writes --
871 when they do complete, they will just be ignored.
872
873 So we just wait for writes to complete if we didn't have a
874 write error.
875 */
876
877 if (!write_error) {
878 /* wait for writes to complete */
879 while (raidPtr->reconControl->pending_writes > 0) {
880
881 event = rf_GetNextReconEvent(reconDesc);
882 status = ProcessReconEvent(raidPtr, event);
883
884 if (status == RF_RECON_WRITE_ERROR) {
885 raidPtr->reconControl->error = 1;
886 /* an error was encountered at the very end... bail.
887 This will be very bad news for the user, since
888 at this point there will have been a read error
889 on one component, and a write error on another!
890 */
891 break;
892 }
893 }
894 }
895
896
897 /* cleanup */
898
899 /* drain the event queue - after waiting for the writes above,
900 there shouldn't be much (if anything!) left in the queue. */
901
902 rf_DrainReconEventQueue(reconDesc);
903
904 rf_FreeReconControl(raidPtr);
905
906 #if RF_ACC_TRACE > 0
907 RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t));
908 #endif
909 FreeReconDesc(reconDesc);
910
911 return (1);
912 }
913
914 /* Success: mark the dead disk as reconstructed. We quiesce
915 * the array here to assure no nasty interactions with pending
916 * user accesses when we free up the psstatus structure as
917 * part of FreeReconControl() */
918
919 rf_SuspendNewRequestsAndWait(raidPtr);
920
921 rf_lock_mutex2(raidPtr->mutex);
922 raidPtr->numFailures--;
923 ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE);
924 raidPtr->Disks[col].status = (ds) ? rf_ds_dist_spared : rf_ds_spared;
925 raidPtr->status = (ds) ? rf_rs_reconfigured : rf_rs_optimal;
926
927 if (col != scol) {
928 /* swap the names, raid_cinfo. queues stay where they are. */
929 rf_swap_components(raidPtr, col, scol);
930
931 /* mark the new spare as good */
932 raidPtr->Disks[col].status = rf_ds_optimal;
933
934 for (i = scol; i < raidPtr->numCol+raidPtr->numSpare-1; i++) {
935 /* now we work our way up the array, swapping as we go. */
936 /* swap with the one at the next position, which must be there */
937 rf_swap_components(raidPtr, i, i+1);
938 }
939 raidPtr->numSpare--;
940 }
941 rf_unlock_mutex2(raidPtr->mutex);
942 RF_GETTIME(etime);
943 RF_TIMEVAL_DIFF(&(raidPtr->reconControl->starttime), &etime, &elpsd);
944
945 rf_ResumeNewRequests(raidPtr);
946
947 printf("raid%d: Reconstruction of disk at col %d completed\n",
948 raidPtr->raidid, col);
949 xor_s = raidPtr->accumXorTimeUs / 1000000;
950 xor_resid_us = raidPtr->accumXorTimeUs % 1000000;
951 printf("raid%d: Recon time was %d.%06d seconds, accumulated XOR time was %ld us (%ld.%06ld)\n",
952 raidPtr->raidid,
953 (int) elpsd.tv_sec, (int) elpsd.tv_usec,
954 raidPtr->accumXorTimeUs, xor_s, xor_resid_us);
955 printf("raid%d: (start time %d sec %d usec, end time %d sec %d usec)\n",
956 raidPtr->raidid,
957 (int) raidPtr->reconControl->starttime.tv_sec,
958 (int) raidPtr->reconControl->starttime.tv_usec,
959 (int) etime.tv_sec, (int) etime.tv_usec);
960 #if RF_RECON_STATS > 0
961 printf("raid%d: Total head-sep stall count was %d\n",
962 raidPtr->raidid, (int) reconDesc->hsStallCount);
963 #endif /* RF_RECON_STATS > 0 */
964 rf_FreeReconControl(raidPtr);
965 #if RF_ACC_TRACE > 0
966 RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t));
967 #endif
968 FreeReconDesc(reconDesc);
969
970 return (0);
971
972 }
973 /*****************************************************************************
974 * do the right thing upon each reconstruction event.
975 *****************************************************************************/
976 static int
ProcessReconEvent(RF_Raid_t * raidPtr,RF_ReconEvent_t * event)977 ProcessReconEvent(RF_Raid_t *raidPtr, RF_ReconEvent_t *event)
978 {
979 int retcode = 0, submitblocked;
980 RF_ReconBuffer_t *rbuf;
981 RF_SectorCount_t sectorsPerRU;
982
983 retcode = RF_RECON_READ_STOPPED;
984
985 Dprintf1("RECON: ProcessReconEvent type %d\n", event->type);
986
987 switch (event->type) {
988
989 /* a read I/O has completed */
990 case RF_REVENT_READDONE:
991 rbuf = raidPtr->reconControl->perDiskInfo[event->col].rbuf;
992 Dprintf2("RECON: READDONE EVENT: col %d psid %ld\n",
993 event->col, rbuf->parityStripeID);
994 Dprintf7("RECON: done read psid %ld buf %lx %02x %02x %02x %02x %02x\n",
995 rbuf->parityStripeID, rbuf->buffer, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff,
996 rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff);
997 rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
998 if (!raidPtr->reconControl->error) {
999 submitblocked = rf_SubmitReconBuffer(rbuf, 0, 0);
1000 Dprintf1("RECON: submitblocked=%d\n", submitblocked);
1001 if (!submitblocked)
1002 retcode = IssueNextReadRequest(raidPtr, event->col);
1003 else
1004 retcode = 0;
1005 }
1006 break;
1007
1008 /* a write I/O has completed */
1009 case RF_REVENT_WRITEDONE:
1010 #if RF_DEBUG_RECON
1011 if (rf_floatingRbufDebug) {
1012 rf_CheckFloatingRbufCount(raidPtr, 1);
1013 }
1014 #endif
1015 sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
1016 rbuf = (RF_ReconBuffer_t *) event->arg;
1017 rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
1018 Dprintf3("RECON: WRITEDONE EVENT: psid %d ru %d (%d %% complete)\n",
1019 rbuf->parityStripeID, rbuf->which_ru, raidPtr->reconControl->percentComplete);
1020 rf_ReconMapUpdate(raidPtr, raidPtr->reconControl->reconMap,
1021 rbuf->failedDiskSectorOffset, rbuf->failedDiskSectorOffset + sectorsPerRU - 1);
1022 rf_RemoveFromActiveReconTable(raidPtr, rbuf->parityStripeID, rbuf->which_ru);
1023
1024 rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
1025 raidPtr->reconControl->pending_writes--;
1026 rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
1027
1028 if (rbuf->type == RF_RBUF_TYPE_FLOATING) {
1029 rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
1030 while(raidPtr->reconControl->rb_lock) {
1031 rf_wait_cond2(raidPtr->reconControl->rb_cv,
1032 raidPtr->reconControl->rb_mutex);
1033 }
1034 raidPtr->reconControl->rb_lock = 1;
1035 rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
1036
1037 raidPtr->numFullReconBuffers--;
1038 rf_ReleaseFloatingReconBuffer(raidPtr, rbuf);
1039
1040 rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
1041 raidPtr->reconControl->rb_lock = 0;
1042 rf_broadcast_cond2(raidPtr->reconControl->rb_cv);
1043 rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
1044 } else
1045 if (rbuf->type == RF_RBUF_TYPE_FORCED)
1046 rf_FreeReconBuffer(rbuf);
1047 else
1048 RF_ASSERT(0);
1049 retcode = RF_RECON_WRITE_DONE;
1050 break;
1051
1052 case RF_REVENT_BUFCLEAR: /* A buffer-stall condition has been
1053 * cleared */
1054 Dprintf1("RECON: BUFCLEAR EVENT: col %d\n", event->col);
1055 if (!raidPtr->reconControl->error) {
1056 submitblocked = rf_SubmitReconBuffer(raidPtr->reconControl->perDiskInfo[event->col].rbuf,
1057 0, (int) (long) event->arg);
1058 RF_ASSERT(!submitblocked); /* we wouldn't have gotten the
1059 * BUFCLEAR event if we
1060 * couldn't submit */
1061 retcode = IssueNextReadRequest(raidPtr, event->col);
1062 }
1063 break;
1064
1065 case RF_REVENT_BLOCKCLEAR: /* A user-write reconstruction
1066 * blockage has been cleared */
1067 DDprintf1("RECON: BLOCKCLEAR EVENT: col %d\n", event->col);
1068 if (!raidPtr->reconControl->error) {
1069 retcode = TryToRead(raidPtr, event->col);
1070 }
1071 break;
1072
1073 case RF_REVENT_HEADSEPCLEAR: /* A max-head-separation
1074 * reconstruction blockage has been
1075 * cleared */
1076 Dprintf1("RECON: HEADSEPCLEAR EVENT: col %d\n", event->col);
1077 if (!raidPtr->reconControl->error) {
1078 retcode = TryToRead(raidPtr, event->col);
1079 }
1080 break;
1081
1082 /* a buffer has become ready to write */
1083 case RF_REVENT_BUFREADY:
1084 Dprintf1("RECON: BUFREADY EVENT: col %d\n", event->col);
1085 if (!raidPtr->reconControl->error) {
1086 retcode = IssueNextWriteRequest(raidPtr);
1087 #if RF_DEBUG_RECON
1088 if (rf_floatingRbufDebug) {
1089 rf_CheckFloatingRbufCount(raidPtr, 1);
1090 }
1091 #endif
1092 }
1093 break;
1094
1095 /* we need to skip the current RU entirely because it got
1096 * recon'd while we were waiting for something else to happen */
1097 case RF_REVENT_SKIP:
1098 DDprintf1("RECON: SKIP EVENT: col %d\n", event->col);
1099 if (!raidPtr->reconControl->error) {
1100 retcode = IssueNextReadRequest(raidPtr, event->col);
1101 }
1102 break;
1103
1104 /* a forced-reconstruction read access has completed. Just
1105 * submit the buffer */
1106 case RF_REVENT_FORCEDREADDONE:
1107 rbuf = (RF_ReconBuffer_t *) event->arg;
1108 rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
1109 DDprintf1("RECON: FORCEDREADDONE EVENT: col %d\n", event->col);
1110 if (!raidPtr->reconControl->error) {
1111 submitblocked = rf_SubmitReconBuffer(rbuf, 1, 0);
1112 RF_ASSERT(!submitblocked);
1113 retcode = 0;
1114 }
1115 break;
1116
1117 /* A read I/O failed to complete */
1118 case RF_REVENT_READ_FAILED:
1119 retcode = RF_RECON_READ_ERROR;
1120 break;
1121
1122 /* A write I/O failed to complete */
1123 case RF_REVENT_WRITE_FAILED:
1124 retcode = RF_RECON_WRITE_ERROR;
1125
1126 /* This is an error, but it was a pending write.
1127 Account for it. */
1128 rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
1129 raidPtr->reconControl->pending_writes--;
1130 rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
1131
1132 rbuf = (RF_ReconBuffer_t *) event->arg;
1133
1134 /* cleanup the disk queue data */
1135 rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
1136
1137 /* At this point we're erroring out, badly, and floatingRbufs
1138 may not even be valid. Rather than putting this back onto
1139 the floatingRbufs list, just arrange for its immediate
1140 destruction.
1141 */
1142 rf_FreeReconBuffer(rbuf);
1143 break;
1144
1145 /* a forced read I/O failed to complete */
1146 case RF_REVENT_FORCEDREAD_FAILED:
1147 retcode = RF_RECON_READ_ERROR;
1148 break;
1149
1150 default:
1151 RF_PANIC();
1152 }
1153 rf_FreeReconEventDesc(raidPtr, event);
1154 return (retcode);
1155 }
1156 /*****************************************************************************
1157 *
1158 * find the next thing that's needed on the indicated disk, and issue
1159 * a read request for it. We assume that the reconstruction buffer
1160 * associated with this process is free to receive the data. If
1161 * reconstruction is blocked on the indicated RU, we issue a
1162 * blockage-release request instead of a physical disk read request.
1163 * If the current disk gets too far ahead of the others, we issue a
1164 * head-separation wait request and return.
1165 *
1166 * ctrl->{ru_count, curPSID, diskOffset} and
1167 * rbuf->failedDiskSectorOffset are maintained to point to the unit
1168 * we're currently accessing. Note that this deviates from the
1169 * standard C idiom of having counters point to the next thing to be
1170 * accessed. This allows us to easily retry when we're blocked by
1171 * head separation or reconstruction-blockage events.
1172 *
1173 *****************************************************************************/
1174 static int
IssueNextReadRequest(RF_Raid_t * raidPtr,RF_RowCol_t col)1175 IssueNextReadRequest(RF_Raid_t *raidPtr, RF_RowCol_t col)
1176 {
1177 RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl->perDiskInfo[col];
1178 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
1179 RF_ReconBuffer_t *rbuf = ctrl->rbuf;
1180 RF_ReconUnitCount_t RUsPerPU = layoutPtr->SUsPerPU / layoutPtr->SUsPerRU;
1181 RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
1182 int do_new_check = 0, retcode = 0, status;
1183
1184 /* if we are currently the slowest disk, mark that we have to do a new
1185 * check */
1186 if (ctrl->headSepCounter <= raidPtr->reconControl->minHeadSepCounter)
1187 do_new_check = 1;
1188
1189 while (1) {
1190
1191 ctrl->ru_count++;
1192 if (ctrl->ru_count < RUsPerPU) {
1193 ctrl->diskOffset += sectorsPerRU;
1194 rbuf->failedDiskSectorOffset += sectorsPerRU;
1195 } else {
1196 ctrl->curPSID++;
1197 ctrl->ru_count = 0;
1198 /* code left over from when head-sep was based on
1199 * parity stripe id */
1200 if (ctrl->curPSID > raidPtr->reconControl->lastPSID) {
1201 CheckForNewMinHeadSep(raidPtr, ++(ctrl->headSepCounter));
1202 return (RF_RECON_DONE_READS); /* finito! */
1203 }
1204 /* find the disk offsets of the start of the parity
1205 * stripe on both the current disk and the failed
1206 * disk. skip this entire parity stripe if either disk
1207 * does not appear in the indicated PS */
1208 status = ComputePSDiskOffsets(raidPtr, ctrl->curPSID, col, &ctrl->diskOffset, &rbuf->failedDiskSectorOffset,
1209 &rbuf->spCol, &rbuf->spOffset);
1210 if (status) {
1211 ctrl->ru_count = RUsPerPU - 1;
1212 continue;
1213 }
1214 }
1215 rbuf->which_ru = ctrl->ru_count;
1216
1217 /* skip this RU if it's already been reconstructed */
1218 if (rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, rbuf->failedDiskSectorOffset)) {
1219 Dprintf2("Skipping psid %ld ru %d: already reconstructed\n", ctrl->curPSID, ctrl->ru_count);
1220 continue;
1221 }
1222 break;
1223 }
1224 ctrl->headSepCounter++;
1225 if (do_new_check)
1226 CheckForNewMinHeadSep(raidPtr, ctrl->headSepCounter); /* update min if needed */
1227
1228
1229 /* at this point, we have definitely decided what to do, and we have
1230 * only to see if we can actually do it now */
1231 rbuf->parityStripeID = ctrl->curPSID;
1232 rbuf->which_ru = ctrl->ru_count;
1233 #if RF_ACC_TRACE > 0
1234 memset(&raidPtr->recon_tracerecs[col], 0,
1235 sizeof(raidPtr->recon_tracerecs[col]));
1236 raidPtr->recon_tracerecs[col].reconacc = 1;
1237 RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
1238 #endif
1239 retcode = TryToRead(raidPtr, col);
1240 return (retcode);
1241 }
1242
1243 /*
1244 * tries to issue the next read on the indicated disk. We may be
1245 * blocked by (a) the heads being too far apart, or (b) recon on the
1246 * indicated RU being blocked due to a write by a user thread. In
1247 * this case, we issue a head-sep or blockage wait request, which will
1248 * cause this same routine to be invoked again later when the blockage
1249 * has cleared.
1250 */
1251
1252 static int
TryToRead(RF_Raid_t * raidPtr,RF_RowCol_t col)1253 TryToRead(RF_Raid_t *raidPtr, RF_RowCol_t col)
1254 {
1255 RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl->perDiskInfo[col];
1256 RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
1257 RF_StripeNum_t psid = ctrl->curPSID;
1258 RF_ReconUnitNum_t which_ru = ctrl->ru_count;
1259 RF_DiskQueueData_t *req;
1260 int status;
1261 RF_ReconParityStripeStatus_t *pssPtr, *newpssPtr;
1262
1263 /* if the current disk is too far ahead of the others, issue a
1264 * head-separation wait and return */
1265 if (CheckHeadSeparation(raidPtr, ctrl, col, ctrl->headSepCounter, which_ru))
1266 return (0);
1267
1268 /* allocate a new PSS in case we need it */
1269 newpssPtr = rf_AllocPSStatus(raidPtr);
1270
1271 RF_LOCK_PSS_MUTEX(raidPtr, psid);
1272 pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl->pssTable, psid, which_ru, RF_PSS_CREATE, newpssPtr);
1273
1274 if (pssPtr != newpssPtr) {
1275 rf_FreePSStatus(raidPtr, newpssPtr);
1276 }
1277
1278 /* if recon is blocked on the indicated parity stripe, issue a
1279 * block-wait request and return. this also must mark the indicated RU
1280 * in the stripe as under reconstruction if not blocked. */
1281 status = CheckForcedOrBlockedReconstruction(raidPtr, pssPtr, ctrl, col, psid, which_ru);
1282 if (status == RF_PSS_RECON_BLOCKED) {
1283 Dprintf2("RECON: Stalling psid %ld ru %d: recon blocked\n", psid, which_ru);
1284 goto out;
1285 } else
1286 if (status == RF_PSS_FORCED_ON_WRITE) {
1287 rf_CauseReconEvent(raidPtr, col, NULL, RF_REVENT_SKIP);
1288 goto out;
1289 }
1290 /* make one last check to be sure that the indicated RU didn't get
1291 * reconstructed while we were waiting for something else to happen.
1292 * This is unfortunate in that it causes us to make this check twice
1293 * in the normal case. Might want to make some attempt to re-work
1294 * this so that we only do this check if we've definitely blocked on
1295 * one of the above checks. When this condition is detected, we may
1296 * have just created a bogus status entry, which we need to delete. */
1297 if (rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, ctrl->rbuf->failedDiskSectorOffset)) {
1298 Dprintf2("RECON: Skipping psid %ld ru %d: prior recon after stall\n", psid, which_ru);
1299 if (pssPtr == newpssPtr)
1300 rf_PSStatusDelete(raidPtr, raidPtr->reconControl->pssTable, pssPtr);
1301 rf_CauseReconEvent(raidPtr, col, NULL, RF_REVENT_SKIP);
1302 goto out;
1303 }
1304 /* found something to read. issue the I/O */
1305 Dprintf4("RECON: Read for psid %ld on col %d offset %ld buf %lx\n",
1306 psid, col, ctrl->diskOffset, ctrl->rbuf->buffer);
1307 #if RF_ACC_TRACE > 0
1308 RF_ETIMER_STOP(raidPtr->recon_tracerecs[col].recon_timer);
1309 RF_ETIMER_EVAL(raidPtr->recon_tracerecs[col].recon_timer);
1310 raidPtr->recon_tracerecs[col].specific.recon.recon_start_to_fetch_us =
1311 RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[col].recon_timer);
1312 RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
1313 #endif
1314 /* should be ok to use a NULL proc pointer here, all the bufs we use
1315 * should be in kernel space */
1316 req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, ctrl->diskOffset, sectorsPerRU, ctrl->rbuf->buffer, psid, which_ru,
1317 ReconReadDoneProc, (void *) ctrl,
1318 #if RF_ACC_TRACE > 0
1319 &raidPtr->recon_tracerecs[col],
1320 #else
1321 NULL,
1322 #endif
1323 (void *) raidPtr, 0, NULL);
1324
1325 ctrl->rbuf->arg = (void *) req;
1326 rf_DiskIOEnqueue(&raidPtr->Queues[col], req, RF_IO_RECON_PRIORITY);
1327 pssPtr->issued[col] = 1;
1328
1329 out:
1330 RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1331 return (0);
1332 }
1333
1334
1335 /*
1336 * given a parity stripe ID, we want to find out whether both the
1337 * current disk and the failed disk exist in that parity stripe. If
1338 * not, we want to skip this whole PS. If so, we want to find the
1339 * disk offset of the start of the PS on both the current disk and the
1340 * failed disk.
1341 *
1342 * this works by getting a list of disks comprising the indicated
1343 * parity stripe, and searching the list for the current and failed
1344 * disks. Once we've decided they both exist in the parity stripe, we
1345 * need to decide whether each is data or parity, so that we'll know
1346 * which mapping function to call to get the corresponding disk
1347 * offsets.
1348 *
1349 * this is kind of unpleasant, but doing it this way allows the
1350 * reconstruction code to use parity stripe IDs rather than physical
1351 * disks address to march through the failed disk, which greatly
1352 * simplifies a lot of code, as well as eliminating the need for a
1353 * reverse-mapping function. I also think it will execute faster,
1354 * since the calls to the mapping module are kept to a minimum.
1355 *
1356 * ASSUMES THAT THE STRIPE IDENTIFIER IDENTIFIES THE DISKS COMPRISING
1357 * THE STRIPE IN THE CORRECT ORDER
1358 *
1359 * raidPtr - raid descriptor
1360 * psid - parity stripe identifier
1361 * col - column of disk to find the offsets for
1362 * spCol - out: col of spare unit for failed unit
1363 * spOffset - out: offset into disk containing spare unit
1364 *
1365 */
1366
1367
1368 static int
ComputePSDiskOffsets(RF_Raid_t * raidPtr,RF_StripeNum_t psid,RF_RowCol_t col,RF_SectorNum_t * outDiskOffset,RF_SectorNum_t * outFailedDiskSectorOffset,RF_RowCol_t * spCol,RF_SectorNum_t * spOffset)1369 ComputePSDiskOffsets(RF_Raid_t *raidPtr, RF_StripeNum_t psid,
1370 RF_RowCol_t col, RF_SectorNum_t *outDiskOffset,
1371 RF_SectorNum_t *outFailedDiskSectorOffset,
1372 RF_RowCol_t *spCol, RF_SectorNum_t *spOffset)
1373 {
1374 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
1375 RF_RowCol_t fcol = raidPtr->reconControl->fcol;
1376 RF_RaidAddr_t sosRaidAddress; /* start-of-stripe */
1377 RF_RowCol_t *diskids;
1378 u_int i, j, k, i_offset, j_offset;
1379 RF_RowCol_t pcol;
1380 int testcol;
1381 RF_SectorNum_t poffset;
1382 char i_is_parity = 0, j_is_parity = 0;
1383 RF_RowCol_t stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
1384
1385 /* get a listing of the disks comprising that stripe */
1386 sosRaidAddress = rf_ParityStripeIDToRaidAddress(layoutPtr, psid);
1387 (layoutPtr->map->IdentifyStripe) (raidPtr, sosRaidAddress, &diskids);
1388 RF_ASSERT(diskids);
1389
1390 /* reject this entire parity stripe if it does not contain the
1391 * indicated disk or it does not contain the failed disk */
1392
1393 for (i = 0; i < stripeWidth; i++) {
1394 if (col == diskids[i])
1395 break;
1396 }
1397 if (i == stripeWidth)
1398 goto skipit;
1399 for (j = 0; j < stripeWidth; j++) {
1400 if (fcol == diskids[j])
1401 break;
1402 }
1403 if (j == stripeWidth) {
1404 goto skipit;
1405 }
1406 /* find out which disk the parity is on */
1407 (layoutPtr->map->MapParity) (raidPtr, sosRaidAddress, &pcol, &poffset, RF_DONT_REMAP);
1408
1409 /* find out if either the current RU or the failed RU is parity */
1410 /* also, if the parity occurs in this stripe prior to the data and/or
1411 * failed col, we need to decrement i and/or j */
1412 for (k = 0; k < stripeWidth; k++)
1413 if (diskids[k] == pcol)
1414 break;
1415 RF_ASSERT(k < stripeWidth);
1416 i_offset = i;
1417 j_offset = j;
1418 if (k < i)
1419 i_offset--;
1420 else
1421 if (k == i) {
1422 i_is_parity = 1;
1423 i_offset = 0;
1424 } /* set offsets to zero to disable multiply
1425 * below */
1426 if (k < j)
1427 j_offset--;
1428 else
1429 if (k == j) {
1430 j_is_parity = 1;
1431 j_offset = 0;
1432 }
1433 /* at this point, [ij]_is_parity tells us whether the [current,failed]
1434 * disk is parity at the start of this RU, and, if data, "[ij]_offset"
1435 * tells us how far into the stripe the [current,failed] disk is. */
1436
1437 /* call the mapping routine to get the offset into the current disk,
1438 * repeat for failed disk. */
1439 if (i_is_parity)
1440 layoutPtr->map->MapParity(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outDiskOffset, RF_DONT_REMAP);
1441 else
1442 layoutPtr->map->MapSector(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outDiskOffset, RF_DONT_REMAP);
1443
1444 RF_ASSERT(col == testcol);
1445
1446 if (j_is_parity)
1447 layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP);
1448 else
1449 layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP);
1450 RF_ASSERT(fcol == testcol);
1451
1452 /* now locate the spare unit for the failed unit */
1453 #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
1454 if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) {
1455 if (j_is_parity)
1456 layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spCol, spOffset, RF_REMAP);
1457 else
1458 layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spCol, spOffset, RF_REMAP);
1459 } else {
1460 #endif
1461 *spCol = raidPtr->reconControl->spareCol;
1462 *spOffset = *outFailedDiskSectorOffset;
1463 #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
1464 }
1465 #endif
1466 return (0);
1467
1468 skipit:
1469 Dprintf2("RECON: Skipping psid %ld: nothing needed from c%d\n",
1470 psid, col);
1471 return (1);
1472 }
1473 /* this is called when a buffer has become ready to write to the replacement disk */
1474 static int
IssueNextWriteRequest(RF_Raid_t * raidPtr)1475 IssueNextWriteRequest(RF_Raid_t *raidPtr)
1476 {
1477 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
1478 RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
1479 #if RF_ACC_TRACE > 0
1480 RF_RowCol_t fcol = raidPtr->reconControl->fcol;
1481 #endif
1482 RF_ReconBuffer_t *rbuf;
1483 RF_DiskQueueData_t *req;
1484
1485 rbuf = rf_GetFullReconBuffer(raidPtr->reconControl);
1486 RF_ASSERT(rbuf); /* there must be one available, or we wouldn't
1487 * have gotten the event that sent us here */
1488 RF_ASSERT(rbuf->pssPtr);
1489
1490 rbuf->pssPtr->writeRbuf = rbuf;
1491 rbuf->pssPtr = NULL;
1492
1493 Dprintf6("RECON: New write (c %d offs %d) for psid %ld ru %d (failed disk offset %ld) buf %lx\n",
1494 rbuf->spCol, rbuf->spOffset, rbuf->parityStripeID,
1495 rbuf->which_ru, rbuf->failedDiskSectorOffset, rbuf->buffer);
1496 Dprintf6("RECON: new write psid %ld %02x %02x %02x %02x %02x\n",
1497 rbuf->parityStripeID, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff,
1498 rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff);
1499
1500 /* should be ok to use a NULL b_proc here b/c all addrs should be in
1501 * kernel space */
1502 req = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, rbuf->spOffset,
1503 sectorsPerRU, rbuf->buffer,
1504 rbuf->parityStripeID, rbuf->which_ru,
1505 ReconWriteDoneProc, (void *) rbuf,
1506 #if RF_ACC_TRACE > 0
1507 &raidPtr->recon_tracerecs[fcol],
1508 #else
1509 NULL,
1510 #endif
1511 (void *) raidPtr, 0, NULL);
1512
1513 rbuf->arg = (void *) req;
1514 rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
1515 raidPtr->reconControl->pending_writes++;
1516 rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
1517 rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spCol], req, RF_IO_RECON_PRIORITY);
1518
1519 return (0);
1520 }
1521
1522 /*
1523 * this gets called upon the completion of a reconstruction read
1524 * operation the arg is a pointer to the per-disk reconstruction
1525 * control structure for the process that just finished a read.
1526 *
1527 * called at interrupt context in the kernel, so don't do anything
1528 * illegal here.
1529 */
1530 static void
ReconReadDoneProc(void * arg,int status)1531 ReconReadDoneProc(void *arg, int status)
1532 {
1533 RF_PerDiskReconCtrl_t *ctrl = (RF_PerDiskReconCtrl_t *) arg;
1534 RF_Raid_t *raidPtr;
1535
1536 /* Detect that reconCtrl is no longer valid, and if that
1537 is the case, bail without calling rf_CauseReconEvent().
1538 There won't be anyone listening for this event anyway */
1539
1540 if (ctrl->reconCtrl == NULL)
1541 return;
1542
1543 raidPtr = ctrl->reconCtrl->reconDesc->raidPtr;
1544
1545 if (status) {
1546 printf("raid%d: Recon read failed: %d\n", raidPtr->raidid, status);
1547 rf_CauseReconEvent(raidPtr, ctrl->col, NULL, RF_REVENT_READ_FAILED);
1548 return;
1549 }
1550 #if RF_ACC_TRACE > 0
1551 RF_ETIMER_STOP(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1552 RF_ETIMER_EVAL(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1553 raidPtr->recon_tracerecs[ctrl->col].specific.recon.recon_fetch_to_return_us =
1554 RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1555 RF_ETIMER_START(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
1556 #endif
1557 rf_CauseReconEvent(raidPtr, ctrl->col, NULL, RF_REVENT_READDONE);
1558 return;
1559 }
1560 /* this gets called upon the completion of a reconstruction write operation.
1561 * the arg is a pointer to the rbuf that was just written
1562 *
1563 * called at interrupt context in the kernel, so don't do anything illegal here.
1564 */
1565 static void
ReconWriteDoneProc(void * arg,int status)1566 ReconWriteDoneProc(void *arg, int status)
1567 {
1568 RF_ReconBuffer_t *rbuf = (RF_ReconBuffer_t *) arg;
1569
1570 /* Detect that reconControl is no longer valid, and if that
1571 is the case, bail without calling rf_CauseReconEvent().
1572 There won't be anyone listening for this event anyway */
1573
1574 if (rbuf->raidPtr->reconControl == NULL)
1575 return;
1576
1577 Dprintf2("Reconstruction completed on psid %ld ru %d\n", rbuf->parityStripeID, rbuf->which_ru);
1578 if (status) {
1579 printf("raid%d: Recon write failed (status %d(0x%x))!\n", rbuf->raidPtr->raidid,status,status);
1580 rf_CauseReconEvent(rbuf->raidPtr, rbuf->col, arg, RF_REVENT_WRITE_FAILED);
1581 return;
1582 }
1583 rf_CauseReconEvent(rbuf->raidPtr, rbuf->col, arg, RF_REVENT_WRITEDONE);
1584 }
1585
1586
1587 /*
1588 * computes a new minimum head sep, and wakes up anyone who needs to
1589 * be woken as a result
1590 */
1591 static void
CheckForNewMinHeadSep(RF_Raid_t * raidPtr,RF_HeadSepLimit_t hsCtr)1592 CheckForNewMinHeadSep(RF_Raid_t *raidPtr, RF_HeadSepLimit_t hsCtr)
1593 {
1594 RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl;
1595 RF_HeadSepLimit_t new_min;
1596 RF_RowCol_t i;
1597 RF_CallbackValueDesc_t *p;
1598 RF_ASSERT(hsCtr >= reconCtrlPtr->minHeadSepCounter); /* from the definition
1599 * of a minimum */
1600
1601
1602 rf_lock_mutex2(reconCtrlPtr->rb_mutex);
1603 while(reconCtrlPtr->rb_lock) {
1604 rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex);
1605 }
1606 reconCtrlPtr->rb_lock = 1;
1607 rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
1608
1609 new_min = ~(1L << (8 * sizeof(long) - 1)); /* 0x7FFF....FFF */
1610 for (i = 0; i < raidPtr->numCol; i++)
1611 if (i != reconCtrlPtr->fcol) {
1612 if (reconCtrlPtr->perDiskInfo[i].headSepCounter < new_min)
1613 new_min = reconCtrlPtr->perDiskInfo[i].headSepCounter;
1614 }
1615 /* set the new minimum and wake up anyone who can now run again */
1616 if (new_min != reconCtrlPtr->minHeadSepCounter) {
1617 reconCtrlPtr->minHeadSepCounter = new_min;
1618 Dprintf1("RECON: new min head pos counter val is %ld\n", new_min);
1619 while (reconCtrlPtr->headSepCBList) {
1620 if (reconCtrlPtr->headSepCBList->v > new_min)
1621 break;
1622 p = reconCtrlPtr->headSepCBList;
1623 reconCtrlPtr->headSepCBList = p->next;
1624 p->next = NULL;
1625 rf_CauseReconEvent(raidPtr, p->col, NULL, RF_REVENT_HEADSEPCLEAR);
1626 rf_FreeCallbackValueDesc(raidPtr, p);
1627 }
1628
1629 }
1630 rf_lock_mutex2(reconCtrlPtr->rb_mutex);
1631 reconCtrlPtr->rb_lock = 0;
1632 rf_broadcast_cond2(reconCtrlPtr->rb_cv);
1633 rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
1634 }
1635
1636 /*
1637 * checks to see that the maximum head separation will not be violated
1638 * if we initiate a reconstruction I/O on the indicated disk.
1639 * Limiting the maximum head separation between two disks eliminates
1640 * the nasty buffer-stall conditions that occur when one disk races
1641 * ahead of the others and consumes all of the floating recon buffers.
1642 * This code is complex and unpleasant but it's necessary to avoid
1643 * some very nasty, albeit fairly rare, reconstruction behavior.
1644 *
1645 * returns non-zero if and only if we have to stop working on the
1646 * indicated disk due to a head-separation delay.
1647 */
1648 static int
CheckHeadSeparation(RF_Raid_t * raidPtr,RF_PerDiskReconCtrl_t * ctrl,RF_RowCol_t col,RF_HeadSepLimit_t hsCtr,RF_ReconUnitNum_t which_ru)1649 CheckHeadSeparation(RF_Raid_t *raidPtr, RF_PerDiskReconCtrl_t *ctrl,
1650 RF_RowCol_t col, RF_HeadSepLimit_t hsCtr,
1651 RF_ReconUnitNum_t which_ru)
1652 {
1653 RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl;
1654 RF_CallbackValueDesc_t *cb, *p, *pt;
1655 int retval = 0;
1656
1657 /* if we're too far ahead of the slowest disk, stop working on this
1658 * disk until the slower ones catch up. We do this by scheduling a
1659 * wakeup callback for the time when the slowest disk has caught up.
1660 * We define "caught up" with 20% hysteresis, i.e. the head separation
1661 * must have fallen to at most 80% of the max allowable head
1662 * separation before we'll wake up.
1663 *
1664 */
1665 rf_lock_mutex2(reconCtrlPtr->rb_mutex);
1666 while(reconCtrlPtr->rb_lock) {
1667 rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex);
1668 }
1669 reconCtrlPtr->rb_lock = 1;
1670 rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
1671 if ((raidPtr->headSepLimit >= 0) &&
1672 ((ctrl->headSepCounter - reconCtrlPtr->minHeadSepCounter) > raidPtr->headSepLimit)) {
1673 Dprintf5("raid%d: RECON: head sep stall: col %d hsCtr %ld minHSCtr %ld limit %ld\n",
1674 raidPtr->raidid, col, ctrl->headSepCounter,
1675 reconCtrlPtr->minHeadSepCounter,
1676 raidPtr->headSepLimit);
1677 cb = rf_AllocCallbackValueDesc(raidPtr);
1678 /* the minHeadSepCounter value we have to get to before we'll
1679 * wake up. build in 20% hysteresis. */
1680 cb->v = (ctrl->headSepCounter - raidPtr->headSepLimit + raidPtr->headSepLimit / 5);
1681 cb->col = col;
1682 cb->next = NULL;
1683
1684 /* insert this callback descriptor into the sorted list of
1685 * pending head-sep callbacks */
1686 p = reconCtrlPtr->headSepCBList;
1687 if (!p)
1688 reconCtrlPtr->headSepCBList = cb;
1689 else
1690 if (cb->v < p->v) {
1691 cb->next = reconCtrlPtr->headSepCBList;
1692 reconCtrlPtr->headSepCBList = cb;
1693 } else {
1694 for (pt = p, p = p->next; p && (p->v < cb->v); pt = p, p = p->next);
1695 cb->next = p;
1696 pt->next = cb;
1697 }
1698 retval = 1;
1699 #if RF_RECON_STATS > 0
1700 ctrl->reconCtrl->reconDesc->hsStallCount++;
1701 #endif /* RF_RECON_STATS > 0 */
1702 }
1703 rf_lock_mutex2(reconCtrlPtr->rb_mutex);
1704 reconCtrlPtr->rb_lock = 0;
1705 rf_broadcast_cond2(reconCtrlPtr->rb_cv);
1706 rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
1707
1708 return (retval);
1709 }
1710 /*
1711 * checks to see if reconstruction has been either forced or blocked
1712 * by a user operation. if forced, we skip this RU entirely. else if
1713 * blocked, put ourselves on the wait list. else return 0.
1714 *
1715 * ASSUMES THE PSS MUTEX IS LOCKED UPON ENTRY
1716 */
1717 static int
CheckForcedOrBlockedReconstruction(RF_Raid_t * raidPtr,RF_ReconParityStripeStatus_t * pssPtr,RF_PerDiskReconCtrl_t * ctrl,RF_RowCol_t col,RF_StripeNum_t psid,RF_ReconUnitNum_t which_ru)1718 CheckForcedOrBlockedReconstruction(RF_Raid_t *raidPtr,
1719 RF_ReconParityStripeStatus_t *pssPtr,
1720 RF_PerDiskReconCtrl_t *ctrl,
1721 RF_RowCol_t col,
1722 RF_StripeNum_t psid,
1723 RF_ReconUnitNum_t which_ru)
1724 {
1725 RF_CallbackValueDesc_t *cb;
1726 int retcode = 0;
1727
1728 if ((pssPtr->flags & RF_PSS_FORCED_ON_READ) || (pssPtr->flags & RF_PSS_FORCED_ON_WRITE))
1729 retcode = RF_PSS_FORCED_ON_WRITE;
1730 else
1731 if (pssPtr->flags & RF_PSS_RECON_BLOCKED) {
1732 Dprintf3("RECON: col %d blocked at psid %ld ru %d\n", col, psid, which_ru);
1733 cb = rf_AllocCallbackValueDesc(raidPtr); /* append ourselves to
1734 * the blockage-wait
1735 * list */
1736 cb->col = col;
1737 cb->next = pssPtr->blockWaitList;
1738 pssPtr->blockWaitList = cb;
1739 retcode = RF_PSS_RECON_BLOCKED;
1740 }
1741 if (!retcode)
1742 pssPtr->flags |= RF_PSS_UNDER_RECON; /* mark this RU as under
1743 * reconstruction */
1744
1745 return (retcode);
1746 }
1747 /*
1748 * if reconstruction is currently ongoing for the indicated stripeID,
1749 * reconstruction is forced to completion and we return non-zero to
1750 * indicate that the caller must wait. If not, then reconstruction is
1751 * blocked on the indicated stripe and the routine returns zero. If
1752 * and only if we return non-zero, we'll cause the cbFunc to get
1753 * invoked with the cbArg when the reconstruction has completed.
1754 */
1755 int
rf_ForceOrBlockRecon(RF_Raid_t * raidPtr,RF_AccessStripeMap_t * asmap,void (* cbFunc)(void *),void * cbArg)1756 rf_ForceOrBlockRecon(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
1757 void (*cbFunc)(void *), void *cbArg)
1758 {
1759 RF_StripeNum_t stripeID = asmap->stripeID; /* the stripe ID we're
1760 * forcing recon on */
1761 RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU; /* num sects in one RU */
1762 RF_ReconParityStripeStatus_t *pssPtr, *newpssPtr; /* a pointer to the parity
1763 * stripe status structure */
1764 RF_StripeNum_t psid; /* parity stripe id */
1765 RF_SectorNum_t offset, fd_offset; /* disk offset, failed-disk
1766 * offset */
1767 RF_RowCol_t *diskids;
1768 RF_ReconUnitNum_t which_ru; /* RU within parity stripe */
1769 RF_RowCol_t fcol, diskno, i;
1770 RF_ReconBuffer_t *new_rbuf; /* ptr to newly allocated rbufs */
1771 RF_DiskQueueData_t *req;/* disk I/O req to be enqueued */
1772 RF_CallbackFuncDesc_t *cb;
1773 int nPromoted;
1774
1775 psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru);
1776
1777 /* allocate a new PSS in case we need it */
1778 newpssPtr = rf_AllocPSStatus(raidPtr);
1779
1780 RF_LOCK_PSS_MUTEX(raidPtr, psid);
1781
1782 pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl->pssTable, psid, which_ru, RF_PSS_CREATE | RF_PSS_RECON_BLOCKED, newpssPtr);
1783
1784 if (pssPtr != newpssPtr) {
1785 rf_FreePSStatus(raidPtr, newpssPtr);
1786 }
1787
1788 /* if recon is not ongoing on this PS, just return */
1789 if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) {
1790 RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1791 return (0);
1792 }
1793 /* otherwise, we have to wait for reconstruction to complete on this
1794 * RU. */
1795 /* In order to avoid waiting for a potentially large number of
1796 * low-priority accesses to complete, we force a normal-priority (i.e.
1797 * not low-priority) reconstruction on this RU. */
1798 if (!(pssPtr->flags & RF_PSS_FORCED_ON_WRITE) && !(pssPtr->flags & RF_PSS_FORCED_ON_READ)) {
1799 DDprintf1("Forcing recon on psid %ld\n", psid);
1800 pssPtr->flags |= RF_PSS_FORCED_ON_WRITE; /* mark this RU as under
1801 * forced recon */
1802 pssPtr->flags &= ~RF_PSS_RECON_BLOCKED; /* clear the blockage
1803 * that we just set */
1804 fcol = raidPtr->reconControl->fcol;
1805
1806 /* get a listing of the disks comprising the indicated stripe */
1807 (raidPtr->Layout.map->IdentifyStripe) (raidPtr, asmap->raidAddress, &diskids);
1808
1809 /* For previously issued reads, elevate them to normal
1810 * priority. If the I/O has already completed, it won't be
1811 * found in the queue, and hence this will be a no-op. For
1812 * unissued reads, allocate buffers and issue new reads. The
1813 * fact that we've set the FORCED bit means that the regular
1814 * recon procs will not re-issue these reqs */
1815 for (i = 0; i < raidPtr->Layout.numDataCol + raidPtr->Layout.numParityCol; i++)
1816 if ((diskno = diskids[i]) != fcol) {
1817 if (pssPtr->issued[diskno]) {
1818 nPromoted = rf_DiskIOPromote(&raidPtr->Queues[diskno], psid, which_ru);
1819 if (rf_reconDebug && nPromoted)
1820 printf("raid%d: promoted read from col %d\n", raidPtr->raidid, diskno);
1821 } else {
1822 new_rbuf = rf_MakeReconBuffer(raidPtr, diskno, RF_RBUF_TYPE_FORCED); /* create new buf */
1823 ComputePSDiskOffsets(raidPtr, psid, diskno, &offset, &fd_offset,
1824 &new_rbuf->spCol, &new_rbuf->spOffset); /* find offsets & spare
1825 * location */
1826 new_rbuf->parityStripeID = psid; /* fill in the buffer */
1827 new_rbuf->which_ru = which_ru;
1828 new_rbuf->failedDiskSectorOffset = fd_offset;
1829 new_rbuf->priority = RF_IO_NORMAL_PRIORITY;
1830
1831 /* use NULL b_proc b/c all addrs
1832 * should be in kernel space */
1833 req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, offset + which_ru * sectorsPerRU, sectorsPerRU, new_rbuf->buffer,
1834 psid, which_ru,
1835 ForceReconReadDoneProc,
1836 (void *) new_rbuf,
1837 NULL, (void *) raidPtr, 0, NULL);
1838
1839 new_rbuf->arg = req;
1840 rf_DiskIOEnqueue(&raidPtr->Queues[diskno], req, RF_IO_NORMAL_PRIORITY); /* enqueue the I/O */
1841 Dprintf2("raid%d: Issued new read req on col %d\n", raidPtr->raidid, diskno);
1842 }
1843 }
1844 /* if the write is sitting in the disk queue, elevate its
1845 * priority */
1846 if (rf_DiskIOPromote(&raidPtr->Queues[fcol], psid, which_ru))
1847 if (rf_reconDebug)
1848 printf("raid%d: promoted write to col %d\n",
1849 raidPtr->raidid, fcol);
1850 }
1851 /* install a callback descriptor to be invoked when recon completes on
1852 * this parity stripe. */
1853 cb = rf_AllocCallbackFuncDesc(raidPtr);
1854 cb->callbackFunc = cbFunc;
1855 cb->callbackArg = cbArg;
1856 cb->next = pssPtr->procWaitList;
1857 pssPtr->procWaitList = cb;
1858 DDprintf2("raid%d: Waiting for forced recon on psid %ld\n",
1859 raidPtr->raidid, psid);
1860
1861 RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1862 return (1);
1863 }
1864 /* called upon the completion of a forced reconstruction read.
1865 * all we do is schedule the FORCEDREADONE event.
1866 * called at interrupt context in the kernel, so don't do anything illegal here.
1867 */
1868 static void
ForceReconReadDoneProc(void * arg,int status)1869 ForceReconReadDoneProc(void *arg, int status)
1870 {
1871 RF_ReconBuffer_t *rbuf = arg;
1872
1873 /* Detect that reconControl is no longer valid, and if that
1874 is the case, bail without calling rf_CauseReconEvent().
1875 There won't be anyone listening for this event anyway */
1876
1877 if (rbuf->raidPtr->reconControl == NULL)
1878 return;
1879
1880 if (status) {
1881 printf("raid%d: Forced recon read failed!\n", rbuf->raidPtr->raidid);
1882 rf_CauseReconEvent(rbuf->raidPtr, rbuf->col, (void *) rbuf, RF_REVENT_FORCEDREAD_FAILED);
1883 return;
1884 }
1885 rf_CauseReconEvent(rbuf->raidPtr, rbuf->col, (void *) rbuf, RF_REVENT_FORCEDREADDONE);
1886 }
1887 /* releases a block on the reconstruction of the indicated stripe */
1888 int
rf_UnblockRecon(RF_Raid_t * raidPtr,RF_AccessStripeMap_t * asmap)1889 rf_UnblockRecon(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
1890 {
1891 RF_StripeNum_t stripeID = asmap->stripeID;
1892 RF_ReconParityStripeStatus_t *pssPtr;
1893 RF_ReconUnitNum_t which_ru;
1894 RF_StripeNum_t psid;
1895 RF_CallbackValueDesc_t *cb;
1896
1897 psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru);
1898 RF_LOCK_PSS_MUTEX(raidPtr, psid);
1899 pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl->pssTable, psid, which_ru, RF_PSS_NONE, NULL);
1900
1901 /* When recon is forced, the pss desc can get deleted before we get
1902 * back to unblock recon. But, this can _only_ happen when recon is
1903 * forced. It would be good to put some kind of sanity check here, but
1904 * how to decide if recon was just forced or not? */
1905 if (!pssPtr) {
1906 /* printf("Warning: no pss descriptor upon unblock on psid %ld
1907 * RU %d\n",psid,which_ru); */
1908 #if (RF_DEBUG_RECON > 0) || (RF_DEBUG_PSS > 0)
1909 if (rf_reconDebug || rf_pssDebug)
1910 printf("Warning: no pss descriptor upon unblock on psid %ld RU %d\n", (long) psid, which_ru);
1911 #endif
1912 goto out;
1913 }
1914 pssPtr->blockCount--;
1915 Dprintf3("raid%d: unblocking recon on psid %ld: blockcount is %d\n",
1916 raidPtr->raidid, psid, pssPtr->blockCount);
1917 if (pssPtr->blockCount == 0) { /* if recon blockage has been released */
1918
1919 /* unblock recon before calling CauseReconEvent in case
1920 * CauseReconEvent causes us to try to issue a new read before
1921 * returning here. */
1922 pssPtr->flags &= ~RF_PSS_RECON_BLOCKED;
1923
1924
1925 while (pssPtr->blockWaitList) {
1926 /* spin through the block-wait list and
1927 release all the waiters */
1928 cb = pssPtr->blockWaitList;
1929 pssPtr->blockWaitList = cb->next;
1930 cb->next = NULL;
1931 rf_CauseReconEvent(raidPtr, cb->col, NULL, RF_REVENT_BLOCKCLEAR);
1932 rf_FreeCallbackValueDesc(raidPtr, cb);
1933 }
1934 if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) {
1935 /* if no recon was requested while recon was blocked */
1936 rf_PSStatusDelete(raidPtr, raidPtr->reconControl->pssTable, pssPtr);
1937 }
1938 }
1939 out:
1940 RF_UNLOCK_PSS_MUTEX(raidPtr, psid);
1941 return (0);
1942 }
1943
1944 void
rf_WakeupHeadSepCBWaiters(RF_Raid_t * raidPtr)1945 rf_WakeupHeadSepCBWaiters(RF_Raid_t *raidPtr)
1946 {
1947 RF_CallbackValueDesc_t *p;
1948
1949 rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
1950 while(raidPtr->reconControl->rb_lock) {
1951 rf_wait_cond2(raidPtr->reconControl->rb_cv,
1952 raidPtr->reconControl->rb_mutex);
1953 }
1954
1955 raidPtr->reconControl->rb_lock = 1;
1956 rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
1957
1958 while (raidPtr->reconControl->headSepCBList) {
1959 p = raidPtr->reconControl->headSepCBList;
1960 raidPtr->reconControl->headSepCBList = p->next;
1961 p->next = NULL;
1962 rf_CauseReconEvent(raidPtr, p->col, NULL, RF_REVENT_HEADSEPCLEAR);
1963 rf_FreeCallbackValueDesc(raidPtr, p);
1964 }
1965 rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
1966 raidPtr->reconControl->rb_lock = 0;
1967 rf_broadcast_cond2(raidPtr->reconControl->rb_cv);
1968 rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
1969
1970 }
1971
1972