![[BACK]](/icons/back.gif){kind=icon}
Return to rf_disks.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_disks.c CVS log | Up to [local] / sys / dev / raidframe |
1.1 nbrk 1: /* $OpenBSD: rf_disks.c,v 1.12 2007/06/05 00:38:22 deraadt Exp $ */
2: /* $NetBSD: rf_disks.c,v 1.31 2000/06/02 01:17:14 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1999 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Greg Oster
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39: /*
40: * Copyright (c) 1995 Carnegie-Mellon University.
41: * All rights reserved.
42: *
43: * Author: Mark Holland
44: *
45: * Permission to use, copy, modify and distribute this software and
46: * its documentation is hereby granted, provided that both the copyright
47: * notice and this permission notice appear in all copies of the
48: * software, derivative works or modified versions, and any portions
49: * thereof, and that both notices appear in supporting documentation.
50: *
51: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
52: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
53: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
54: *
55: * Carnegie Mellon requests users of this software to return to
56: *
57: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
58: * School of Computer Science
59: * Carnegie Mellon University
60: * Pittsburgh PA 15213-3890
61: *
62: * any improvements or extensions that they make and grant Carnegie the
63: * rights to redistribute these changes.
64: */
65:
66: /***************************************************************
67: * rf_disks.c -- Code to perform operations on the actual disks.
68: ***************************************************************/
69:
70: #include "rf_types.h"
71: #include "rf_raid.h"
72: #include "rf_alloclist.h"
73: #include "rf_utils.h"
74: #include "rf_configure.h"
75: #include "rf_general.h"
76: #include "rf_options.h"
77: #include "rf_kintf.h"
78:
79: #if defined(__NetBSD__)
80: #include "rf_netbsd.h"
81: #elif defined(__OpenBSD__)
82: #include "rf_openbsd.h"
83: #endif
84:
85: #include <sys/types.h>
86: #include <sys/param.h>
87: #include <sys/systm.h>
88: #include <sys/proc.h>
89: #include <sys/ioctl.h>
90: #include <sys/fcntl.h>
91: #ifdef __NETBSD__
92: #include <sys/vnode.h>
93: #endif /* __NETBSD__ */
94:
95: int rf_AllocDiskStructures(RF_Raid_t *, RF_Config_t *);
96: void rf_print_label_status(RF_Raid_t *, int, int, char *,
97: RF_ComponentLabel_t *);
98: int rf_check_label_vitals(RF_Raid_t *, int, int, char *,
99: RF_ComponentLabel_t *, int, int);
100:
101: #define DPRINTF6(a,b,c,d,e,f) if (rf_diskDebug) printf(a,b,c,d,e,f)
102: #define DPRINTF7(a,b,c,d,e,f,g) if (rf_diskDebug) printf(a,b,c,d,e,f,g)
103:
104: /****************************************************************************
105: *
106: * Initialize the disks comprising the array.
107: *
108: * We want the spare disks to have regular row,col numbers so that we can
109: * easily substitue a spare for a failed disk. But, the driver code assumes
110: * throughout that the array contains numRow by numCol _non-spare_ disks, so
111: * it's not clear how to fit in the spares. This is an unfortunate holdover
112: * from raidSim. The quick and dirty fix is to make row zero bigger than the
113: * rest, and put all the spares in it. This probably needs to get changed
114: * eventually.
115: *
116: ****************************************************************************/
117: int
118: rf_ConfigureDisks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
119: RF_Config_t *cfgPtr)
120: {
121: RF_RaidDisk_t **disks;
122: RF_SectorCount_t min_numblks = (RF_SectorCount_t) 0x7FFFFFFFFFFFLL;
123: RF_RowCol_t r, c;
124: int bs, ret;
125: unsigned i, count, foundone = 0, numFailuresThisRow;
126: int force;
127:
128: force = cfgPtr->force;
129:
130: ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
131: if (ret)
132: goto fail;
133:
134: disks = raidPtr->Disks;
135:
136: for (r = 0; r < raidPtr->numRow; r++) {
137: numFailuresThisRow = 0;
138: for (c = 0; c < raidPtr->numCol; c++) {
139: ret = rf_ConfigureDisk(raidPtr,
140: &cfgPtr->devnames[r][c][0], &disks[r][c], r, c);
141:
142: if (ret)
143: goto fail;
144:
145: if (disks[r][c].status == rf_ds_optimal) {
146: raidread_component_label(
147: raidPtr->raid_cinfo[r][c].ci_dev,
148: raidPtr->raid_cinfo[r][c].ci_vp,
149: &raidPtr->raid_cinfo[r][c].ci_label);
150: }
151:
152: if (disks[r][c].status != rf_ds_optimal) {
153: numFailuresThisRow++;
154: } else {
155: if (disks[r][c].numBlocks < min_numblks)
156: min_numblks = disks[r][c].numBlocks;
157: DPRINTF7("Disk at row %d col %d: dev %s"
158: " numBlocks %ld blockSize %d (%ld MB)\n",
159: r, c, disks[r][c].devname,
160: (long int) disks[r][c].numBlocks,
161: disks[r][c].blockSize,
162: (long int) disks[r][c].numBlocks *
163: disks[r][c].blockSize / 1024 / 1024);
164: }
165: }
166: /* XXX Fix for n-fault tolerant. */
167: /*
168: * XXX This should probably check to see how many failures
169: * we can handle for this configuration !
170: */
171: if (numFailuresThisRow > 0)
172: raidPtr->status[r] = rf_rs_degraded;
173: }
174: /*
175: * All disks must be the same size & have the same block size, bs must
176: * be a power of 2.
177: */
178: bs = 0;
179: for (foundone = r = 0; !foundone && r < raidPtr->numRow; r++) {
180: for (c = 0; !foundone && c < raidPtr->numCol; c++) {
181: if (disks[r][c].status == rf_ds_optimal) {
182: bs = disks[r][c].blockSize;
183: foundone = 1;
184: }
185: }
186: }
187: if (!foundone) {
188: RF_ERRORMSG("RAIDFRAME: Did not find any live disks in"
189: " the array.\n");
190: ret = EINVAL;
191: goto fail;
192: }
193: for (count = 0, i = 1; i; i <<= 1)
194: if (bs & i)
195: count++;
196: if (count != 1) {
197: RF_ERRORMSG1("Error: block size on disks (%d) must be a"
198: " power of 2.\n", bs);
199: ret = EINVAL;
200: goto fail;
201: }
202:
203: if (rf_CheckLabels(raidPtr, cfgPtr)) {
204: printf("raid%d: There were fatal errors\n", raidPtr->raidid);
205: if (force != 0) {
206: printf("raid%d: Fatal errors being ignored.\n",
207: raidPtr->raidid);
208: } else {
209: ret = EINVAL;
210: goto fail;
211: }
212: }
213:
214: for (r = 0; r < raidPtr->numRow; r++) {
215: for (c = 0; c < raidPtr->numCol; c++) {
216: if (disks[r][c].status == rf_ds_optimal) {
217: if (disks[r][c].blockSize != bs) {
218: RF_ERRORMSG2("Error: block size of"
219: " disk at r %d c %d different from"
220: " disk at r 0 c 0.\n", r, c);
221: ret = EINVAL;
222: goto fail;
223: }
224: if (disks[r][c].numBlocks != min_numblks) {
225: RF_ERRORMSG3("WARNING: truncating disk"
226: " at r %d c %d to %d blocks.\n",
227: r, c, (int) min_numblks);
228: disks[r][c].numBlocks = min_numblks;
229: }
230: }
231: }
232: }
233:
234: raidPtr->sectorsPerDisk = min_numblks;
235: raidPtr->logBytesPerSector = ffs(bs) - 1;
236: raidPtr->bytesPerSector = bs;
237: raidPtr->sectorMask = bs - 1;
238: return (0);
239:
240: fail:
241: rf_UnconfigureVnodes(raidPtr);
242:
243: return (ret);
244: }
245:
246:
247: /****************************************************************************
248: * Set up the data structures describing the spare disks in the array.
249: * Recall from the above comment that the spare disk descriptors are stored
250: * in row zero, which is specially expanded to hold them.
251: ****************************************************************************/
252: int
253: rf_ConfigureSpareDisks(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
254: RF_Config_t * cfgPtr)
255: {
256: int i, ret;
257: unsigned int bs;
258: RF_RaidDisk_t *disks;
259: int num_spares_done;
260:
261: num_spares_done = 0;
262:
263: /*
264: * The space for the spares should have already been allocated by
265: * ConfigureDisks().
266: */
267:
268: disks = &raidPtr->Disks[0][raidPtr->numCol];
269: for (i = 0; i < raidPtr->numSpare; i++) {
270: ret = rf_ConfigureDisk(raidPtr, &cfgPtr->spare_names[i][0],
271: &disks[i], 0, raidPtr->numCol + i);
272: if (ret)
273: goto fail;
274: if (disks[i].status != rf_ds_optimal) {
275: RF_ERRORMSG1("Warning: spare disk %s failed TUR\n",
276: &cfgPtr->spare_names[i][0]);
277: } else {
278: /* Change status to spare. */
279: disks[i].status = rf_ds_spare;
280: DPRINTF6("Spare Disk %d: dev %s numBlocks %ld"
281: " blockSize %d (%ld MB).\n", i, disks[i].devname,
282: (long int) disks[i].numBlocks, disks[i].blockSize,
283: (long int) disks[i].numBlocks *
284: disks[i].blockSize / 1024 / 1024);
285: }
286: num_spares_done++;
287: }
288:
289: /* Check sizes and block sizes on spare disks. */
290: bs = 1 << raidPtr->logBytesPerSector;
291: for (i = 0; i < raidPtr->numSpare; i++) {
292: if (disks[i].blockSize != bs) {
293: RF_ERRORMSG3("Block size of %d on spare disk %s is"
294: " not the same as on other disks (%d).\n",
295: disks[i].blockSize, disks[i].devname, bs);
296: ret = EINVAL;
297: goto fail;
298: }
299: if (disks[i].numBlocks < raidPtr->sectorsPerDisk) {
300: RF_ERRORMSG3("Spare disk %s (%llu blocks) is too small"
301: " to serve as a spare (need %llu blocks).\n",
302: disks[i].devname, disks[i].numBlocks,
303: raidPtr->sectorsPerDisk);
304: ret = EINVAL;
305: goto fail;
306: } else
307: if (disks[i].numBlocks > raidPtr->sectorsPerDisk) {
308: RF_ERRORMSG2("Warning: truncating spare disk"
309: " %s to %llu blocks.\n", disks[i].devname,
310: raidPtr->sectorsPerDisk);
311:
312: disks[i].numBlocks = raidPtr->sectorsPerDisk;
313: }
314: }
315:
316: return (0);
317:
318: fail:
319:
320: /*
321: * Release the hold on the main components. We've failed to allocate
322: * a spare, and since we're failing, we need to free things...
323: *
324: * XXX Failing to allocate a spare is *not* that big of a deal...
325: * We *can* survive without it, if need be, esp. if we get hot
326: * adding working.
327: * If we don't fail out here, then we need a way to remove this spare...
328: * That should be easier to do here than if we are "live"...
329: */
330:
331: rf_UnconfigureVnodes(raidPtr);
332:
333: return (ret);
334: }
335:
336: int
337: rf_AllocDiskStructures(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
338: {
339: RF_RaidDisk_t **disks;
340: int ret;
341: int r;
342:
343: RF_CallocAndAdd(disks, raidPtr->numRow, sizeof(RF_RaidDisk_t *),
344: (RF_RaidDisk_t **), raidPtr->cleanupList);
345: if (disks == NULL) {
346: ret = ENOMEM;
347: goto fail;
348: }
349: raidPtr->Disks = disks;
350: /* Get space for the device-specific stuff... */
351: RF_CallocAndAdd(raidPtr->raid_cinfo, raidPtr->numRow,
352: sizeof(struct raidcinfo *), (struct raidcinfo **),
353: raidPtr->cleanupList);
354: if (raidPtr->raid_cinfo == NULL) {
355: ret = ENOMEM;
356: goto fail;
357: }
358:
359: for (r = 0; r < raidPtr->numRow; r++) {
360: /*
361: * We allocate RF_MAXSPARE on the first row so that we
362: * have room to do hot-swapping of spares.
363: */
364: RF_CallocAndAdd(disks[r], raidPtr->numCol +
365: ((r == 0) ? RF_MAXSPARE : 0), sizeof(RF_RaidDisk_t),
366: (RF_RaidDisk_t *), raidPtr->cleanupList);
367: if (disks[r] == NULL) {
368: ret = ENOMEM;
369: goto fail;
370: }
371: /* Get more space for device specific stuff... */
372: RF_CallocAndAdd(raidPtr->raid_cinfo[r], raidPtr->numCol +
373: ((r == 0) ? raidPtr->numSpare : 0),
374: sizeof(struct raidcinfo), (struct raidcinfo *),
375: raidPtr->cleanupList);
376: if (raidPtr->raid_cinfo[r] == NULL) {
377: ret = ENOMEM;
378: goto fail;
379: }
380: }
381: return(0);
382: fail:
383: rf_UnconfigureVnodes(raidPtr);
384:
385: return(ret);
386: }
387:
388:
389: /* Configure a single disk during auto-configuration at boot. */
390: int
391: rf_AutoConfigureDisks(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr,
392: RF_AutoConfig_t *auto_config)
393: {
394: RF_RaidDisk_t **disks;
395: RF_RaidDisk_t *diskPtr;
396: RF_RowCol_t r, c;
397: RF_SectorCount_t min_numblks = (RF_SectorCount_t) 0x7FFFFFFFFFFFLL;
398: int bs, ret;
399: int numFailuresThisRow;
400: int force;
401: RF_AutoConfig_t *ac;
402: int parity_good;
403: int mod_counter;
404: int mod_counter_found;
405:
406: #if DEBUG
407: printf("Starting autoconfiguration of RAID set...\n");
408: #endif /* DEBUG */
409: force = cfgPtr->force;
410:
411: ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
412: if (ret)
413: goto fail;
414:
415: disks = raidPtr->Disks;
416:
417: /* Assume the parity will be fine... */
418: parity_good = RF_RAID_CLEAN;
419:
420: /* Check for mod_counters that are too low. */
421: mod_counter_found = 0;
422: ac = auto_config;
423: while(ac!=NULL) {
424: if (mod_counter_found == 0) {
425: mod_counter = ac->clabel->mod_counter;
426: mod_counter_found = 1;
427: } else {
428: if (ac->clabel->mod_counter > mod_counter) {
429: mod_counter = ac->clabel->mod_counter;
430: }
431: }
432: ac->flag = 0; /* Clear the general purpose flag. */
433: ac = ac->next;
434: }
435:
436: for (r = 0; r < raidPtr->numRow; r++) {
437: numFailuresThisRow = 0;
438: for (c = 0; c < raidPtr->numCol; c++) {
439: diskPtr = &disks[r][c];
440:
441: /* Find this row/col in the autoconfig. */
442: #if DEBUG
443: printf("Looking for %d,%d in autoconfig.\n", r, c);
444: #endif /* DEBUG */
445: ac = auto_config;
446: while(ac!=NULL) {
447: if (ac->clabel == NULL) {
448: /* Big-time bad news. */
449: goto fail;
450: }
451: if ((ac->clabel->row == r) &&
452: (ac->clabel->column == c) &&
453: (ac->clabel->mod_counter == mod_counter)) {
454: /* It's this one... */
455: /*
456: * Flag it as 'used', so we don't
457: * free it later.
458: */
459: ac->flag = 1;
460: #if DEBUG
461: printf("Found: %s at %d,%d.\n",
462: ac->devname, r, c);
463: #endif /* DEBUG */
464:
465: break;
466: }
467: ac = ac->next;
468: }
469:
470: if (ac == NULL) {
471: /*
472: * We didn't find an exact match with a
473: * correct mod_counter above... Can we
474: * find one with an incorrect mod_counter
475: * to use instead ? (This one, if we find
476: * it, will be marked as failed once the
477: * set configures)
478: */
479:
480: ac = auto_config;
481: while(ac!=NULL) {
482: if (ac->clabel == NULL) {
483: /* Big-time bad news. */
484: goto fail;
485: }
486: if ((ac->clabel->row == r) &&
487: (ac->clabel->column == c)) {
488: /*
489: * It's this one...
490: * Flag it as 'used', so we
491: * don't free it later.
492: */
493: ac->flag = 1;
494: #if DEBUG
495: printf("Found(low mod_counter)"
496: ": %s at %d,%d.\n",
497: ac->devname, r, c);
498: #endif /* DEBUG */
499:
500: break;
501: }
502: ac = ac->next;
503: }
504: }
505:
506:
507:
508: if (ac!=NULL) {
509: /* Found it. Configure it... */
510: diskPtr->blockSize = ac->clabel->blockSize;
511: diskPtr->numBlocks = ac->clabel->numBlocks;
512: /*
513: * Note: rf_protectedSectors is already
514: * factored into numBlocks here.
515: */
516: raidPtr->raid_cinfo[r][c].ci_vp = ac->vp;
517: raidPtr->raid_cinfo[r][c].ci_dev = ac->dev;
518:
519: memcpy(&raidPtr->raid_cinfo[r][c].ci_label,
520: ac->clabel, sizeof(*ac->clabel));
521: snprintf(diskPtr->devname,
522: sizeof diskPtr->devname, "/dev/%s",
523: ac->devname);
524:
525: /*
526: * Note the fact that this component was
527: * autoconfigured. You'll need this info
528: * later. Trust me :)
529: */
530: diskPtr->auto_configured = 1;
531: diskPtr->dev = ac->dev;
532:
533: /*
534: * We allow the user to specify that
535: * only a fraction of the disks should
536: * be used. This is just for debug: it
537: * speeds up the parity scan.
538: */
539:
540: diskPtr->numBlocks = diskPtr->numBlocks *
541: rf_sizePercentage / 100;
542:
543: /*
544: * XXX These will get set multiple times,
545: * but since we're autoconfiguring, they'd
546: * better be always the same each time !
547: * If not, this is the least of your worries.
548: */
549:
550: bs = diskPtr->blockSize;
551: min_numblks = diskPtr->numBlocks;
552:
553: /*
554: * This gets done multiple times, but that's
555: * fine -- the serial number will be the same
556: * for all components, guaranteed.
557: */
558: raidPtr->serial_number =
559: ac->clabel->serial_number;
560: /*
561: * Check the last time the label
562: * was modified.
563: */
564: if (ac->clabel->mod_counter != mod_counter) {
565: /*
566: * Even though we've filled in all
567: * of the above, we don't trust
568: * this component since it's
569: * modification counter is not
570: * in sync with the rest, and we really
571: * consider it to be failed.
572: */
573: disks[r][c].status = rf_ds_failed;
574: numFailuresThisRow++;
575: } else {
576: if (ac->clabel->clean != RF_RAID_CLEAN)
577: {
578: parity_good = RF_RAID_DIRTY;
579: }
580: }
581: } else {
582: /*
583: * Didn't find it at all !!!
584: * Component must really be dead.
585: */
586: disks[r][c].status = rf_ds_failed;
587: snprintf(disks[r][c].devname,
588: sizeof disks[r][c].devname, "component%d",
589: r * raidPtr->numCol + c);
590: numFailuresThisRow++;
591: }
592: }
593: /* XXX Fix for n-fault tolerant. */
594: /*
595: * XXX This should probably check to see how many failures
596: * we can handle for this configuration !
597: */
598: if (numFailuresThisRow > 0)
599: raidPtr->status[r] = rf_rs_degraded;
600: }
601:
602: /* Close the device for the ones that didn't get used. */
603:
604: ac = auto_config;
605: while(ac != NULL) {
606: if (ac->flag == 0) {
607: VOP_CLOSE(ac->vp, FREAD, NOCRED, 0);
608: vput(ac->vp);
609: ac->vp = NULL;
610: #if DEBUG
611: printf("Released %s from auto-config set.\n",
612: ac->devname);
613: #endif /* DEBUG */
614: }
615: ac = ac->next;
616: }
617:
618: raidPtr->mod_counter = mod_counter;
619:
620: /* Note the state of the parity, if any. */
621: raidPtr->parity_good = parity_good;
622: raidPtr->sectorsPerDisk = min_numblks;
623: raidPtr->logBytesPerSector = ffs(bs) - 1;
624: raidPtr->bytesPerSector = bs;
625: raidPtr->sectorMask = bs - 1;
626: return (0);
627:
628: fail:
629:
630: rf_UnconfigureVnodes(raidPtr);
631:
632: return (ret);
633:
634: }
635:
636: /* Configure a single disk in the array. */
637: int
638: rf_ConfigureDisk(RF_Raid_t *raidPtr, char *buf, RF_RaidDisk_t *diskPtr,
639: RF_RowCol_t row, RF_RowCol_t col)
640: {
641: char *p;
642: int retcode;
643:
644: struct partinfo dpart;
645: struct vnode *vp;
646: struct vattr va;
647: struct proc *proc;
648: int error;
649:
650: retcode = 0;
651: p = rf_find_non_white(buf);
652: if (*buf != '\0' && p[strlen(p) - 1] == '\n') {
653: /* Strip off the newline. */
654: p[strlen(p) - 1] = '\0';
655: }
656: (void) strlcpy(diskPtr->devname, p, sizeof diskPtr->devname);
657:
658: proc = raidPtr->engine_thread;
659:
660: /* Let's start by claiming the component is fine and well... */
661: diskPtr->status = rf_ds_optimal;
662:
663: raidPtr->raid_cinfo[row][col].ci_vp = NULL;
664: raidPtr->raid_cinfo[row][col].ci_dev = NULL;
665:
666: error = raidlookup(diskPtr->devname, curproc, &vp);
667: if (error) {
668: printf("raidlookup on device: %s failed !\n", diskPtr->devname);
669: if (error == ENXIO) {
670: /* The component isn't there... Must be dead :-( */
671: diskPtr->status = rf_ds_failed;
672: } else {
673: return (error);
674: }
675: }
676: if (diskPtr->status == rf_ds_optimal) {
677:
678: if ((error = VOP_GETATTR(vp, &va, proc->p_ucred, proc)) != 0) {
679: return (error);
680: }
681: error = VOP_IOCTL(vp, DIOCGPART, (caddr_t) & dpart, FREAD,
682: proc->p_ucred, proc);
683: if (error) {
684: return (error);
685: }
686: diskPtr->blockSize = dpart.disklab->d_secsize;
687:
688: diskPtr->numBlocks = DL_GETPSIZE(dpart.part) - rf_protectedSectors;
689: diskPtr->partitionSize = DL_GETPSIZE(dpart.part);
690:
691: raidPtr->raid_cinfo[row][col].ci_vp = vp;
692: raidPtr->raid_cinfo[row][col].ci_dev = va.va_rdev;
693:
694: /* This component was not automatically configured. */
695: diskPtr->auto_configured = 0;
696: diskPtr->dev = va.va_rdev;
697:
698: /*
699: * We allow the user to specify that only a fraction of the
700: * disks should be used. This is just for debug: it speeds up
701: * the parity scan.
702: */
703: diskPtr->numBlocks = diskPtr->numBlocks * rf_sizePercentage
704: / 100;
705: }
706: return (0);
707: }
708:
709: void
710: rf_print_label_status(RF_Raid_t *raidPtr, int row, int column, char *dev_name,
711: RF_ComponentLabel_t *ci_label)
712: {
713:
714: printf("raid%d: Component %s being configured at row: %d col: %d\n",
715: raidPtr->raidid, dev_name, row, column);
716: printf(" Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
717: ci_label->row, ci_label->column, ci_label->num_rows,
718: ci_label->num_columns);
719: printf(" Version: %d Serial Number: %d Mod Counter: %d\n",
720: ci_label->version, ci_label->serial_number, ci_label->mod_counter);
721: printf(" Clean: %s Status: %d\n",
722: ci_label->clean ? "Yes" : "No", ci_label->status);
723: }
724:
725: int
726: rf_check_label_vitals(RF_Raid_t *raidPtr, int row, int column, char *dev_name,
727: RF_ComponentLabel_t *ci_label, int serial_number, int mod_counter)
728: {
729: int fatal_error = 0;
730:
731: if (serial_number != ci_label->serial_number) {
732: printf("%s has a different serial number: %d %d.\n",
733: dev_name, serial_number, ci_label->serial_number);
734: fatal_error = 1;
735: }
736: if (mod_counter != ci_label->mod_counter) {
737: printf("%s has a different modfication count: %d %d.\n",
738: dev_name, mod_counter, ci_label->mod_counter);
739: }
740:
741: if (row != ci_label->row) {
742: printf("Row out of alignment for: %s.\n", dev_name);
743: fatal_error = 1;
744: }
745: if (column != ci_label->column) {
746: printf("Column out of alignment for: %s.\n", dev_name);
747: fatal_error = 1;
748: }
749: if (raidPtr->numRow != ci_label->num_rows) {
750: printf("Number of rows do not match for: %s.\n", dev_name);
751: fatal_error = 1;
752: }
753: if (raidPtr->numCol != ci_label->num_columns) {
754: printf("Number of columns do not match for: %s.\n", dev_name);
755: fatal_error = 1;
756: }
757: if (ci_label->clean == 0) {
758: /* It's not clean, but that's not fatal. */
759: printf("%s is not clean !\n", dev_name);
760: }
761: return(fatal_error);
762: }
763:
764:
765: /*
766: *
767: * rf_CheckLabels() - Check all the component labels for consistency.
768: * Return an error if there is anything major amiss.
769: *
770: */
771:
772: int
773: rf_CheckLabels(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
774: {
775: int r, c;
776: char *dev_name;
777: RF_ComponentLabel_t *ci_label;
778: int serial_number = 0;
779: int mod_number = 0;
780: int fatal_error = 0;
781: int mod_values[4];
782: int mod_count[4];
783: int ser_values[4];
784: int ser_count[4];
785: int num_ser;
786: int num_mod;
787: int i;
788: int found;
789: int hosed_row;
790: int hosed_column;
791: int too_fatal;
792: int parity_good;
793: int force;
794:
795: hosed_row = -1;
796: hosed_column = -1;
797: too_fatal = 0;
798: force = cfgPtr->force;
799:
800: /*
801: * We're going to try to be a little intelligent here. If one
802: * component's label is bogus, and we can identify that it's the
803: * *only* one that's gone, we'll mark it as "failed" and allow
804: * the configuration to proceed. This will be the *only* case
805: * that we'll proceed if there would be (otherwise) fatal errors.
806: *
807: * Basically we simply keep a count of how many components had
808: * what serial number. If all but one agree, we simply mark
809: * the disagreeing component as being failed, and allow
810: * things to come up "normally".
811: *
812: * We do this first for serial numbers, and then for "mod_counter".
813: *
814: */
815:
816: num_ser = 0;
817: num_mod = 0;
818: for (r = 0; r < raidPtr->numRow && !fatal_error; r++) {
819: for (c = 0; c < raidPtr->numCol; c++) {
820: ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
821: found = 0;
822: for(i = 0; i < num_ser; i++) {
823: if (ser_values[i] == ci_label->serial_number) {
824: ser_count[i]++;
825: found = 1;
826: break;
827: }
828: }
829: if (!found) {
830: ser_values[num_ser] = ci_label->serial_number;
831: ser_count[num_ser] = 1;
832: num_ser++;
833: if (num_ser > 2) {
834: fatal_error = 1;
835: break;
836: }
837: }
838: found = 0;
839: for(i = 0; i < num_mod; i++) {
840: if (mod_values[i] == ci_label->mod_counter) {
841: mod_count[i]++;
842: found = 1;
843: break;
844: }
845: }
846: if (!found) {
847: mod_values[num_mod] = ci_label->mod_counter;
848: mod_count[num_mod] = 1;
849: num_mod++;
850: if (num_mod > 2) {
851: fatal_error = 1;
852: break;
853: }
854: }
855: }
856: }
857: #if DEBUG
858: printf("raid%d: Summary of serial numbers:\n", raidPtr->raidid);
859: for(i = 0; i < num_ser; i++) {
860: printf("%d %d\n", ser_values[i], ser_count[i]);
861: }
862: printf("raid%d: Summary of mod counters:\n", raidPtr->raidid);
863: for(i = 0; i < num_mod; i++) {
864: printf("%d %d\n", mod_values[i], mod_count[i]);
865: }
866: #endif /* DEBUG */
867: serial_number = ser_values[0];
868: if (num_ser == 2) {
869: if ((ser_count[0] == 1) || (ser_count[1] == 1)) {
870: /* Locate the maverick component. */
871: if (ser_count[1] > ser_count[0]) {
872: serial_number = ser_values[1];
873: }
874: for (r = 0; r < raidPtr->numRow; r++) {
875: for (c = 0; c < raidPtr->numCol; c++) {
876: ci_label =
877: &raidPtr->raid_cinfo[r][c].ci_label;
878: if (serial_number !=
879: ci_label->serial_number) {
880: hosed_row = r;
881: hosed_column = c;
882: break;
883: }
884: }
885: }
886: printf("Hosed component: %s.\n",
887: &cfgPtr->devnames[hosed_row][hosed_column][0]);
888: if (!force) {
889: /*
890: * We'll fail this component, as if there are
891: * other major errors, we aren't forcing things
892: * and we'll abort the config anyways.
893: */
894: raidPtr->Disks[hosed_row][hosed_column].status
895: = rf_ds_failed;
896: raidPtr->numFailures++;
897: raidPtr->status[hosed_row] = rf_rs_degraded;
898: }
899: } else {
900: too_fatal = 1;
901: }
902: if (cfgPtr->parityConfig == '0') {
903: /*
904: * We've identified two different serial numbers.
905: * RAID 0 can't cope with that, so we'll punt.
906: */
907: too_fatal = 1;
908: }
909:
910: }
911:
912: /*
913: * Record the serial number for later. If we bail later, setting
914: * this doesn't matter, otherwise we've got the best guess at the
915: * correct serial number.
916: */
917: raidPtr->serial_number = serial_number;
918:
919: mod_number = mod_values[0];
920: if (num_mod == 2) {
921: if ((mod_count[0] == 1) || (mod_count[1] == 1)) {
922: /* Locate the maverick component. */
923: if (mod_count[1] > mod_count[0]) {
924: mod_number = mod_values[1];
925: } else if (mod_count[1] < mod_count[0]) {
926: mod_number = mod_values[0];
927: } else {
928: /*
929: * Counts of different modification values
930: * are the same. Assume greater value is
931: * the correct one, all other things
932: * considered.
933: */
934: if (mod_values[0] > mod_values[1]) {
935: mod_number = mod_values[0];
936: } else {
937: mod_number = mod_values[1];
938: }
939:
940: }
941: for (r = 0; r < raidPtr->numRow && !too_fatal; r++) {
942: for (c = 0; c < raidPtr->numCol; c++) {
943: ci_label =
944: &raidPtr->raid_cinfo[r][c].ci_label;
945: if (mod_number !=
946: ci_label->mod_counter) {
947: if ((hosed_row == r) &&
948: (hosed_column == c)) {
949: /*
950: * Same one. Can
951: * deal with it.
952: */
953: } else {
954: hosed_row = r;
955: hosed_column = c;
956: if (num_ser != 1) {
957: too_fatal = 1;
958: break;
959: }
960: }
961: }
962: }
963: }
964: printf("Hosed component: %s.\n",
965: &cfgPtr->devnames[hosed_row][hosed_column][0]);
966: if (!force) {
967: /*
968: * We'll fail this component, as if there are
969: * other major errors, we aren't forcing things
970: * and we'll abort the config anyways.
971: */
972: if (raidPtr
973: ->Disks[hosed_row][hosed_column].status !=
974: rf_ds_failed) {
975: raidPtr->Disks[hosed_row]
976: [hosed_column].status =
977: rf_ds_failed;
978: raidPtr->numFailures++;
979: raidPtr->status[hosed_row] =
980: rf_rs_degraded;
981: }
982: }
983: } else {
984: too_fatal = 1;
985: }
986: if (cfgPtr->parityConfig == '0') {
987: /*
988: * We've identified two different mod counters.
989: * RAID 0 can't cope with that, so we'll punt.
990: */
991: too_fatal = 1;
992: }
993: }
994:
995: raidPtr->mod_counter = mod_number;
996:
997: if (too_fatal) {
998: /*
999: * We've had both a serial number mismatch, and a mod_counter
1000: * mismatch -- and they involved two different components !!!
1001: * Bail -- make things fail so that the user must force
1002: * the issue...
1003: */
1004: hosed_row = -1;
1005: hosed_column = -1;
1006: }
1007:
1008: if (num_ser > 2) {
1009: printf("raid%d: Too many different serial numbers !\n",
1010: raidPtr->raidid);
1011: }
1012:
1013: if (num_mod > 2) {
1014: printf("raid%d: Too many different mod counters !\n",
1015: raidPtr->raidid);
1016: }
1017:
1018: /*
1019: * We start by assuming the parity will be good, and flee from
1020: * that notion at the slightest sign of trouble.
1021: */
1022:
1023: parity_good = RF_RAID_CLEAN;
1024: for (r = 0; r < raidPtr->numRow; r++) {
1025: for (c = 0; c < raidPtr->numCol; c++) {
1026: dev_name = &cfgPtr->devnames[r][c][0];
1027: ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
1028:
1029: if ((r == hosed_row) && (c == hosed_column)) {
1030: printf("raid%d: Ignoring %s.\n",
1031: raidPtr->raidid, dev_name);
1032: } else {
1033: rf_print_label_status(raidPtr, r, c, dev_name,
1034: ci_label);
1035: if (rf_check_label_vitals(raidPtr, r, c,
1036: dev_name, ci_label, serial_number,
1037: mod_number)) {
1038: fatal_error = 1;
1039: }
1040: if (ci_label->clean != RF_RAID_CLEAN) {
1041: parity_good = RF_RAID_DIRTY;
1042: }
1043: }
1044: }
1045: }
1046: if (fatal_error) {
1047: parity_good = RF_RAID_DIRTY;
1048: }
1049:
1050: /* We note the state of the parity. */
1051: raidPtr->parity_good = parity_good;
1052:
1053: return(fatal_error);
1054: }
1055:
1056: int
1057: rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
1058: {
1059: RF_RaidDisk_t *disks;
1060: RF_DiskQueue_t *spareQueues;
1061: int ret;
1062: unsigned int bs;
1063: int spare_number;
1064:
1065: #if 0
1066: printf("Just in rf_add_hot_spare: %d.\n", raidPtr->numSpare);
1067: printf("Num col: %d.\n", raidPtr->numCol);
1068: #endif
1069: if (raidPtr->numSpare >= RF_MAXSPARE) {
1070: RF_ERRORMSG1("Too many spares: %d.\n", raidPtr->numSpare);
1071: return(EINVAL);
1072: }
1073:
1074: RF_LOCK_MUTEX(raidPtr->mutex);
1075:
1076: /* The beginning of the spares... */
1077: disks = &raidPtr->Disks[0][raidPtr->numCol];
1078:
1079: spare_number = raidPtr->numSpare;
1080:
1081: ret = rf_ConfigureDisk(raidPtr, sparePtr->component_name,
1082: &disks[spare_number], 0, raidPtr->numCol + spare_number);
1083:
1084: if (ret)
1085: goto fail;
1086: if (disks[spare_number].status != rf_ds_optimal) {
1087: RF_ERRORMSG1("Warning: spare disk %s failed TUR.\n",
1088: sparePtr->component_name);
1089: ret = EINVAL;
1090: goto fail;
1091: } else {
1092: disks[spare_number].status = rf_ds_spare;
1093: DPRINTF6("Spare Disk %d: dev %s numBlocks %ld blockSize %d"
1094: " (%ld MB).\n", spare_number, disks[spare_number].devname,
1095: (long int) disks[spare_number].numBlocks,
1096: disks[spare_number].blockSize,
1097: (long int) disks[spare_number].numBlocks *
1098: disks[spare_number].blockSize / 1024 / 1024);
1099: }
1100:
1101:
1102: /* Check sizes and block sizes on the spare disk. */
1103: bs = 1 << raidPtr->logBytesPerSector;
1104: if (disks[spare_number].blockSize != bs) {
1105: RF_ERRORMSG3("Block size of %d on spare disk %s is not"
1106: " the same as on other disks (%d).\n",
1107: disks[spare_number].blockSize,
1108: disks[spare_number].devname, bs);
1109: ret = EINVAL;
1110: goto fail;
1111: }
1112: if (disks[spare_number].numBlocks < raidPtr->sectorsPerDisk) {
1113: RF_ERRORMSG3("Spare disk %s (%llu blocks) is too small to serve"
1114: " as a spare (need %llu blocks).\n",
1115: disks[spare_number].devname, disks[spare_number].numBlocks,
1116: raidPtr->sectorsPerDisk);
1117: ret = EINVAL;
1118: goto fail;
1119: } else {
1120: if (disks[spare_number].numBlocks >
1121: raidPtr->sectorsPerDisk) {
1122: RF_ERRORMSG2("Warning: truncating spare disk %s to %llu"
1123: " blocks.\n", disks[spare_number].devname,
1124: raidPtr->sectorsPerDisk);
1125:
1126: disks[spare_number].numBlocks = raidPtr->sectorsPerDisk;
1127: }
1128: }
1129:
1130: spareQueues = &raidPtr->Queues[0][raidPtr->numCol];
1131: ret = rf_ConfigureDiskQueue(raidPtr, &spareQueues[spare_number],
1132: 0, raidPtr->numCol + spare_number, raidPtr->qType,
1133: raidPtr->sectorsPerDisk, raidPtr->Disks[0][raidPtr->numCol +
1134: spare_number].dev, raidPtr->maxOutstanding,
1135: &raidPtr->shutdownList, raidPtr->cleanupList);
1136:
1137:
1138: raidPtr->numSpare++;
1139: RF_UNLOCK_MUTEX(raidPtr->mutex);
1140: return (0);
1141:
1142: fail:
1143: RF_UNLOCK_MUTEX(raidPtr->mutex);
1144: return(ret);
1145: }
1146:
1147: int
1148: rf_remove_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
1149: {
1150: int spare_number;
1151:
1152: if (raidPtr->numSpare == 0) {
1153: printf("No spares to remove !\n");
1154: return(EINVAL);
1155: }
1156:
1157: spare_number = sparePtr->column;
1158:
1159: return(EINVAL); /* XXX Not implemented yet. */
1160: #if 0
1161: if (spare_number < 0 || spare_number > raidPtr->numSpare) {
1162: return(EINVAL);
1163: }
1164:
1165: /* Verify that this spare isn't in use... */
1166:
1167: /* It's gone... */
1168:
1169: raidPtr->numSpare--;
1170:
1171: return (0);
1172: #endif
1173: }
1174:
1175: int
1176: rf_delete_component(RF_Raid_t *raidPtr, RF_SingleComponent_t *component)
1177: {
1178: RF_RaidDisk_t *disks;
1179:
1180: if ((component->row < 0) ||
1181: (component->row >= raidPtr->numRow) ||
1182: (component->column < 0) ||
1183: (component->column >= raidPtr->numCol)) {
1184: return(EINVAL);
1185: }
1186:
1187: disks = &raidPtr->Disks[component->row][component->column];
1188:
1189: /* 1. This component must be marked as 'failed'. */
1190:
1191: return(EINVAL); /* Not implemented yet. */
1192: }
1193:
1194: int
1195: rf_incorporate_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *component)
1196: {
1197:
1198: /*
1199: * Issues here include how to 'move' this in if there is IO
1200: * taking place (e.g. component queues and such).
1201: */
1202:
1203: return(EINVAL); /* Not implemented yet. */
1204: }