Annotation of sys/dev/raidframe/rf_copyback.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_copyback.c,v 1.8 2007/06/05 00:38:22 deraadt Exp $ */
2: /* $NetBSD: rf_copyback.c,v 1.14 2000/03/07 02:59:50 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Mark Holland
9: *
10: * Permission to use, copy, modify and distribute this software and
11: * its documentation is hereby granted, provided that both the copyright
12: * notice and this permission notice appear in all copies of the
13: * software, derivative works or modified versions, and any portions
14: * thereof, and that both notices appear in supporting documentation.
15: *
16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
19: *
20: * Carnegie Mellon requests users of this software to return to
21: *
22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
23: * School of Computer Science
24: * Carnegie Mellon University
25: * Pittsburgh PA 15213-3890
26: *
27: * any improvements or extensions that they make and grant Carnegie the
28: * rights to redistribute these changes.
29: */
30:
31:
32: /*****************************************************************************
33: *
34: * copyback.c -- Code to copy reconstructed data back from spare space to
35: * the replaced disk.
36: *
37: * The code operates using callbacks on the I/Os to continue with the next
38: * unit to be copied back. We do this because a simple loop containing
39: * blocking I/Os will not work in the simulator.
40: *
41: *****************************************************************************/
42:
43: #include "rf_types.h"
44:
45: #include <sys/time.h>
46: #include <sys/buf.h>
47: #include "rf_raid.h"
48: #include "rf_mcpair.h"
49: #include "rf_acctrace.h"
50: #include "rf_etimer.h"
51: #include "rf_general.h"
52: #include "rf_utils.h"
53: #include "rf_copyback.h"
54: #include "rf_decluster.h"
55: #include "rf_driver.h"
56: #include "rf_shutdown.h"
57: #include "rf_kintf.h"
58:
59: #define RF_COPYBACK_DATA 0
60: #define RF_COPYBACK_PARITY 1
61:
62: int rf_copyback_in_progress;
63:
64: int rf_CopybackReadDoneProc(RF_CopybackDesc_t *, int);
65: int rf_CopybackWriteDoneProc(RF_CopybackDesc_t *, int);
66: void rf_CopybackOne(RF_CopybackDesc_t *, int, RF_RaidAddr_t,
67: RF_RowCol_t, RF_RowCol_t, RF_SectorNum_t);
68: void rf_CopybackComplete(RF_CopybackDesc_t *, int);
69:
70: int
71: rf_ConfigureCopyback(RF_ShutdownList_t **listp)
72: {
73: rf_copyback_in_progress = 0;
74: return (0);
75: }
76:
77: #include <sys/types.h>
78: #include <sys/param.h>
79: #include <sys/systm.h>
80: #include <sys/proc.h>
81: #include <sys/ioctl.h>
82: #include <sys/fcntl.h>
83: #ifdef __NETBSD__
84: #include <sys/vnode.h>
85: #endif
86:
87:
88: /* Do a complete copyback. */
89: void
90: rf_CopybackReconstructedData(RF_Raid_t *raidPtr)
91: {
92: RF_ComponentLabel_t c_label;
93: int done, retcode;
94: RF_CopybackDesc_t *desc;
95: RF_RowCol_t frow, fcol;
96: RF_RaidDisk_t *badDisk;
97: char *databuf;
98:
99: struct partinfo dpart;
100: struct vnode *vp;
101: struct vattr va;
102: struct proc *proc;
103:
104: int ac;
105:
106: done = 0;
107: fcol = 0;
108: for (frow = 0; frow < raidPtr->numRow; frow++) {
109: for (fcol = 0; fcol < raidPtr->numCol; fcol++) {
110: if (raidPtr->Disks[frow][fcol].status ==
111: rf_ds_dist_spared ||
112: raidPtr->Disks[frow][fcol].status ==
113: rf_ds_spared) {
114: done = 1;
115: break;
116: }
117: }
118: if (done)
119: break;
120: }
121:
122: if (frow == raidPtr->numRow) {
123: printf("COPYBACK: No disks need copyback.\n");
124: return;
125: }
126: badDisk = &raidPtr->Disks[frow][fcol];
127:
128: proc = raidPtr->engine_thread;
129:
130: /*
131: * This device may have been opened successfully the first time.
132: * Close it before trying to open it again.
133: */
134:
135: if (raidPtr->raid_cinfo[frow][fcol].ci_vp != NULL) {
136: printf("Close the opened device: %s.\n",
137: raidPtr->Disks[frow][fcol].devname);
138: vp = raidPtr->raid_cinfo[frow][fcol].ci_vp;
139: ac = raidPtr->Disks[frow][fcol].auto_configured;
140: rf_close_component(raidPtr, vp, ac);
141: raidPtr->raid_cinfo[frow][fcol].ci_vp = NULL;
142:
143: }
144: /* Note that this disk was *not* auto_configured (any longer). */
145: raidPtr->Disks[frow][fcol].auto_configured = 0;
146:
147: printf("About to (re-)open the device: %s.\n",
148: raidPtr->Disks[frow][fcol].devname);
149:
150: retcode = raidlookup(raidPtr->Disks[frow][fcol].devname, proc, &vp);
151:
152: if (retcode) {
153: printf("COPYBACK: raidlookup on device: %s failed: %d !\n",
154: raidPtr->Disks[frow][fcol].devname, retcode);
155:
156: /*
157: * XXX The component isn't responding properly... Must be
158: * still dead :-(
159: */
160: return;
161:
162: } else {
163:
164: /*
165: * Ok, so we can at least do a lookup...
166: * How about actually getting a vp for it ?
167: */
168:
169: if ((retcode = VOP_GETATTR(vp, &va, proc->p_ucred, proc)) != 0)
170: {
171: return;
172: }
173: retcode = VOP_IOCTL(vp, DIOCGPART, (caddr_t) &dpart, FREAD,
174: proc->p_ucred, proc);
175: if (retcode) {
176: return;
177: }
178: raidPtr->Disks[frow][fcol].blockSize = dpart.disklab->d_secsize;
179:
180: raidPtr->Disks[frow][fcol].numBlocks = DL_GETPSIZE(dpart.part) -
181: rf_protectedSectors;
182:
183: raidPtr->raid_cinfo[frow][fcol].ci_vp = vp;
184: raidPtr->raid_cinfo[frow][fcol].ci_dev = va.va_rdev;
185:
186: /* XXX Or the above ? */
187: raidPtr->Disks[frow][fcol].dev = va.va_rdev;
188:
189: /*
190: * We allow the user to specify that only a fraction of the
191: * disks should be used this is just for debug: it speeds up
192: * the parity scan.
193: */
194: raidPtr->Disks[frow][fcol].numBlocks =
195: raidPtr->Disks[frow][fcol].numBlocks *
196: rf_sizePercentage / 100;
197: }
198: #if 0
199: /* This is the way it was done before the CAM stuff was removed. */
200:
201: if (rf_extract_ids(badDisk->devname, &bus, &targ, &lun)) {
202: printf("COPYBACK: unable to extract bus, target, lun from"
203: " devname %s.\n", badDisk->devname);
204: return;
205: }
206: /*
207: * TUR the disk that's marked as bad to be sure that it's actually
208: * alive.
209: */
210: rf_SCSI_AllocTUR(&tur_op);
211: retcode = rf_SCSI_DoTUR(tur_op, bus, targ, lun, badDisk->dev);
212: rf_SCSI_FreeDiskOp(tur_op, 0);
213: #endif
214:
215: if (retcode) {
216: printf("COPYBACK: target disk failed TUR.\n");
217: return;
218: }
219: /* Get a buffer to hold one SU. */
220: RF_Malloc(databuf, rf_RaidAddressToByte(raidPtr,
221: raidPtr->Layout.sectorsPerStripeUnit), (char *));
222:
223: /* Create a descriptor. */
224: RF_Malloc(desc, sizeof(*desc), (RF_CopybackDesc_t *));
225: desc->raidPtr = raidPtr;
226: desc->status = 0;
227: desc->frow = frow;
228: desc->fcol = fcol;
229: desc->spRow = badDisk->spareRow;
230: desc->spCol = badDisk->spareCol;
231: desc->stripeAddr = 0;
232: desc->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
233: desc->sectPerStripe = raidPtr->Layout.sectorsPerStripeUnit *
234: raidPtr->Layout.numDataCol;
235: desc->databuf = databuf;
236: desc->mcpair = rf_AllocMCPair();
237:
238: printf("COPYBACK: Quiescing the array.\n");
239: /*
240: * Quiesce the array, since we don't want to code support for user
241: * accs here.
242: */
243: rf_SuspendNewRequestsAndWait(raidPtr);
244:
245: /* Adjust state of the array and of the disks. */
246: RF_LOCK_MUTEX(raidPtr->mutex);
247: raidPtr->Disks[desc->frow][desc->fcol].status = rf_ds_optimal;
248: raidPtr->status[desc->frow] = rf_rs_optimal;
249: rf_copyback_in_progress = 1; /* Debug only. */
250: RF_UNLOCK_MUTEX(raidPtr->mutex);
251:
252: printf("COPYBACK: Beginning\n");
253: RF_GETTIME(desc->starttime);
254: rf_ContinueCopyback(desc);
255:
256: /*
257: * Data has been restored.
258: * Fix up the component label.
259: * Don't actually need the read here.
260: */
261: raidread_component_label(raidPtr->raid_cinfo[frow][fcol].ci_dev,
262: raidPtr->raid_cinfo[frow][fcol].ci_vp,
263: &c_label);
264:
265: raid_init_component_label(raidPtr, &c_label);
266:
267: c_label.row = frow;
268: c_label.column = fcol;
269:
270: raidwrite_component_label(raidPtr->raid_cinfo[frow][fcol].ci_dev,
271: raidPtr->raid_cinfo[frow][fcol].ci_vp,
272: &c_label);
273: }
274:
275:
276: /*
277: * Invoked via callback after a copyback I/O has completed to
278: * continue on with the next one.
279: */
280: void
281: rf_ContinueCopyback(RF_CopybackDesc_t *desc)
282: {
283: RF_SectorNum_t testOffs, stripeAddr;
284: RF_Raid_t *raidPtr = desc->raidPtr;
285: RF_RaidAddr_t addr;
286: RF_RowCol_t testRow, testCol;
287: int old_pctg, new_pctg, done;
288: struct timeval t, diff;
289:
290: old_pctg = (-1);
291: while (1) {
292: stripeAddr = desc->stripeAddr;
293: desc->raidPtr->copyback_stripes_done = stripeAddr /
294: desc->sectPerStripe;
295: if (rf_prReconSched) {
296: old_pctg = 100 * desc->stripeAddr /
297: raidPtr->totalSectors;
298: }
299: desc->stripeAddr += desc->sectPerStripe;
300: if (rf_prReconSched) {
301: new_pctg = 100 * desc->stripeAddr /
302: raidPtr->totalSectors;
303: if (new_pctg != old_pctg) {
304: RF_GETTIME(t);
305: RF_TIMEVAL_DIFF(&desc->starttime, &t, &diff);
306: printf("%d %d.%06d\n", new_pctg,
307: (int) diff.tv_sec, (int) diff.tv_usec);
308: }
309: }
310: if (stripeAddr >= raidPtr->totalSectors) {
311: rf_CopybackComplete(desc, 0);
312: return;
313: }
314: /* Walk through the current stripe, su-by-su. */
315: for (done = 0, addr = stripeAddr;
316: addr < stripeAddr + desc->sectPerStripe;
317: addr += desc->sectPerSU) {
318:
319: /* Map the SU, disallowing remap to spare space. */
320: (raidPtr->Layout.map->MapSector) (raidPtr, addr,
321: &testRow, &testCol, &testOffs, RF_DONT_REMAP);
322:
323: if (testRow == desc->frow && testCol == desc->fcol) {
324: rf_CopybackOne(desc, RF_COPYBACK_DATA, addr,
325: testRow, testCol, testOffs);
326: done = 1;
327: break;
328: }
329: }
330:
331: if (!done) {
332: /*
333: * We didn't find the failed disk in the data part,
334: * check parity.
335: */
336:
337: /*
338: * Map the parity for this stripe, disallowing remap
339: * to spare space.
340: */
341: (raidPtr->Layout.map->MapParity) (raidPtr, stripeAddr,
342: &testRow, &testCol, &testOffs, RF_DONT_REMAP);
343:
344: if (testRow == desc->frow && testCol == desc->fcol) {
345: rf_CopybackOne(desc, RF_COPYBACK_PARITY,
346: stripeAddr, testRow, testCol, testOffs);
347: }
348: }
349: /* Check to see if the last read/write pair failed. */
350: if (desc->status) {
351: rf_CopybackComplete(desc, 1);
352: return;
353: }
354: /*
355: * We didn't find any units to copy back in this stripe.
356: * Continue with the next one.
357: */
358: }
359: }
360:
361:
362: /* Copyback one unit. */
363: void
364: rf_CopybackOne(RF_CopybackDesc_t *desc, int typ, RF_RaidAddr_t addr,
365: RF_RowCol_t testRow, RF_RowCol_t testCol, RF_SectorNum_t testOffs)
366: {
367: RF_SectorCount_t sectPerSU = desc->sectPerSU;
368: RF_Raid_t *raidPtr = desc->raidPtr;
369: RF_RowCol_t spRow = desc->spRow;
370: RF_RowCol_t spCol = desc->spCol;
371: RF_SectorNum_t spOffs;
372:
373: /* Find the spare location for this SU. */
374: if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
375: if (typ == RF_COPYBACK_DATA)
376: raidPtr->Layout.map->MapSector(raidPtr, addr, &spRow,
377: &spCol, &spOffs, RF_REMAP);
378: else
379: raidPtr->Layout.map->MapParity(raidPtr, addr, &spRow,
380: &spCol, &spOffs, RF_REMAP);
381: } else {
382: spOffs = testOffs;
383: }
384:
385: /* Create reqs to read the old location & write the new. */
386: desc->readreq = rf_CreateDiskQueueData(RF_IO_TYPE_READ, spOffs,
387: sectPerSU, desc->databuf, 0L, 0, (int (*) (void *, int))
388: rf_CopybackReadDoneProc, desc, NULL, NULL, (void *) raidPtr,
389: RF_DISKQUEUE_DATA_FLAGS_NONE, NULL);
390: desc->writereq = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, testOffs,
391: sectPerSU, desc->databuf, 0L, 0, (int (*) (void *, int))
392: rf_CopybackWriteDoneProc, desc, NULL, NULL, (void *) raidPtr,
393: RF_DISKQUEUE_DATA_FLAGS_NONE, NULL);
394: desc->frow = testRow;
395: desc->fcol = testCol;
396:
397: /*
398: * Enqueue the read. The write will go out as part of the callback on
399: * the read. At user-level & in the kernel, wait for the read-write
400: * pair to complete. In the simulator, just return, since everything
401: * will happen as callbacks.
402: */
403:
404: RF_LOCK_MUTEX(desc->mcpair->mutex);
405: desc->mcpair->flag = 0;
406:
407: rf_DiskIOEnqueue(&raidPtr->Queues[spRow][spCol], desc->readreq,
408: RF_IO_NORMAL_PRIORITY);
409:
410: while (!desc->mcpair->flag) {
411: RF_WAIT_MCPAIR(desc->mcpair);
412: }
413: RF_UNLOCK_MUTEX(desc->mcpair->mutex);
414: rf_FreeDiskQueueData(desc->readreq);
415: rf_FreeDiskQueueData(desc->writereq);
416:
417: }
418:
419:
420: /*
421: * Called at interrupt context when the read has completed.
422: * Just send out the write.
423: */
424: int
425: rf_CopybackReadDoneProc(RF_CopybackDesc_t *desc, int status)
426: {
427: if (status) { /* Invoke the callback with bad status. */
428: printf("COPYBACK: copyback read failed. Aborting.\n");
429: (desc->writereq->CompleteFunc) (desc, -100);
430: } else {
431: rf_DiskIOEnqueue(&(desc->raidPtr
432: ->Queues[desc->frow][desc->fcol]),
433: desc->writereq, RF_IO_NORMAL_PRIORITY);
434: }
435: return (0);
436: }
437:
438:
439: /*
440: * Called at interrupt context when the write has completed.
441: * At user level & in the kernel, wake up the copyback thread.
442: * In the simulator, invoke the next copyback directly.
443: * Can't free diskqueuedata structs in the kernel because we're at
444: * interrupt context.
445: */
446: int
447: rf_CopybackWriteDoneProc(RF_CopybackDesc_t *desc, int status)
448: {
449: if (status && status != -100) {
450: printf("COPYBACK: copyback write failed. Aborting.\n");
451: }
452: desc->status = status;
453: rf_MCPairWakeupFunc(desc->mcpair);
454: return (0);
455: }
456:
457:
458: /* Invoked when the copyback has completed. */
459: void
460: rf_CopybackComplete(RF_CopybackDesc_t *desc, int status)
461: {
462: RF_Raid_t *raidPtr = desc->raidPtr;
463: struct timeval t, diff;
464:
465: if (!status) {
466: RF_LOCK_MUTEX(raidPtr->mutex);
467: if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
468: RF_ASSERT(raidPtr->Layout.map->parityConfig == 'D');
469: rf_FreeSpareTable(raidPtr);
470: } else {
471: raidPtr->Disks[desc->spRow][desc->spCol].status =
472: rf_ds_spare;
473: }
474: RF_UNLOCK_MUTEX(raidPtr->mutex);
475:
476: RF_GETTIME(t);
477: RF_TIMEVAL_DIFF(&desc->starttime, &t, &diff);
478: printf("Copyback time was %d.%06d seconds.\n",
479: (int) diff.tv_sec, (int) diff.tv_usec);
480: } else
481: printf("COPYBACK: Failure.\n");
482:
483: RF_Free(desc->databuf, rf_RaidAddressToByte(raidPtr, desc->sectPerSU));
484: rf_FreeMCPair(desc->mcpair);
485: RF_Free(desc, sizeof(*desc));
486:
487: rf_copyback_in_progress = 0;
488: rf_ResumeNewRequests(raidPtr);
489: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_copyback.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe