1 /* $NetBSD: rf_disks.c,v 1.82 2011/10/14 09:23:30 hannken 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.82 2011/10/14 09:23:30 hannken 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 /* mark it as failed if the label looks bogus... */ 141 if (!rf_reasonable_label(&raidPtr->raid_cinfo[c].ci_label,0) && !force) { 142 disks[c].status = rf_ds_failed; 143 } 144 } 145 146 if (disks[c].status != rf_ds_optimal) { 147 numFailuresThisRow++; 148 } else { 149 if (disks[c].numBlocks < min_numblks) 150 min_numblks = disks[c].numBlocks; 151 DPRINTF6("Disk at col %d: dev %s numBlocks %" PRIu64 " blockSize %d (%ld MB)\n", 152 c, disks[c].devname, 153 disks[c].numBlocks, 154 disks[c].blockSize, 155 (long int) disks[c].numBlocks * 156 disks[c].blockSize / 1024 / 1024); 157 } 158 } 159 /* XXX fix for n-fault tolerant */ 160 /* XXX this should probably check to see how many failures 161 we can handle for this configuration! */ 162 if (numFailuresThisRow > 0) 163 raidPtr->status = rf_rs_degraded; 164 165 /* all disks must be the same size & have the same block size, bs must 166 * be a power of 2 */ 167 bs = 0; 168 foundone = 0; 169 for (c = 0; c < raidPtr->numCol; c++) { 170 if (disks[c].status == rf_ds_optimal) { 171 bs = disks[c].blockSize; 172 foundone = 1; 173 break; 174 } 175 } 176 if (!foundone) { 177 RF_ERRORMSG("RAIDFRAME: Did not find any live disks in the array.\n"); 178 ret = EINVAL; 179 goto fail; 180 } 181 for (count = 0, i = 1; i; i <<= 1) 182 if (bs & i) 183 count++; 184 if (count != 1) { 185 RF_ERRORMSG1("Error: block size on disks (%d) must be a power of 2\n", bs); 186 ret = EINVAL; 187 goto fail; 188 } 189 190 if (rf_CheckLabels( raidPtr, cfgPtr )) { 191 printf("raid%d: There were fatal errors\n", raidPtr->raidid); 192 if (force != 0) { 193 printf("raid%d: Fatal errors being ignored.\n", 194 raidPtr->raidid); 195 } else { 196 ret = EINVAL; 197 goto fail; 198 } 199 } 200 201 for (c = 0; c < raidPtr->numCol; c++) { 202 if (disks[c].status == rf_ds_optimal) { 203 if (disks[c].blockSize != bs) { 204 RF_ERRORMSG1("Error: block size of disk at c %d different from disk at c 0\n", c); 205 ret = EINVAL; 206 goto fail; 207 } 208 if (disks[c].numBlocks != min_numblks) { 209 RF_ERRORMSG2("WARNING: truncating disk at c %d to %d blocks\n", 210 c, (int) min_numblks); 211 disks[c].numBlocks = min_numblks; 212 } 213 } 214 } 215 216 raidPtr->sectorsPerDisk = min_numblks; 217 raidPtr->logBytesPerSector = ffs(bs) - 1; 218 raidPtr->bytesPerSector = bs; 219 raidPtr->sectorMask = bs - 1; 220 return (0); 221 222 fail: 223 224 rf_UnconfigureVnodes( raidPtr ); 225 226 return (ret); 227 } 228 229 230 /**************************************************************************** 231 * set up the data structures describing the spare disks in the array 232 * recall from the above comment that the spare disk descriptors are stored 233 * in row zero, which is specially expanded to hold them. 234 ****************************************************************************/ 235 int 236 rf_ConfigureSpareDisks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr, 237 RF_Config_t *cfgPtr) 238 { 239 int i, ret; 240 unsigned int bs; 241 RF_RaidDisk_t *disks; 242 int num_spares_done; 243 244 num_spares_done = 0; 245 246 /* The space for the spares should have already been allocated by 247 * ConfigureDisks() */ 248 249 disks = &raidPtr->Disks[raidPtr->numCol]; 250 for (i = 0; i < raidPtr->numSpare; i++) { 251 ret = rf_ConfigureDisk(raidPtr, &cfgPtr->spare_names[i][0], 252 &disks[i], raidPtr->numCol + i); 253 if (ret) 254 goto fail; 255 if (disks[i].status != rf_ds_optimal) { 256 RF_ERRORMSG1("Warning: spare disk %s failed TUR\n", 257 &cfgPtr->spare_names[i][0]); 258 } else { 259 disks[i].status = rf_ds_spare; /* change status to 260 * spare */ 261 DPRINTF6("Spare Disk %d: dev %s numBlocks %" PRIu64 " blockSize %d (%ld MB)\n", i, 262 disks[i].devname, 263 disks[i].numBlocks, disks[i].blockSize, 264 (long int) disks[i].numBlocks * 265 disks[i].blockSize / 1024 / 1024); 266 } 267 num_spares_done++; 268 } 269 270 /* check sizes and block sizes on spare disks */ 271 bs = 1 << raidPtr->logBytesPerSector; 272 for (i = 0; i < raidPtr->numSpare; i++) { 273 if (disks[i].blockSize != bs) { 274 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); 275 ret = EINVAL; 276 goto fail; 277 } 278 if (disks[i].numBlocks < raidPtr->sectorsPerDisk) { 279 RF_ERRORMSG3("Spare disk %s (%d blocks) is too small to serve as a spare (need %" PRIu64 " blocks)\n", 280 disks[i].devname, disks[i].blockSize, 281 raidPtr->sectorsPerDisk); 282 ret = EINVAL; 283 goto fail; 284 } else 285 if (disks[i].numBlocks > raidPtr->sectorsPerDisk) { 286 RF_ERRORMSG3("Warning: truncating spare disk %s to %" PRIu64 " blocks (from %" PRIu64 ")\n", 287 disks[i].devname, 288 raidPtr->sectorsPerDisk, 289 disks[i].numBlocks); 290 291 disks[i].numBlocks = raidPtr->sectorsPerDisk; 292 } 293 } 294 295 return (0); 296 297 fail: 298 299 /* Release the hold on the main components. We've failed to allocate 300 * a spare, and since we're failing, we need to free things.. 301 302 XXX failing to allocate a spare is *not* that big of a deal... 303 We *can* survive without it, if need be, esp. if we get hot 304 adding working. 305 306 If we don't fail out here, then we need a way to remove this spare... 307 that should be easier to do here than if we are "live"... 308 309 */ 310 311 rf_UnconfigureVnodes( raidPtr ); 312 313 return (ret); 314 } 315 316 static int 317 rf_AllocDiskStructures(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr) 318 { 319 int ret; 320 321 /* We allocate RF_MAXSPARE on the first row so that we 322 have room to do hot-swapping of spares */ 323 RF_MallocAndAdd(raidPtr->Disks, (raidPtr->numCol + RF_MAXSPARE) * 324 sizeof(RF_RaidDisk_t), (RF_RaidDisk_t *), 325 raidPtr->cleanupList); 326 if (raidPtr->Disks == NULL) { 327 ret = ENOMEM; 328 goto fail; 329 } 330 331 /* get space for device specific stuff.. */ 332 RF_MallocAndAdd(raidPtr->raid_cinfo, 333 (raidPtr->numCol + RF_MAXSPARE) * 334 sizeof(struct raidcinfo), (struct raidcinfo *), 335 raidPtr->cleanupList); 336 337 if (raidPtr->raid_cinfo == NULL) { 338 ret = ENOMEM; 339 goto fail; 340 } 341 342 return(0); 343 fail: 344 rf_UnconfigureVnodes( raidPtr ); 345 346 return(ret); 347 } 348 349 350 /* configure a single disk during auto-configuration at boot */ 351 int 352 rf_AutoConfigureDisks(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, 353 RF_AutoConfig_t *auto_config) 354 { 355 RF_RaidDisk_t *disks; 356 RF_RaidDisk_t *diskPtr; 357 RF_RowCol_t c; 358 RF_SectorCount_t min_numblks = (RF_SectorCount_t) 0x7FFFFFFFFFFFLL; 359 int bs, ret; 360 int numFailuresThisRow; 361 RF_AutoConfig_t *ac; 362 int parity_good; 363 int mod_counter; 364 int mod_counter_found; 365 366 #if DEBUG 367 printf("Starting autoconfiguration of RAID set...\n"); 368 #endif 369 370 ret = rf_AllocDiskStructures(raidPtr, cfgPtr); 371 if (ret) 372 goto fail; 373 374 disks = raidPtr->Disks; 375 376 /* assume the parity will be fine.. */ 377 parity_good = RF_RAID_CLEAN; 378 379 /* Check for mod_counters that are too low */ 380 mod_counter_found = 0; 381 mod_counter = 0; 382 ac = auto_config; 383 while(ac!=NULL) { 384 if (mod_counter_found==0) { 385 mod_counter = ac->clabel->mod_counter; 386 mod_counter_found = 1; 387 } else { 388 if (ac->clabel->mod_counter > mod_counter) { 389 mod_counter = ac->clabel->mod_counter; 390 } 391 } 392 ac->flag = 0; /* clear the general purpose flag */ 393 ac = ac->next; 394 } 395 396 bs = 0; 397 398 numFailuresThisRow = 0; 399 for (c = 0; c < raidPtr->numCol; c++) { 400 diskPtr = &disks[c]; 401 402 /* find this row/col in the autoconfig */ 403 #if DEBUG 404 printf("Looking for %d in autoconfig\n",c); 405 #endif 406 ac = auto_config; 407 while(ac!=NULL) { 408 if (ac->clabel==NULL) { 409 /* big-time bad news. */ 410 goto fail; 411 } 412 if ((ac->clabel->column == c) && 413 (ac->clabel->mod_counter == mod_counter)) { 414 /* it's this one... */ 415 /* flag it as 'used', so we don't 416 free it later. */ 417 ac->flag = 1; 418 #if DEBUG 419 printf("Found: %s at %d\n", 420 ac->devname,c); 421 #endif 422 423 break; 424 } 425 ac=ac->next; 426 } 427 428 if (ac==NULL) { 429 /* we didn't find an exact match with a 430 correct mod_counter above... can we find 431 one with an incorrect mod_counter to use 432 instead? (this one, if we find it, will be 433 marked as failed once the set configures) 434 */ 435 436 ac = auto_config; 437 while(ac!=NULL) { 438 if (ac->clabel==NULL) { 439 /* big-time bad news. */ 440 goto fail; 441 } 442 if (ac->clabel->column == c) { 443 /* it's this one... 444 flag it as 'used', so we 445 don't free it later. */ 446 ac->flag = 1; 447 #if DEBUG 448 printf("Found(low mod_counter): %s at %d\n", 449 ac->devname,c); 450 #endif 451 452 break; 453 } 454 ac=ac->next; 455 } 456 } 457 458 459 460 if (ac!=NULL) { 461 /* Found it. Configure it.. */ 462 diskPtr->blockSize = ac->clabel->blockSize; 463 diskPtr->numBlocks = 464 rf_component_label_numblocks(ac->clabel); 465 /* Note: rf_protectedSectors is already 466 factored into numBlocks here */ 467 raidPtr->raid_cinfo[c].ci_vp = ac->vp; 468 raidPtr->raid_cinfo[c].ci_dev = ac->dev; 469 470 memcpy(raidget_component_label(raidPtr, c), 471 ac->clabel, sizeof(*ac->clabel)); 472 snprintf(diskPtr->devname, sizeof(diskPtr->devname), 473 "/dev/%s", ac->devname); 474 475 /* note the fact that this component was 476 autoconfigured. You'll need this info 477 later. Trust me :) */ 478 diskPtr->auto_configured = 1; 479 diskPtr->dev = ac->dev; 480 481 /* 482 * we allow the user to specify that 483 * only a fraction of the disks should 484 * be used this is just for debug: it 485 * speeds up the parity scan 486 */ 487 488 diskPtr->numBlocks = diskPtr->numBlocks * 489 rf_sizePercentage / 100; 490 491 /* XXX these will get set multiple times, 492 but since we're autoconfiguring, they'd 493 better be always the same each time! 494 If not, this is the least of your worries */ 495 496 bs = diskPtr->blockSize; 497 min_numblks = diskPtr->numBlocks; 498 499 /* this gets done multiple times, but that's 500 fine -- the serial number will be the same 501 for all components, guaranteed */ 502 raidPtr->serial_number = ac->clabel->serial_number; 503 /* check the last time the label was modified */ 504 505 if (ac->clabel->mod_counter != mod_counter) { 506 /* Even though we've filled in all of 507 the above, we don't trust this 508 component since it's modification 509 counter is not in sync with the 510 rest, and we really consider it to 511 be failed. */ 512 disks[c].status = rf_ds_failed; 513 numFailuresThisRow++; 514 } else { 515 if (ac->clabel->clean != RF_RAID_CLEAN) { 516 parity_good = RF_RAID_DIRTY; 517 } 518 } 519 } else { 520 /* Didn't find it at all!! Component must 521 really be dead */ 522 disks[c].status = rf_ds_failed; 523 snprintf(disks[c].devname, sizeof(disks[c].devname), 524 "component%d", c); 525 numFailuresThisRow++; 526 } 527 } 528 /* XXX fix for n-fault tolerant */ 529 /* XXX this should probably check to see how many failures 530 we can handle for this configuration! */ 531 if (numFailuresThisRow > 0) { 532 raidPtr->status = rf_rs_degraded; 533 raidPtr->numFailures = numFailuresThisRow; 534 } 535 536 /* close the device for the ones that didn't get used */ 537 538 ac = auto_config; 539 while(ac!=NULL) { 540 if (ac->flag == 0) { 541 vn_lock(ac->vp, LK_EXCLUSIVE | LK_RETRY); 542 VOP_CLOSE(ac->vp, FREAD | FWRITE, NOCRED); 543 vput(ac->vp); 544 ac->vp = NULL; 545 #if DEBUG 546 printf("Released %s from auto-config set.\n", 547 ac->devname); 548 #endif 549 } 550 ac = ac->next; 551 } 552 553 raidPtr->mod_counter = mod_counter; 554 555 /* note the state of the parity, if any */ 556 raidPtr->parity_good = parity_good; 557 raidPtr->sectorsPerDisk = min_numblks; 558 raidPtr->logBytesPerSector = ffs(bs) - 1; 559 raidPtr->bytesPerSector = bs; 560 raidPtr->sectorMask = bs - 1; 561 return (0); 562 563 fail: 564 565 rf_UnconfigureVnodes( raidPtr ); 566 567 return (ret); 568 569 } 570 571 /* configure a single disk in the array */ 572 int 573 rf_ConfigureDisk(RF_Raid_t *raidPtr, char *bf, RF_RaidDisk_t *diskPtr, 574 RF_RowCol_t col) 575 { 576 char *p; 577 struct pathbuf *pb; 578 struct vnode *vp; 579 struct vattr va; 580 int error; 581 582 p = rf_find_non_white(bf); 583 if (p[strlen(p) - 1] == '\n') { 584 /* strip off the newline */ 585 p[strlen(p) - 1] = '\0'; 586 } 587 (void) strcpy(diskPtr->devname, p); 588 589 /* Let's start by claiming the component is fine and well... */ 590 diskPtr->status = rf_ds_optimal; 591 592 raidPtr->raid_cinfo[col].ci_vp = NULL; 593 raidPtr->raid_cinfo[col].ci_dev = 0; 594 595 if (!strcmp("absent", diskPtr->devname)) { 596 printf("Ignoring missing component at column %d\n", col); 597 sprintf(diskPtr->devname, "component%d", col); 598 diskPtr->status = rf_ds_failed; 599 return (0); 600 } 601 602 pb = pathbuf_create(diskPtr->devname); 603 if (pb == NULL) { 604 printf("pathbuf_create for device: %s failed!\n", 605 diskPtr->devname); 606 return ENOMEM; 607 } 608 error = dk_lookup(pb, curlwp, &vp); 609 pathbuf_destroy(pb); 610 if (error) { 611 printf("dk_lookup on device: %s failed!\n", diskPtr->devname); 612 if (error == ENXIO) { 613 /* the component isn't there... must be dead :-( */ 614 diskPtr->status = rf_ds_failed; 615 return 0; 616 } else { 617 return (error); 618 } 619 } 620 621 if ((error = rf_getdisksize(vp, diskPtr)) != 0) 622 return (error); 623 624 /* 625 * If this raidPtr's bytesPerSector is zero, fill it in with this 626 * components blockSize. This will give us something to work with 627 * initially, and if it is wrong, we'll get errors later. 628 */ 629 if (raidPtr->bytesPerSector == 0) 630 raidPtr->bytesPerSector = diskPtr->blockSize; 631 632 if (diskPtr->status == rf_ds_optimal) { 633 vn_lock(vp, LK_SHARED | LK_RETRY); 634 error = VOP_GETATTR(vp, &va, curlwp->l_cred); 635 VOP_UNLOCK(vp); 636 if (error != 0) 637 return (error); 638 639 raidPtr->raid_cinfo[col].ci_vp = vp; 640 raidPtr->raid_cinfo[col].ci_dev = va.va_rdev; 641 642 /* This component was not automatically configured */ 643 diskPtr->auto_configured = 0; 644 diskPtr->dev = va.va_rdev; 645 646 /* we allow the user to specify that only a fraction of the 647 * disks should be used this is just for debug: it speeds up 648 * the parity scan */ 649 diskPtr->numBlocks = diskPtr->numBlocks * 650 rf_sizePercentage / 100; 651 } 652 return (0); 653 } 654 655 static void 656 rf_print_label_status(RF_Raid_t *raidPtr, int column, char *dev_name, 657 RF_ComponentLabel_t *ci_label) 658 { 659 660 printf("raid%d: Component %s being configured at col: %d\n", 661 raidPtr->raidid, dev_name, column ); 662 printf(" Column: %d Num Columns: %d\n", 663 ci_label->column, 664 ci_label->num_columns); 665 printf(" Version: %d Serial Number: %d Mod Counter: %d\n", 666 ci_label->version, ci_label->serial_number, 667 ci_label->mod_counter); 668 printf(" Clean: %s Status: %d\n", 669 ci_label->clean ? "Yes" : "No", ci_label->status ); 670 } 671 672 static int rf_check_label_vitals(RF_Raid_t *raidPtr, int row, int column, 673 char *dev_name, RF_ComponentLabel_t *ci_label, 674 int serial_number, int mod_counter) 675 { 676 int fatal_error = 0; 677 678 if (serial_number != ci_label->serial_number) { 679 printf("%s has a different serial number: %d %d\n", 680 dev_name, serial_number, ci_label->serial_number); 681 fatal_error = 1; 682 } 683 if (mod_counter != ci_label->mod_counter) { 684 printf("%s has a different modification count: %d %d\n", 685 dev_name, mod_counter, ci_label->mod_counter); 686 } 687 688 if (row != ci_label->row) { 689 printf("Row out of alignment for: %s\n", dev_name); 690 fatal_error = 1; 691 } 692 if (column != ci_label->column) { 693 printf("Column out of alignment for: %s\n", dev_name); 694 fatal_error = 1; 695 } 696 if (raidPtr->numCol != ci_label->num_columns) { 697 printf("Number of columns do not match for: %s\n", dev_name); 698 fatal_error = 1; 699 } 700 if (ci_label->clean == 0) { 701 /* it's not clean, but that's not fatal */ 702 printf("%s is not clean!\n", dev_name); 703 } 704 return(fatal_error); 705 } 706 707 708 /* 709 710 rf_CheckLabels() - check all the component labels for consistency. 711 Return an error if there is anything major amiss. 712 713 */ 714 715 int 716 rf_CheckLabels(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr) 717 { 718 int c; 719 char *dev_name; 720 RF_ComponentLabel_t *ci_label; 721 int serial_number = 0; 722 int mod_number = 0; 723 int fatal_error = 0; 724 int mod_values[4]; 725 int mod_count[4]; 726 int ser_values[4]; 727 int ser_count[4]; 728 int num_ser; 729 int num_mod; 730 int i; 731 int found; 732 int hosed_column; 733 int too_fatal; 734 int parity_good; 735 int force; 736 737 hosed_column = -1; 738 too_fatal = 0; 739 force = cfgPtr->force; 740 741 /* 742 We're going to try to be a little intelligent here. If one 743 component's label is bogus, and we can identify that it's the 744 *only* one that's gone, we'll mark it as "failed" and allow 745 the configuration to proceed. This will be the *only* case 746 that we'll proceed if there would be (otherwise) fatal errors. 747 748 Basically we simply keep a count of how many components had 749 what serial number. If all but one agree, we simply mark 750 the disagreeing component as being failed, and allow 751 things to come up "normally". 752 753 We do this first for serial numbers, and then for "mod_counter". 754 755 */ 756 757 num_ser = 0; 758 num_mod = 0; 759 760 ser_values[0] = ser_values[1] = ser_values[2] = ser_values[3] = 0; 761 ser_count[0] = ser_count[1] = ser_count[2] = ser_count[3] = 0; 762 763 for (c = 0; c < raidPtr->numCol; c++) { 764 if (raidPtr->Disks[c].status != rf_ds_optimal) 765 continue; 766 ci_label = raidget_component_label(raidPtr, c); 767 found=0; 768 for(i=0;i<num_ser;i++) { 769 if (ser_values[i] == ci_label->serial_number) { 770 ser_count[i]++; 771 found=1; 772 break; 773 } 774 } 775 if (!found) { 776 ser_values[num_ser] = ci_label->serial_number; 777 ser_count[num_ser] = 1; 778 num_ser++; 779 if (num_ser>2) { 780 fatal_error = 1; 781 break; 782 } 783 } 784 found=0; 785 for(i=0;i<num_mod;i++) { 786 if (mod_values[i] == ci_label->mod_counter) { 787 mod_count[i]++; 788 found=1; 789 break; 790 } 791 } 792 if (!found) { 793 mod_values[num_mod] = ci_label->mod_counter; 794 mod_count[num_mod] = 1; 795 num_mod++; 796 if (num_mod>2) { 797 fatal_error = 1; 798 break; 799 } 800 } 801 } 802 #if DEBUG 803 printf("raid%d: Summary of serial numbers:\n", raidPtr->raidid); 804 for(i=0;i<num_ser;i++) { 805 printf("%d %d\n", ser_values[i], ser_count[i]); 806 } 807 printf("raid%d: Summary of mod counters:\n", raidPtr->raidid); 808 for(i=0;i<num_mod;i++) { 809 printf("%d %d\n", mod_values[i], mod_count[i]); 810 } 811 #endif 812 serial_number = ser_values[0]; 813 if (num_ser == 2) { 814 if ((ser_count[0] == 1) || (ser_count[1] == 1)) { 815 /* Locate the maverick component */ 816 if (ser_count[1] > ser_count[0]) { 817 serial_number = ser_values[1]; 818 } 819 820 for (c = 0; c < raidPtr->numCol; c++) { 821 if (raidPtr->Disks[c].status != rf_ds_optimal) 822 continue; 823 ci_label = raidget_component_label(raidPtr, c); 824 if (serial_number != ci_label->serial_number) { 825 hosed_column = c; 826 break; 827 } 828 } 829 printf("Hosed component: %s\n", 830 &cfgPtr->devnames[0][hosed_column][0]); 831 if (!force) { 832 /* we'll fail this component, as if there are 833 other major errors, we arn't forcing things 834 and we'll abort the config anyways */ 835 raidPtr->Disks[hosed_column].status 836 = rf_ds_failed; 837 raidPtr->numFailures++; 838 raidPtr->status = rf_rs_degraded; 839 } 840 } else { 841 too_fatal = 1; 842 } 843 if (cfgPtr->parityConfig == '0') { 844 /* We've identified two different serial numbers. 845 RAID 0 can't cope with that, so we'll punt */ 846 too_fatal = 1; 847 } 848 849 } 850 851 /* record the serial number for later. If we bail later, setting 852 this doesn't matter, otherwise we've got the best guess at the 853 correct serial number */ 854 raidPtr->serial_number = serial_number; 855 856 mod_number = mod_values[0]; 857 if (num_mod == 2) { 858 if ((mod_count[0] == 1) || (mod_count[1] == 1)) { 859 /* Locate the maverick component */ 860 if (mod_count[1] > mod_count[0]) { 861 mod_number = mod_values[1]; 862 } else if (mod_count[1] < mod_count[0]) { 863 mod_number = mod_values[0]; 864 } else { 865 /* counts of different modification values 866 are the same. Assume greater value is 867 the correct one, all other things 868 considered */ 869 if (mod_values[0] > mod_values[1]) { 870 mod_number = mod_values[0]; 871 } else { 872 mod_number = mod_values[1]; 873 } 874 875 } 876 877 for (c = 0; c < raidPtr->numCol; c++) { 878 if (raidPtr->Disks[c].status != rf_ds_optimal) 879 continue; 880 881 ci_label = raidget_component_label(raidPtr, c); 882 if (mod_number != ci_label->mod_counter) { 883 if (hosed_column == c) { 884 /* same one. Can 885 deal with it. */ 886 } else { 887 hosed_column = c; 888 if (num_ser != 1) { 889 too_fatal = 1; 890 break; 891 } 892 } 893 } 894 } 895 printf("Hosed component: %s\n", 896 &cfgPtr->devnames[0][hosed_column][0]); 897 if (!force) { 898 /* we'll fail this component, as if there are 899 other major errors, we arn't forcing things 900 and we'll abort the config anyways */ 901 if (raidPtr->Disks[hosed_column].status != rf_ds_failed) { 902 raidPtr->Disks[hosed_column].status 903 = rf_ds_failed; 904 raidPtr->numFailures++; 905 raidPtr->status = rf_rs_degraded; 906 } 907 } 908 } else { 909 too_fatal = 1; 910 } 911 if (cfgPtr->parityConfig == '0') { 912 /* We've identified two different mod counters. 913 RAID 0 can't cope with that, so we'll punt */ 914 too_fatal = 1; 915 } 916 } 917 918 raidPtr->mod_counter = mod_number; 919 920 if (too_fatal) { 921 /* we've had both a serial number mismatch, and a mod_counter 922 mismatch -- and they involved two different components!! 923 Bail -- make things fail so that the user must force 924 the issue... */ 925 hosed_column = -1; 926 fatal_error = 1; 927 } 928 929 if (num_ser > 2) { 930 printf("raid%d: Too many different serial numbers!\n", 931 raidPtr->raidid); 932 fatal_error = 1; 933 } 934 935 if (num_mod > 2) { 936 printf("raid%d: Too many different mod counters!\n", 937 raidPtr->raidid); 938 fatal_error = 1; 939 } 940 941 for (c = 0; c < raidPtr->numCol; c++) { 942 if (raidPtr->Disks[c].status != rf_ds_optimal) { 943 hosed_column = c; 944 break; 945 } 946 } 947 948 /* we start by assuming the parity will be good, and flee from 949 that notion at the slightest sign of trouble */ 950 951 parity_good = RF_RAID_CLEAN; 952 953 for (c = 0; c < raidPtr->numCol; c++) { 954 dev_name = &cfgPtr->devnames[0][c][0]; 955 ci_label = raidget_component_label(raidPtr, c); 956 957 if (c == hosed_column) { 958 printf("raid%d: Ignoring %s\n", 959 raidPtr->raidid, dev_name); 960 } else { 961 rf_print_label_status( raidPtr, c, dev_name, ci_label); 962 if (rf_check_label_vitals( raidPtr, 0, c, 963 dev_name, ci_label, 964 serial_number, 965 mod_number )) { 966 fatal_error = 1; 967 } 968 if (ci_label->clean != RF_RAID_CLEAN) { 969 parity_good = RF_RAID_DIRTY; 970 } 971 } 972 } 973 974 if (fatal_error) { 975 parity_good = RF_RAID_DIRTY; 976 } 977 978 /* we note the state of the parity */ 979 raidPtr->parity_good = parity_good; 980 981 return(fatal_error); 982 } 983 984 int 985 rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr) 986 { 987 RF_RaidDisk_t *disks; 988 RF_DiskQueue_t *spareQueues; 989 int ret; 990 unsigned int bs; 991 int spare_number; 992 993 ret=0; 994 995 if (raidPtr->numSpare >= RF_MAXSPARE) { 996 RF_ERRORMSG1("Too many spares: %d\n", raidPtr->numSpare); 997 return(EINVAL); 998 } 999 1000 rf_lock_mutex2(raidPtr->mutex); 1001 while (raidPtr->adding_hot_spare == 1) { 1002 rf_wait_cond2(raidPtr->adding_hot_spare_cv, raidPtr->mutex); 1003 } 1004 raidPtr->adding_hot_spare = 1; 1005 rf_unlock_mutex2(raidPtr->mutex); 1006 1007 /* the beginning of the spares... */ 1008 disks = &raidPtr->Disks[raidPtr->numCol]; 1009 1010 spare_number = raidPtr->numSpare; 1011 1012 ret = rf_ConfigureDisk(raidPtr, sparePtr->component_name, 1013 &disks[spare_number], 1014 raidPtr->numCol + spare_number); 1015 1016 if (ret) 1017 goto fail; 1018 if (disks[spare_number].status != rf_ds_optimal) { 1019 RF_ERRORMSG1("Warning: spare disk %s failed TUR\n", 1020 sparePtr->component_name); 1021 rf_close_component(raidPtr, raidPtr->raid_cinfo[raidPtr->numCol+spare_number].ci_vp, 0); 1022 ret=EINVAL; 1023 goto fail; 1024 } else { 1025 disks[spare_number].status = rf_ds_spare; 1026 DPRINTF6("Spare Disk %d: dev %s numBlocks %" PRIu64 " blockSize %d (%ld MB)\n", 1027 spare_number, 1028 disks[spare_number].devname, 1029 disks[spare_number].numBlocks, 1030 disks[spare_number].blockSize, 1031 (long int) disks[spare_number].numBlocks * 1032 disks[spare_number].blockSize / 1024 / 1024); 1033 } 1034 1035 1036 /* check sizes and block sizes on the spare disk */ 1037 bs = 1 << raidPtr->logBytesPerSector; 1038 if (disks[spare_number].blockSize != bs) { 1039 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); 1040 rf_close_component(raidPtr, raidPtr->raid_cinfo[raidPtr->numCol+spare_number].ci_vp, 0); 1041 ret = EINVAL; 1042 goto fail; 1043 } 1044 if (disks[spare_number].numBlocks < raidPtr->sectorsPerDisk) { 1045 RF_ERRORMSG3("Spare disk %s (%d blocks) is too small to serve as a spare (need %" PRIu64 " blocks)\n", 1046 disks[spare_number].devname, 1047 disks[spare_number].blockSize, 1048 raidPtr->sectorsPerDisk); 1049 rf_close_component(raidPtr, raidPtr->raid_cinfo[raidPtr->numCol+spare_number].ci_vp, 0); 1050 ret = EINVAL; 1051 goto fail; 1052 } else { 1053 if (disks[spare_number].numBlocks > 1054 raidPtr->sectorsPerDisk) { 1055 RF_ERRORMSG3("Warning: truncating spare disk %s to %" PRIu64 " blocks (from %" PRIu64 ")\n", 1056 disks[spare_number].devname, 1057 raidPtr->sectorsPerDisk, 1058 disks[spare_number].numBlocks); 1059 1060 disks[spare_number].numBlocks = raidPtr->sectorsPerDisk; 1061 } 1062 } 1063 1064 spareQueues = &raidPtr->Queues[raidPtr->numCol]; 1065 ret = rf_ConfigureDiskQueue( raidPtr, &spareQueues[spare_number], 1066 raidPtr->numCol + spare_number, 1067 raidPtr->qType, 1068 raidPtr->sectorsPerDisk, 1069 raidPtr->Disks[raidPtr->numCol + 1070 spare_number].dev, 1071 raidPtr->maxOutstanding, 1072 &raidPtr->shutdownList, 1073 raidPtr->cleanupList); 1074 1075 rf_lock_mutex2(raidPtr->mutex); 1076 raidPtr->numSpare++; 1077 rf_unlock_mutex2(raidPtr->mutex); 1078 1079 fail: 1080 rf_lock_mutex2(raidPtr->mutex); 1081 raidPtr->adding_hot_spare = 0; 1082 rf_signal_cond2(raidPtr->adding_hot_spare_cv); 1083 rf_unlock_mutex2(raidPtr->mutex); 1084 1085 return(ret); 1086 } 1087 1088 int 1089 rf_remove_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr) 1090 { 1091 int spare_number; 1092 1093 1094 if (raidPtr->numSpare==0) { 1095 printf("No spares to remove!\n"); 1096 return(EINVAL); 1097 } 1098 1099 spare_number = sparePtr->column; 1100 1101 return(EINVAL); /* XXX not implemented yet */ 1102 #if 0 1103 if (spare_number < 0 || spare_number > raidPtr->numSpare) { 1104 return(EINVAL); 1105 } 1106 1107 /* verify that this spare isn't in use... */ 1108 1109 1110 1111 1112 /* it's gone.. */ 1113 1114 raidPtr->numSpare--; 1115 1116 return(0); 1117 #endif 1118 } 1119 1120 1121 int 1122 rf_delete_component(RF_Raid_t *raidPtr, RF_SingleComponent_t *component) 1123 { 1124 RF_RaidDisk_t *disks; 1125 1126 if ((component->column < 0) || 1127 (component->column >= raidPtr->numCol)) { 1128 return(EINVAL); 1129 } 1130 1131 disks = &raidPtr->Disks[component->column]; 1132 1133 /* 1. This component must be marked as 'failed' */ 1134 1135 return(EINVAL); /* Not implemented yet. */ 1136 } 1137 1138 int 1139 rf_incorporate_hot_spare(RF_Raid_t *raidPtr, 1140 RF_SingleComponent_t *component) 1141 { 1142 1143 /* Issues here include how to 'move' this in if there is IO 1144 taking place (e.g. component queues and such) */ 1145 1146 return(EINVAL); /* Not implemented yet. */ 1147 } 1148