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