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