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