1 /* $NetBSD: rf_driver.c,v 1.140 2022/08/10 01:16:38 mrg 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, Khalil Amiri, Claudson Bornstein, William V. Courtright II, 36 * Robby Findler, Daniel Stodolsky, Rachad Youssef, Jim Zelenka 37 * 38 * Permission to use, copy, modify and distribute this software and 39 * its documentation is hereby granted, provided that both the copyright 40 * notice and this permission notice appear in all copies of the 41 * software, derivative works or modified versions, and any portions 42 * thereof, and that both notices appear in supporting documentation. 43 * 44 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 45 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 46 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 47 * 48 * Carnegie Mellon requests users of this software to return to 49 * 50 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 51 * School of Computer Science 52 * Carnegie Mellon University 53 * Pittsburgh PA 15213-3890 54 * 55 * any improvements or extensions that they make and grant Carnegie the 56 * rights to redistribute these changes. 57 */ 58 59 /****************************************************************************** 60 * 61 * rf_driver.c -- main setup, teardown, and access routines for the RAID driver 62 * 63 * all routines are prefixed with rf_ (raidframe), to avoid conficts. 64 * 65 ******************************************************************************/ 66 67 68 #include <sys/cdefs.h> 69 __KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.140 2022/08/10 01:16:38 mrg Exp $"); 70 71 #ifdef _KERNEL_OPT 72 #include "opt_raid_diagnostic.h" 73 #endif 74 75 #include <sys/param.h> 76 #include <sys/systm.h> 77 #include <sys/ioctl.h> 78 #include <sys/fcntl.h> 79 #include <sys/vnode.h> 80 81 82 #include "rf_archs.h" 83 #include "rf_threadstuff.h" 84 85 #include <sys/errno.h> 86 87 #include "rf_raid.h" 88 #include "rf_dag.h" 89 #include "rf_aselect.h" 90 #include "rf_diskqueue.h" 91 #include "rf_parityscan.h" 92 #include "rf_alloclist.h" 93 #include "rf_dagutils.h" 94 #include "rf_utils.h" 95 #include "rf_etimer.h" 96 #include "rf_acctrace.h" 97 #include "rf_general.h" 98 #include "rf_desc.h" 99 #include "rf_states.h" 100 #include "rf_decluster.h" 101 #include "rf_map.h" 102 #include "rf_revent.h" 103 #include "rf_callback.h" 104 #include "rf_engine.h" 105 #include "rf_mcpair.h" 106 #include "rf_nwayxor.h" 107 #include "rf_copyback.h" 108 #include "rf_driver.h" 109 #include "rf_options.h" 110 #include "rf_shutdown.h" 111 #include "rf_kintf.h" 112 #include "rf_paritymap.h" 113 114 #include <sys/buf.h> 115 116 #ifndef RF_ACCESS_DEBUG 117 #define RF_ACCESS_DEBUG 0 118 #endif 119 120 /* rad == RF_RaidAccessDesc_t */ 121 #define RF_MAX_FREE_RAD 128 122 #define RF_MIN_FREE_RAD 32 123 124 /* main configuration routines */ 125 static int raidframe_booted = 0; 126 127 static void rf_ConfigureDebug(RF_Config_t * cfgPtr); 128 static void set_debug_option(char *name, long val); 129 static void rf_UnconfigureArray(void); 130 static void rf_ShutdownRDFreeList(void *); 131 static int rf_ConfigureRDFreeList(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *); 132 133 rf_declare_mutex2(rf_printf_mutex); /* debug only: avoids interleaved 134 * printfs by different stripes */ 135 136 #define SIGNAL_QUIESCENT_COND(_raid_) \ 137 rf_broadcast_cond2((_raid_)->access_suspend_cv) 138 #define WAIT_FOR_QUIESCENCE(_raid_) \ 139 rf_wait_cond2((_raid_)->access_suspend_cv, \ 140 (_raid_)->access_suspend_mutex) 141 142 static int configureCount = 0; /* number of active configurations */ 143 static int isconfigged = 0; /* is basic raidframe (non per-array) 144 * stuff configured */ 145 static rf_declare_mutex2(configureMutex); /* used to lock the configuration 146 * stuff */ 147 static RF_ShutdownList_t *globalShutdown; /* non array-specific 148 * stuff */ 149 150 static int rf_ConfigureRDFreeList(RF_ShutdownList_t ** listp, RF_Raid_t *raidPtr, RF_Config_t *cfgPtr); 151 static int rf_AllocEmergBuffers(RF_Raid_t *); 152 static void rf_FreeEmergBuffers(RF_Raid_t *); 153 static void rf_destroy_mutex_cond(RF_Raid_t *); 154 static void rf_alloc_mutex_cond(RF_Raid_t *); 155 156 /* called at system boot time */ 157 int 158 rf_BootRaidframe(bool boot) 159 { 160 161 if (boot) { 162 if (raidframe_booted) 163 return (EBUSY); 164 raidframe_booted = 1; 165 rf_init_mutex2(configureMutex, IPL_NONE); 166 configureCount = 0; 167 isconfigged = 0; 168 globalShutdown = NULL; 169 } else { 170 rf_destroy_mutex2(configureMutex); 171 raidframe_booted = 0; 172 } 173 return (0); 174 } 175 176 /* 177 * Called whenever an array is shutdown 178 */ 179 static void 180 rf_UnconfigureArray(void) 181 { 182 183 rf_lock_mutex2(configureMutex); 184 if (--configureCount == 0) { /* if no active configurations, shut 185 * everything down */ 186 rf_destroy_mutex2(rf_printf_mutex); 187 isconfigged = 0; 188 rf_ShutdownList(&globalShutdown); 189 190 /* 191 * We must wait until now, because the AllocList module 192 * uses the DebugMem module. 193 */ 194 #if RF_DEBUG_MEM 195 if (rf_memDebug) 196 rf_print_unfreed(); 197 #endif 198 } 199 rf_unlock_mutex2(configureMutex); 200 } 201 202 /* 203 * Called to shut down an array. 204 */ 205 int 206 rf_Shutdown(RF_Raid_t *raidPtr) 207 { 208 209 if (!raidPtr->valid) { 210 RF_ERRORMSG("Attempt to shut down unconfigured RAIDframe driver. Aborting shutdown\n"); 211 return (EINVAL); 212 } 213 /* 214 * wait for outstanding IOs to land 215 * As described in rf_raid.h, we use the rad_freelist lock 216 * to protect the per-array info about outstanding descs 217 * since we need to do freelist locking anyway, and this 218 * cuts down on the amount of serialization we've got going 219 * on. 220 */ 221 rf_lock_mutex2(raidPtr->rad_lock); 222 if (raidPtr->waitShutdown) { 223 rf_unlock_mutex2(raidPtr->rad_lock); 224 return (EBUSY); 225 } 226 raidPtr->waitShutdown = 1; 227 while (raidPtr->nAccOutstanding) { 228 rf_wait_cond2(raidPtr->outstandingCond, raidPtr->rad_lock); 229 } 230 231 /* Wait for any parity re-writes to stop... */ 232 while (raidPtr->parity_rewrite_in_progress) { 233 printf("raid%d: Waiting for parity re-write to exit...\n", 234 raidPtr->raidid); 235 rf_wait_cond2(raidPtr->parity_rewrite_cv, raidPtr->rad_lock); 236 } 237 rf_unlock_mutex2(raidPtr->rad_lock); 238 239 /* Wait for any reconstruction to stop... */ 240 rf_lock_mutex2(raidPtr->mutex); 241 while (raidPtr->reconInProgress) { 242 printf("raid%d: Waiting for reconstruction to stop...\n", 243 raidPtr->raidid); 244 rf_wait_cond2(raidPtr->waitForReconCond, raidPtr->mutex); 245 } 246 rf_unlock_mutex2(raidPtr->mutex); 247 248 raidPtr->valid = 0; 249 250 if (raidPtr->parity_map != NULL) 251 rf_paritymap_detach(raidPtr); 252 253 rf_update_component_labels(raidPtr, RF_FINAL_COMPONENT_UPDATE); 254 255 rf_UnconfigureVnodes(raidPtr); 256 257 rf_FreeEmergBuffers(raidPtr); 258 259 rf_ShutdownList(&raidPtr->shutdownList); 260 261 rf_destroy_mutex_cond(raidPtr); 262 263 rf_UnconfigureArray(); 264 265 return (0); 266 } 267 268 269 #define DO_INIT_CONFIGURE(f) { \ 270 rc = f (&globalShutdown); \ 271 if (rc) { \ 272 RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \ 273 rf_ShutdownList(&globalShutdown); \ 274 configureCount--; \ 275 rf_unlock_mutex2(configureMutex); \ 276 rf_destroy_mutex2(rf_printf_mutex); \ 277 return(rc); \ 278 } \ 279 } 280 281 #define DO_RAID_FAIL() { \ 282 rf_UnconfigureVnodes(raidPtr); \ 283 rf_FreeEmergBuffers(raidPtr); \ 284 rf_ShutdownList(&raidPtr->shutdownList); \ 285 rf_UnconfigureArray(); \ 286 rf_destroy_mutex_cond(raidPtr); \ 287 } 288 289 #define DO_RAID_INIT_CONFIGURE(f) { \ 290 rc = f (&raidPtr->shutdownList, raidPtr, cfgPtr); \ 291 if (rc) { \ 292 RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \ 293 DO_RAID_FAIL(); \ 294 return(rc); \ 295 } \ 296 } 297 298 int 299 rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac) 300 { 301 RF_RowCol_t col; 302 int rc; 303 bool swapped = false; 304 bool first = true; 305 306 rf_lock_mutex2(configureMutex); 307 configureCount++; 308 if (isconfigged == 0) { 309 rf_init_mutex2(rf_printf_mutex, IPL_VM); 310 311 /* initialize globals */ 312 DO_INIT_CONFIGURE(rf_ConfigureAllocList); 313 314 /* 315 * Yes, this does make debugging general to the whole 316 * system instead of being array specific. Bummer, drag. 317 */ 318 rf_ConfigureDebug(cfgPtr); 319 DO_INIT_CONFIGURE(rf_ConfigureDebugMem); 320 #if RF_ACC_TRACE > 0 321 DO_INIT_CONFIGURE(rf_ConfigureAccessTrace); 322 #endif 323 DO_INIT_CONFIGURE(rf_ConfigureNWayXor); 324 DO_INIT_CONFIGURE(rf_ConfigureDAGFuncs); 325 DO_INIT_CONFIGURE(rf_ConfigureCopyback); 326 isconfigged = 1; 327 } 328 rf_unlock_mutex2(configureMutex); 329 330 rf_alloc_mutex_cond(raidPtr); 331 332 /* set up the cleanup list. Do this after ConfigureDebug so that 333 * value of memDebug will be set */ 334 335 rf_MakeAllocList(raidPtr->cleanupList); 336 if (raidPtr->cleanupList == NULL) { 337 DO_RAID_FAIL(); 338 return (ENOMEM); 339 } 340 rf_ShutdownCreate(&raidPtr->shutdownList, 341 (void (*) (void *)) rf_FreeAllocList, 342 raidPtr->cleanupList); 343 344 KASSERT(cfgPtr->numCol < RF_MAXCOL); 345 KASSERT(cfgPtr->numCol >= 0); 346 KASSERT(cfgPtr->numSpare < RF_MAXSPARE); 347 KASSERT(cfgPtr->numSpare >= 0); 348 349 raidPtr->numCol = cfgPtr->numCol; 350 raidPtr->numSpare = cfgPtr->numSpare; 351 352 raidPtr->status = rf_rs_optimal; 353 raidPtr->reconControl = NULL; 354 355 DO_RAID_INIT_CONFIGURE(rf_ConfigureMapModule); 356 DO_RAID_INIT_CONFIGURE(rf_ConfigureReconEvent); 357 DO_RAID_INIT_CONFIGURE(rf_ConfigureCallback); 358 DO_RAID_INIT_CONFIGURE(rf_ConfigureRDFreeList); 359 DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLockFreeList); 360 DO_RAID_INIT_CONFIGURE(rf_ConfigureMCPair); 361 DO_RAID_INIT_CONFIGURE(rf_ConfigureDAGs); 362 DO_RAID_INIT_CONFIGURE(rf_ConfigureReconstruction); 363 DO_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueueSystem); 364 DO_RAID_INIT_CONFIGURE(rf_ConfigurePSStatus); 365 366 DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine); 367 DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks); 368 369 raidPtr->nAccOutstanding = 0; 370 raidPtr->waitShutdown = 0; 371 372 if (ac!=NULL) { 373 /* We have an AutoConfig structure.. Don't do the 374 normal disk configuration... call the auto config 375 stuff */ 376 rf_AutoConfigureDisks(raidPtr, cfgPtr, ac); 377 } else { 378 DO_RAID_INIT_CONFIGURE(rf_ConfigureDisks); 379 DO_RAID_INIT_CONFIGURE(rf_ConfigureSpareDisks); 380 } 381 /* do this after ConfigureDisks & ConfigureSpareDisks to be sure dev 382 * no. is set */ 383 DO_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueues); 384 385 DO_RAID_INIT_CONFIGURE(rf_ConfigureLayout); 386 387 388 389 390 /* Initialize per-RAID PSS bits */ 391 rf_InitPSStatus(raidPtr); 392 393 #if RF_INCLUDE_CHAINDECLUSTER > 0 394 for (col = 0; col < raidPtr->numCol; col++) { 395 /* 396 * XXX better distribution 397 */ 398 raidPtr->hist_diskreq[col] = 0; 399 } 400 #endif 401 raidPtr->numNewFailures = 0; 402 raidPtr->copyback_in_progress = 0; 403 raidPtr->parity_rewrite_in_progress = 0; 404 raidPtr->adding_hot_spare = 0; 405 raidPtr->recon_in_progress = 0; 406 407 raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs; 408 409 /* autoconfigure and root_partition will actually get filled in 410 after the config is done */ 411 raidPtr->autoconfigure = 0; 412 raidPtr->root_partition = 0; 413 raidPtr->last_unit = raidPtr->raidid; 414 raidPtr->config_order = 0; 415 416 if (rf_keepAccTotals) { 417 raidPtr->keep_acc_totals = 1; 418 } 419 420 /* Allocate a bunch of buffers to be used in low-memory conditions */ 421 raidPtr->iobuf = NULL; 422 423 rc = rf_AllocEmergBuffers(raidPtr); 424 if (rc) { 425 printf("raid%d: Unable to allocate emergency buffers.\n", 426 raidPtr->raidid); 427 DO_RAID_FAIL(); 428 return(rc); 429 } 430 431 /* Set up parity map stuff, if applicable. */ 432 #ifndef RF_NO_PARITY_MAP 433 rf_paritymap_attach(raidPtr, cfgPtr->force); 434 #endif 435 436 raidPtr->valid = 1; 437 438 printf("raid%d: %s\n", raidPtr->raidid, 439 raidPtr->Layout.map->configName); 440 printf("raid%d: Components:", raidPtr->raidid); 441 442 for (col = 0; col < raidPtr->numCol; col++) { 443 RF_ComponentLabel_t *clabel; 444 bool compswapped; 445 446 printf(" %s", raidPtr->Disks[col].devname); 447 if (RF_DEAD_DISK(raidPtr->Disks[col].status)) { 448 printf("[**FAILED**]"); 449 } 450 clabel = raidget_component_label(raidPtr, col); 451 compswapped = clabel->version == 452 bswap32(RF_COMPONENT_LABEL_VERSION); 453 if (first) 454 swapped = compswapped; 455 else if (swapped != compswapped) 456 printf("raid%d: Component %d has different endian " 457 "than first component.", raidPtr->raidid, col); 458 } 459 printf("\n"); 460 printf("raid%d: Total Sectors: %" PRIu64 " (%" PRIu64 " MB)\n", 461 raidPtr->raidid, 462 raidPtr->totalSectors, 463 (raidPtr->totalSectors / 1024 * 464 (1 << raidPtr->logBytesPerSector) / 1024)); 465 if (swapped) 466 printf("raid%d: Using swapped-endian component labels.\n", 467 raidPtr->raidid); 468 469 return (0); 470 } 471 472 473 /* 474 475 Routines to allocate and free the "emergency buffers" for a given 476 RAID set. These emergency buffers will be used when the kernel runs 477 out of kernel memory. 478 479 */ 480 481 static int 482 rf_AllocEmergBuffers(RF_Raid_t *raidPtr) 483 { 484 void *tmpbuf; 485 RF_VoidPointerListElem_t *vple; 486 int i; 487 488 /* XXX next line needs tuning... */ 489 raidPtr->numEmergencyBuffers = 10 * raidPtr->numCol; 490 #if DEBUG 491 printf("raid%d: allocating %d buffers of %d bytes.\n", 492 raidPtr->raidid, 493 raidPtr->numEmergencyBuffers, 494 (int)(raidPtr->Layout.sectorsPerStripeUnit << 495 raidPtr->logBytesPerSector)); 496 #endif 497 for (i = 0; i < raidPtr->numEmergencyBuffers; i++) { 498 tmpbuf = malloc( raidPtr->Layout.sectorsPerStripeUnit << 499 raidPtr->logBytesPerSector, 500 M_RAIDFRAME, M_WAITOK); 501 if (tmpbuf) { 502 vple = rf_AllocVPListElem(raidPtr); 503 vple->p= tmpbuf; 504 vple->next = raidPtr->iobuf; 505 raidPtr->iobuf = vple; 506 raidPtr->iobuf_count++; 507 } else { 508 printf("raid%d: failed to allocate emergency buffer!\n", 509 raidPtr->raidid); 510 return 1; 511 } 512 } 513 514 /* XXX next line needs tuning too... */ 515 raidPtr->numEmergencyStripeBuffers = 10; 516 for (i = 0; i < raidPtr->numEmergencyStripeBuffers; i++) { 517 tmpbuf = malloc( raidPtr->numCol * (raidPtr->Layout.sectorsPerStripeUnit << 518 raidPtr->logBytesPerSector), 519 M_RAIDFRAME, M_WAITOK); 520 if (tmpbuf) { 521 vple = rf_AllocVPListElem(raidPtr); 522 vple->p= tmpbuf; 523 vple->next = raidPtr->stripebuf; 524 raidPtr->stripebuf = vple; 525 raidPtr->stripebuf_count++; 526 } else { 527 printf("raid%d: failed to allocate emergency stripe buffer!\n", 528 raidPtr->raidid); 529 return 1; 530 } 531 } 532 533 return (0); 534 } 535 536 static void 537 rf_FreeEmergBuffers(RF_Raid_t *raidPtr) 538 { 539 RF_VoidPointerListElem_t *tmp; 540 541 /* Free the emergency IO buffers */ 542 while (raidPtr->iobuf != NULL) { 543 tmp = raidPtr->iobuf; 544 raidPtr->iobuf = raidPtr->iobuf->next; 545 free(tmp->p, M_RAIDFRAME); 546 rf_FreeVPListElem(raidPtr,tmp); 547 } 548 549 /* Free the emergency stripe buffers */ 550 while (raidPtr->stripebuf != NULL) { 551 tmp = raidPtr->stripebuf; 552 raidPtr->stripebuf = raidPtr->stripebuf->next; 553 free(tmp->p, M_RAIDFRAME); 554 rf_FreeVPListElem(raidPtr, tmp); 555 } 556 } 557 558 559 static void 560 rf_ShutdownRDFreeList(void *arg) 561 { 562 RF_Raid_t *raidPtr; 563 564 raidPtr = (RF_Raid_t *) arg; 565 566 pool_destroy(&raidPtr->pools.rad); 567 } 568 569 static int 570 rf_ConfigureRDFreeList(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr, 571 RF_Config_t *cfgPtr) 572 { 573 574 rf_pool_init(raidPtr, raidPtr->poolNames.rad, &raidPtr->pools.rad, sizeof(RF_RaidAccessDesc_t), 575 "rad", RF_MIN_FREE_RAD, RF_MAX_FREE_RAD); 576 rf_ShutdownCreate(listp, rf_ShutdownRDFreeList, raidPtr); 577 return (0); 578 } 579 580 RF_RaidAccessDesc_t * 581 rf_AllocRaidAccDesc(RF_Raid_t *raidPtr, RF_IoType_t type, 582 RF_RaidAddr_t raidAddress, RF_SectorCount_t numBlocks, 583 void *bufPtr, void *bp, RF_RaidAccessFlags_t flags, 584 const RF_AccessState_t *states) 585 { 586 RF_RaidAccessDesc_t *desc; 587 588 desc = pool_get(&raidPtr->pools.rad, PR_WAITOK); 589 590 rf_lock_mutex2(raidPtr->rad_lock); 591 if (raidPtr->waitShutdown) { 592 /* 593 * Actually, we're shutting the array down. Free the desc 594 * and return NULL. 595 */ 596 597 rf_unlock_mutex2(raidPtr->rad_lock); 598 pool_put(&raidPtr->pools.rad, desc); 599 return (NULL); 600 } 601 raidPtr->nAccOutstanding++; 602 603 rf_unlock_mutex2(raidPtr->rad_lock); 604 605 desc->raidPtr = (void *) raidPtr; 606 desc->type = type; 607 desc->raidAddress = raidAddress; 608 desc->numBlocks = numBlocks; 609 desc->bufPtr = bufPtr; 610 desc->bp = bp; 611 desc->flags = flags; 612 desc->states = states; 613 desc->state = 0; 614 desc->dagList = NULL; 615 616 desc->status = 0; 617 desc->numRetries = 0; 618 #if RF_ACC_TRACE > 0 619 memset(&desc->tracerec, 0, sizeof(desc->tracerec)); 620 #endif 621 desc->callbackFunc = NULL; 622 desc->callbackArg = NULL; 623 desc->next = NULL; 624 desc->iobufs = NULL; 625 desc->stripebufs = NULL; 626 627 return (desc); 628 } 629 630 void 631 rf_FreeRaidAccDesc(RF_RaidAccessDesc_t *desc) 632 { 633 RF_Raid_t *raidPtr = desc->raidPtr; 634 RF_DagList_t *dagList, *temp; 635 RF_VoidPointerListElem_t *tmp; 636 637 RF_ASSERT(desc); 638 639 /* Cleanup the dagList(s) */ 640 dagList = desc->dagList; 641 while(dagList != NULL) { 642 temp = dagList; 643 dagList = dagList->next; 644 rf_FreeDAGList(raidPtr, temp); 645 } 646 647 while (desc->iobufs) { 648 tmp = desc->iobufs; 649 desc->iobufs = desc->iobufs->next; 650 rf_FreeIOBuffer(raidPtr, tmp); 651 } 652 653 while (desc->stripebufs) { 654 tmp = desc->stripebufs; 655 desc->stripebufs = desc->stripebufs->next; 656 rf_FreeStripeBuffer(raidPtr, tmp); 657 } 658 659 pool_put(&raidPtr->pools.rad, desc); 660 rf_lock_mutex2(raidPtr->rad_lock); 661 raidPtr->nAccOutstanding--; 662 if (raidPtr->waitShutdown) { 663 rf_signal_cond2(raidPtr->outstandingCond); 664 } 665 rf_unlock_mutex2(raidPtr->rad_lock); 666 } 667 /********************************************************************* 668 * Main routine for performing an access. 669 * Accesses are retried until a DAG can not be selected. This occurs 670 * when either the DAG library is incomplete or there are too many 671 * failures in a parity group. 672 * 673 * type should be read or write. bp_in is a buf pointer. void *to 674 * facilitate ignoring it outside the kernel 675 ********************************************************************/ 676 int 677 rf_DoAccess(RF_Raid_t * raidPtr, RF_IoType_t type, RF_RaidAddr_t raidAddress, RF_SectorCount_t numBlocks, 678 void *bufPtr, struct buf *bp, RF_RaidAccessFlags_t flags) 679 { 680 RF_RaidAccessDesc_t *desc; 681 void *lbufPtr = bufPtr; 682 683 raidAddress += rf_raidSectorOffset; 684 685 #if RF_ACCESS_DEBUG 686 if (rf_accessDebug) { 687 688 printf("logBytes is: %d %d %d\n", raidPtr->raidid, 689 raidPtr->logBytesPerSector, 690 (int) rf_RaidAddressToByte(raidPtr, numBlocks)); 691 printf("raid%d: %s raidAddr %d (stripeid %d-%d) numBlocks %d (%d bytes) buf 0x%lx\n", raidPtr->raidid, 692 (type == RF_IO_TYPE_READ) ? "READ" : "WRITE", (int) raidAddress, 693 (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress), 694 (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress + numBlocks - 1), 695 (int) numBlocks, 696 (int) rf_RaidAddressToByte(raidPtr, numBlocks), 697 (long) bufPtr); 698 } 699 #endif 700 701 desc = rf_AllocRaidAccDesc(raidPtr, type, raidAddress, 702 numBlocks, lbufPtr, bp, flags, raidPtr->Layout.map->states); 703 704 if (desc == NULL) { 705 return (ENOMEM); 706 } 707 #if RF_ACC_TRACE > 0 708 RF_ETIMER_START(desc->tracerec.tot_timer); 709 #endif 710 711 if (raidPtr->parity_map != NULL && 712 type == RF_IO_TYPE_WRITE) 713 rf_paritymap_begin(raidPtr->parity_map, raidAddress, 714 numBlocks); 715 716 rf_ContinueRaidAccess(desc); 717 718 return (0); 719 } 720 #if 0 721 /* force the array into reconfigured mode without doing reconstruction */ 722 int 723 rf_SetReconfiguredMode(RF_Raid_t *raidPtr, int col) 724 { 725 if (!(raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) { 726 printf("Can't set reconfigured mode in dedicated-spare array\n"); 727 RF_PANIC(); 728 } 729 rf_lock_mutex2(raidPtr->mutex); 730 raidPtr->numFailures++; 731 raidPtr->Disks[col].status = rf_ds_dist_spared; 732 raidPtr->status = rf_rs_reconfigured; 733 rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); 734 /* install spare table only if declustering + distributed sparing 735 * architecture. */ 736 if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED) 737 rf_InstallSpareTable(raidPtr, col); 738 rf_unlock_mutex2(raidPtr->mutex); 739 return (0); 740 } 741 #endif 742 743 int 744 rf_FailDisk(RF_Raid_t *raidPtr, int fcol, int initRecon) 745 { 746 747 /* need to suspend IO's here -- if there are DAGs in flight 748 and we pull the rug out from under ci_vp, Bad Things 749 can happen. */ 750 751 rf_SuspendNewRequestsAndWait(raidPtr); 752 753 rf_lock_mutex2(raidPtr->mutex); 754 if (raidPtr->Disks[fcol].status != rf_ds_failed) { 755 /* must be failing something that is valid, or else it's 756 already marked as failed (in which case we don't 757 want to mark it failed again!) */ 758 raidPtr->numFailures++; 759 raidPtr->Disks[fcol].status = rf_ds_failed; 760 raidPtr->status = rf_rs_degraded; 761 } 762 rf_unlock_mutex2(raidPtr->mutex); 763 764 rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); 765 766 /* Close the component, so that it's not "locked" if someone 767 else want's to use it! */ 768 769 rf_close_component(raidPtr, raidPtr->raid_cinfo[fcol].ci_vp, 770 raidPtr->Disks[fcol].auto_configured); 771 772 rf_lock_mutex2(raidPtr->mutex); 773 raidPtr->raid_cinfo[fcol].ci_vp = NULL; 774 775 /* Need to mark the component as not being auto_configured 776 (in case it was previously). */ 777 778 raidPtr->Disks[fcol].auto_configured = 0; 779 rf_unlock_mutex2(raidPtr->mutex); 780 /* now we can allow IO to continue -- we'll be suspending it 781 again in rf_ReconstructFailedDisk() if we have to.. */ 782 783 rf_ResumeNewRequests(raidPtr); 784 785 if (initRecon) 786 rf_ReconstructFailedDisk(raidPtr, fcol); 787 return (0); 788 } 789 /* releases a thread that is waiting for the array to become quiesced. 790 * access_suspend_mutex should be locked upon calling this 791 */ 792 void 793 rf_SignalQuiescenceLock(RF_Raid_t *raidPtr) 794 { 795 #if RF_DEBUG_QUIESCE 796 if (rf_quiesceDebug) { 797 printf("raid%d: Signalling quiescence lock\n", 798 raidPtr->raidid); 799 } 800 #endif 801 raidPtr->access_suspend_release = 1; 802 803 if (raidPtr->waiting_for_quiescence) { 804 SIGNAL_QUIESCENT_COND(raidPtr); 805 } 806 } 807 /* suspends all new requests to the array. No effect on accesses that are in flight. */ 808 int 809 rf_SuspendNewRequestsAndWait(RF_Raid_t *raidPtr) 810 { 811 #if RF_DEBUG_QUIESCE 812 if (rf_quiesceDebug) 813 printf("raid%d: Suspending new reqs\n", raidPtr->raidid); 814 #endif 815 rf_lock_mutex2(raidPtr->access_suspend_mutex); 816 raidPtr->accesses_suspended++; 817 raidPtr->waiting_for_quiescence = (raidPtr->accs_in_flight == 0) ? 0 : 1; 818 819 if (raidPtr->waiting_for_quiescence) { 820 raidPtr->access_suspend_release = 0; 821 while (!raidPtr->access_suspend_release) { 822 #if RF_DEBUG_QUIESCE 823 printf("raid%d: Suspending: Waiting for Quiescence\n", 824 raidPtr->raidid); 825 #endif 826 WAIT_FOR_QUIESCENCE(raidPtr); 827 raidPtr->waiting_for_quiescence = 0; 828 } 829 } 830 #if RF_DEBUG_QUIESCE 831 printf("raid%d: Quiescence reached..\n", raidPtr->raidid); 832 #endif 833 834 rf_unlock_mutex2(raidPtr->access_suspend_mutex); 835 return (raidPtr->waiting_for_quiescence); 836 } 837 /* wake up everyone waiting for quiescence to be released */ 838 void 839 rf_ResumeNewRequests(RF_Raid_t *raidPtr) 840 { 841 RF_CallbackFuncDesc_t *t, *cb; 842 843 #if RF_DEBUG_QUIESCE 844 if (rf_quiesceDebug) 845 printf("raid%d: Resuming new requests\n", raidPtr->raidid); 846 #endif 847 848 rf_lock_mutex2(raidPtr->access_suspend_mutex); 849 raidPtr->accesses_suspended--; 850 if (raidPtr->accesses_suspended == 0) 851 cb = raidPtr->quiesce_wait_list; 852 else 853 cb = NULL; 854 raidPtr->quiesce_wait_list = NULL; 855 rf_unlock_mutex2(raidPtr->access_suspend_mutex); 856 857 while (cb) { 858 t = cb; 859 cb = cb->next; 860 (t->callbackFunc) (t->callbackArg); 861 rf_FreeCallbackFuncDesc(raidPtr, t); 862 } 863 } 864 /***************************************************************************************** 865 * 866 * debug routines 867 * 868 ****************************************************************************************/ 869 870 static void 871 set_debug_option(char *name, long val) 872 { 873 RF_DebugName_t *p; 874 875 for (p = rf_debugNames; p->name; p++) { 876 if (!strcmp(p->name, name)) { 877 *(p->ptr) = val; 878 printf("[Set debug variable %s to %ld]\n", name, val); 879 return; 880 } 881 } 882 RF_ERRORMSG1("Unknown debug string \"%s\"\n", name); 883 } 884 885 886 /* would like to use sscanf here, but apparently not available in kernel */ 887 /*ARGSUSED*/ 888 static void 889 rf_ConfigureDebug(RF_Config_t *cfgPtr) 890 { 891 char *val_p, *name_p, *white_p; 892 long val; 893 int i; 894 895 rf_ResetDebugOptions(); 896 for (i = 0; i < RF_MAXDBGV && cfgPtr->debugVars[i][0]; i++) { 897 name_p = rf_find_non_white(&cfgPtr->debugVars[i][0]); 898 white_p = rf_find_white(name_p); /* skip to start of 2nd 899 * word */ 900 val_p = rf_find_non_white(white_p); 901 if (*val_p == '0' && *(val_p + 1) == 'x') 902 val = rf_htoi(val_p + 2); 903 else 904 val = rf_atoi(val_p); 905 *white_p = '\0'; 906 set_debug_option(name_p, val); 907 } 908 } 909 910 void 911 rf_print_panic_message(int line, const char *file) 912 { 913 kern_assert("raidframe error at line %d file %s", line, file); 914 } 915 916 #ifdef RAID_DIAGNOSTIC 917 void 918 rf_print_assert_panic_message(int line, const char *file, const char *condition) 919 { 920 kern_assert("raidframe error at line %d file %s (failed asserting %s)\n", 921 line, file, condition); 922 } 923 #endif 924 925 void 926 rf_print_unable_to_init_mutex(const char *file, int line, int rc) 927 { 928 RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 929 file, line, rc); 930 } 931 932 void 933 rf_print_unable_to_add_shutdown(const char *file, int line, int rc) 934 { 935 RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", 936 file, line, rc); 937 } 938 939 static void 940 rf_alloc_mutex_cond(RF_Raid_t *raidPtr) 941 { 942 943 rf_init_mutex2(raidPtr->mutex, IPL_VM); 944 945 rf_init_cond2(raidPtr->outstandingCond, "rfocond"); 946 rf_init_cond2(raidPtr->parity_rewrite_cv, "rfprwshutdown"); 947 rf_init_mutex2(raidPtr->rad_lock, IPL_VM); 948 949 rf_init_mutex2(raidPtr->access_suspend_mutex, IPL_VM); 950 rf_init_cond2(raidPtr->access_suspend_cv, "rfquiesce"); 951 952 rf_init_cond2(raidPtr->waitForReconCond, "rfrcnw"); 953 954 rf_init_cond2(raidPtr->adding_hot_spare_cv, "raidhs"); 955 } 956 957 static void 958 rf_destroy_mutex_cond(RF_Raid_t *raidPtr) 959 { 960 961 rf_destroy_cond2(raidPtr->waitForReconCond); 962 rf_destroy_cond2(raidPtr->adding_hot_spare_cv); 963 964 rf_destroy_mutex2(raidPtr->access_suspend_mutex); 965 rf_destroy_cond2(raidPtr->access_suspend_cv); 966 967 rf_destroy_cond2(raidPtr->parity_rewrite_cv); 968 rf_destroy_cond2(raidPtr->outstandingCond); 969 rf_destroy_mutex2(raidPtr->rad_lock); 970 971 rf_destroy_mutex2(raidPtr->mutex); 972 } 973