1 /* $NetBSD: rf_driver.c,v 1.46 2002/01/07 01:58:03 oster 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 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed by the NetBSD 20 * Foundation, Inc. and its contributors. 21 * 4. Neither the name of The NetBSD Foundation nor the names of its 22 * contributors may be used to endorse or promote products derived 23 * from this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 26 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 /* 39 * Copyright (c) 1995 Carnegie-Mellon University. 40 * All rights reserved. 41 * 42 * Author: Mark Holland, Khalil Amiri, Claudson Bornstein, William V. Courtright II, 43 * Robby Findler, Daniel Stodolsky, Rachad Youssef, Jim Zelenka 44 * 45 * Permission to use, copy, modify and distribute this software and 46 * its documentation is hereby granted, provided that both the copyright 47 * notice and this permission notice appear in all copies of the 48 * software, derivative works or modified versions, and any portions 49 * thereof, and that both notices appear in supporting documentation. 50 * 51 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 52 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 53 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 54 * 55 * Carnegie Mellon requests users of this software to return to 56 * 57 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 58 * School of Computer Science 59 * Carnegie Mellon University 60 * Pittsburgh PA 15213-3890 61 * 62 * any improvements or extensions that they make and grant Carnegie the 63 * rights to redistribute these changes. 64 */ 65 66 /****************************************************************************** 67 * 68 * rf_driver.c -- main setup, teardown, and access routines for the RAID driver 69 * 70 * all routines are prefixed with rf_ (raidframe), to avoid conficts. 71 * 72 ******************************************************************************/ 73 74 75 #include <sys/cdefs.h> 76 __KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.46 2002/01/07 01:58:03 oster Exp $"); 77 78 #include <sys/param.h> 79 #include <sys/systm.h> 80 #include <sys/ioctl.h> 81 #include <sys/fcntl.h> 82 #include <sys/vnode.h> 83 84 85 #include "rf_archs.h" 86 #include "rf_threadstuff.h" 87 88 #include <sys/errno.h> 89 90 #include "rf_raid.h" 91 #include "rf_dag.h" 92 #include "rf_aselect.h" 93 #include "rf_diskqueue.h" 94 #include "rf_parityscan.h" 95 #include "rf_alloclist.h" 96 #include "rf_dagutils.h" 97 #include "rf_utils.h" 98 #include "rf_etimer.h" 99 #include "rf_acctrace.h" 100 #include "rf_general.h" 101 #include "rf_desc.h" 102 #include "rf_states.h" 103 #include "rf_freelist.h" 104 #include "rf_decluster.h" 105 #include "rf_map.h" 106 #include "rf_revent.h" 107 #include "rf_callback.h" 108 #include "rf_engine.h" 109 #include "rf_memchunk.h" 110 #include "rf_mcpair.h" 111 #include "rf_nwayxor.h" 112 #include "rf_debugprint.h" 113 #include "rf_copyback.h" 114 #include "rf_driver.h" 115 #include "rf_options.h" 116 #include "rf_shutdown.h" 117 #include "rf_kintf.h" 118 119 #include <sys/buf.h> 120 121 /* rad == RF_RaidAccessDesc_t */ 122 static RF_FreeList_t *rf_rad_freelist; 123 #define RF_MAX_FREE_RAD 128 124 #define RF_RAD_INC 16 125 #define RF_RAD_INITIAL 32 126 127 /* debug variables */ 128 char rf_panicbuf[2048]; /* a buffer to hold an error msg when we panic */ 129 130 /* main configuration routines */ 131 static int raidframe_booted = 0; 132 133 static void rf_ConfigureDebug(RF_Config_t * cfgPtr); 134 static void set_debug_option(char *name, long val); 135 static void rf_UnconfigureArray(void); 136 static int init_rad(RF_RaidAccessDesc_t *); 137 static void clean_rad(RF_RaidAccessDesc_t *); 138 static void rf_ShutdownRDFreeList(void *); 139 static int rf_ConfigureRDFreeList(RF_ShutdownList_t **); 140 141 RF_DECLARE_MUTEX(rf_printf_mutex) /* debug only: avoids interleaved 142 * printfs by different stripes */ 143 144 #define SIGNAL_QUIESCENT_COND(_raid_) wakeup(&((_raid_)->accesses_suspended)) 145 #define WAIT_FOR_QUIESCENCE(_raid_) \ 146 ltsleep(&((_raid_)->accesses_suspended), PRIBIO, \ 147 "raidframe quiesce", 0, &((_raid_)->access_suspend_mutex)) 148 149 #define IO_BUF_ERR(bp, err) { \ 150 bp->b_flags |= B_ERROR; \ 151 bp->b_resid = bp->b_bcount; \ 152 bp->b_error = err; \ 153 biodone(bp); \ 154 } 155 156 static int configureCount = 0; /* number of active configurations */ 157 static int isconfigged = 0; /* is basic raidframe (non per-array) 158 * stuff configged */ 159 RF_DECLARE_STATIC_MUTEX(configureMutex) /* used to lock the configuration 160 * stuff */ 161 static RF_ShutdownList_t *globalShutdown; /* non array-specific 162 * stuff */ 163 164 static int rf_ConfigureRDFreeList(RF_ShutdownList_t ** listp); 165 166 /* called at system boot time */ 167 int 168 rf_BootRaidframe() 169 { 170 int rc; 171 172 if (raidframe_booted) 173 return (EBUSY); 174 raidframe_booted = 1; 175 176 rc = rf_mutex_init(&configureMutex); 177 if (rc) { 178 RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__, 179 __LINE__, rc); 180 RF_PANIC(); 181 } 182 configureCount = 0; 183 isconfigged = 0; 184 globalShutdown = NULL; 185 return (0); 186 } 187 /* 188 * This function is really just for debugging user-level stuff: it 189 * frees up all memory, other RAIDframe resources which might otherwise 190 * be kept around. This is used with systems like "sentinel" to detect 191 * memory leaks. 192 */ 193 int 194 rf_UnbootRaidframe() 195 { 196 int rc; 197 198 RF_LOCK_MUTEX(configureMutex); 199 if (configureCount) { 200 RF_UNLOCK_MUTEX(configureMutex); 201 return (EBUSY); 202 } 203 raidframe_booted = 0; 204 RF_UNLOCK_MUTEX(configureMutex); 205 rc = rf_mutex_destroy(&configureMutex); 206 if (rc) { 207 RF_ERRORMSG3("Unable to destroy mutex file %s line %d rc=%d\n", __FILE__, 208 __LINE__, rc); 209 RF_PANIC(); 210 } 211 return (0); 212 } 213 /* 214 * Called whenever an array is shutdown 215 */ 216 static void 217 rf_UnconfigureArray() 218 { 219 int rc; 220 221 RF_LOCK_MUTEX(configureMutex); 222 if (--configureCount == 0) { /* if no active configurations, shut 223 * everything down */ 224 isconfigged = 0; 225 226 rc = rf_ShutdownList(&globalShutdown); 227 if (rc) { 228 RF_ERRORMSG1("RAIDFRAME: unable to do global shutdown, rc=%d\n", rc); 229 } 230 231 /* 232 * We must wait until now, because the AllocList module 233 * uses the DebugMem module. 234 */ 235 if (rf_memDebug) 236 rf_print_unfreed(); 237 } 238 RF_UNLOCK_MUTEX(configureMutex); 239 } 240 241 /* 242 * Called to shut down an array. 243 */ 244 int 245 rf_Shutdown(raidPtr) 246 RF_Raid_t *raidPtr; 247 { 248 249 if (!raidPtr->valid) { 250 RF_ERRORMSG("Attempt to shut down unconfigured RAIDframe driver. Aborting shutdown\n"); 251 return (EINVAL); 252 } 253 /* 254 * wait for outstanding IOs to land 255 * As described in rf_raid.h, we use the rad_freelist lock 256 * to protect the per-array info about outstanding descs 257 * since we need to do freelist locking anyway, and this 258 * cuts down on the amount of serialization we've got going 259 * on. 260 */ 261 RF_FREELIST_DO_LOCK(rf_rad_freelist); 262 if (raidPtr->waitShutdown) { 263 RF_FREELIST_DO_UNLOCK(rf_rad_freelist); 264 return (EBUSY); 265 } 266 raidPtr->waitShutdown = 1; 267 while (raidPtr->nAccOutstanding) { 268 RF_WAIT_COND(raidPtr->outstandingCond, RF_FREELIST_MUTEX_OF(rf_rad_freelist)); 269 } 270 RF_FREELIST_DO_UNLOCK(rf_rad_freelist); 271 272 /* Wait for any parity re-writes to stop... */ 273 while (raidPtr->parity_rewrite_in_progress) { 274 printf("Waiting for parity re-write to exit...\n"); 275 tsleep(&raidPtr->parity_rewrite_in_progress, PRIBIO, 276 "rfprwshutdown", 0); 277 } 278 279 raidPtr->valid = 0; 280 281 rf_update_component_labels(raidPtr, RF_FINAL_COMPONENT_UPDATE); 282 283 rf_UnconfigureVnodes(raidPtr); 284 285 rf_ShutdownList(&raidPtr->shutdownList); 286 287 rf_UnconfigureArray(); 288 289 return (0); 290 } 291 292 293 #define DO_INIT_CONFIGURE(f) { \ 294 rc = f (&globalShutdown); \ 295 if (rc) { \ 296 RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \ 297 rf_ShutdownList(&globalShutdown); \ 298 configureCount--; \ 299 RF_UNLOCK_MUTEX(configureMutex); \ 300 return(rc); \ 301 } \ 302 } 303 304 #define DO_RAID_FAIL() { \ 305 rf_UnconfigureVnodes(raidPtr); \ 306 rf_ShutdownList(&raidPtr->shutdownList); \ 307 rf_UnconfigureArray(); \ 308 } 309 310 #define DO_RAID_INIT_CONFIGURE(f) { \ 311 rc = f (&raidPtr->shutdownList, raidPtr, cfgPtr); \ 312 if (rc) { \ 313 RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \ 314 DO_RAID_FAIL(); \ 315 return(rc); \ 316 } \ 317 } 318 319 #define DO_RAID_MUTEX(_m_) { \ 320 rc = rf_create_managed_mutex(&raidPtr->shutdownList, (_m_)); \ 321 if (rc) { \ 322 RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", \ 323 __FILE__, __LINE__, rc); \ 324 DO_RAID_FAIL(); \ 325 return(rc); \ 326 } \ 327 } 328 329 #define DO_RAID_COND(_c_) { \ 330 rc = rf_create_managed_cond(&raidPtr->shutdownList, (_c_)); \ 331 if (rc) { \ 332 RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", \ 333 __FILE__, __LINE__, rc); \ 334 DO_RAID_FAIL(); \ 335 return(rc); \ 336 } \ 337 } 338 339 int 340 rf_Configure(raidPtr, cfgPtr, ac) 341 RF_Raid_t *raidPtr; 342 RF_Config_t *cfgPtr; 343 RF_AutoConfig_t *ac; 344 { 345 RF_RowCol_t row, col; 346 int i, rc; 347 348 /* XXX This check can probably be removed now, since 349 RAIDFRAME_CONFIGURRE now checks to make sure that the 350 RAID set is not already valid 351 */ 352 if (raidPtr->valid) { 353 RF_ERRORMSG("RAIDframe configuration not shut down. Aborting configure.\n"); 354 return (EINVAL); 355 } 356 RF_LOCK_MUTEX(configureMutex); 357 configureCount++; 358 if (isconfigged == 0) { 359 rc = rf_create_managed_mutex(&globalShutdown, &rf_printf_mutex); 360 if (rc) { 361 RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__, 362 __LINE__, rc); 363 rf_ShutdownList(&globalShutdown); 364 return (rc); 365 } 366 /* initialize globals */ 367 printf("RAIDFRAME: protectedSectors is %ld\n", 368 rf_protectedSectors); 369 370 rf_clear_debug_print_buffer(); 371 372 DO_INIT_CONFIGURE(rf_ConfigureAllocList); 373 374 /* 375 * Yes, this does make debugging general to the whole 376 * system instead of being array specific. Bummer, drag. 377 */ 378 rf_ConfigureDebug(cfgPtr); 379 DO_INIT_CONFIGURE(rf_ConfigureDebugMem); 380 DO_INIT_CONFIGURE(rf_ConfigureAccessTrace); 381 DO_INIT_CONFIGURE(rf_ConfigureMapModule); 382 DO_INIT_CONFIGURE(rf_ConfigureReconEvent); 383 DO_INIT_CONFIGURE(rf_ConfigureCallback); 384 DO_INIT_CONFIGURE(rf_ConfigureMemChunk); 385 DO_INIT_CONFIGURE(rf_ConfigureRDFreeList); 386 DO_INIT_CONFIGURE(rf_ConfigureNWayXor); 387 DO_INIT_CONFIGURE(rf_ConfigureStripeLockFreeList); 388 DO_INIT_CONFIGURE(rf_ConfigureMCPair); 389 DO_INIT_CONFIGURE(rf_ConfigureDAGs); 390 DO_INIT_CONFIGURE(rf_ConfigureDAGFuncs); 391 DO_INIT_CONFIGURE(rf_ConfigureDebugPrint); 392 DO_INIT_CONFIGURE(rf_ConfigureReconstruction); 393 DO_INIT_CONFIGURE(rf_ConfigureCopyback); 394 DO_INIT_CONFIGURE(rf_ConfigureDiskQueueSystem); 395 isconfigged = 1; 396 } 397 RF_UNLOCK_MUTEX(configureMutex); 398 399 DO_RAID_MUTEX(&raidPtr->mutex); 400 /* set up the cleanup list. Do this after ConfigureDebug so that 401 * value of memDebug will be set */ 402 403 rf_MakeAllocList(raidPtr->cleanupList); 404 if (raidPtr->cleanupList == NULL) { 405 DO_RAID_FAIL(); 406 return (ENOMEM); 407 } 408 rc = rf_ShutdownCreate(&raidPtr->shutdownList, 409 (void (*) (void *)) rf_FreeAllocList, 410 raidPtr->cleanupList); 411 if (rc) { 412 RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", 413 __FILE__, __LINE__, rc); 414 DO_RAID_FAIL(); 415 return (rc); 416 } 417 raidPtr->numRow = cfgPtr->numRow; 418 raidPtr->numCol = cfgPtr->numCol; 419 raidPtr->numSpare = cfgPtr->numSpare; 420 421 /* XXX we don't even pretend to support more than one row in the 422 * kernel... */ 423 if (raidPtr->numRow != 1) { 424 RF_ERRORMSG("Only one row supported in kernel.\n"); 425 DO_RAID_FAIL(); 426 return (EINVAL); 427 } 428 RF_CallocAndAdd(raidPtr->status, raidPtr->numRow, sizeof(RF_RowStatus_t), 429 (RF_RowStatus_t *), raidPtr->cleanupList); 430 if (raidPtr->status == NULL) { 431 DO_RAID_FAIL(); 432 return (ENOMEM); 433 } 434 RF_CallocAndAdd(raidPtr->reconControl, raidPtr->numRow, 435 sizeof(RF_ReconCtrl_t *), (RF_ReconCtrl_t **), raidPtr->cleanupList); 436 if (raidPtr->reconControl == NULL) { 437 DO_RAID_FAIL(); 438 return (ENOMEM); 439 } 440 for (i = 0; i < raidPtr->numRow; i++) { 441 raidPtr->status[i] = rf_rs_optimal; 442 raidPtr->reconControl[i] = NULL; 443 } 444 445 DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine); 446 DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks); 447 448 DO_RAID_COND(&raidPtr->outstandingCond); 449 450 raidPtr->nAccOutstanding = 0; 451 raidPtr->waitShutdown = 0; 452 453 DO_RAID_MUTEX(&raidPtr->access_suspend_mutex); 454 DO_RAID_COND(&raidPtr->quiescent_cond); 455 456 DO_RAID_COND(&raidPtr->waitForReconCond); 457 458 DO_RAID_MUTEX(&raidPtr->recon_done_proc_mutex); 459 460 if (ac!=NULL) { 461 /* We have an AutoConfig structure.. Don't do the 462 normal disk configuration... call the auto config 463 stuff */ 464 rf_AutoConfigureDisks(raidPtr, cfgPtr, ac); 465 } else { 466 DO_RAID_INIT_CONFIGURE(rf_ConfigureDisks); 467 DO_RAID_INIT_CONFIGURE(rf_ConfigureSpareDisks); 468 } 469 /* do this after ConfigureDisks & ConfigureSpareDisks to be sure dev 470 * no. is set */ 471 DO_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueues); 472 473 DO_RAID_INIT_CONFIGURE(rf_ConfigureLayout); 474 475 DO_RAID_INIT_CONFIGURE(rf_ConfigurePSStatus); 476 477 for (row = 0; row < raidPtr->numRow; row++) { 478 for (col = 0; col < raidPtr->numCol; col++) { 479 /* 480 * XXX better distribution 481 */ 482 raidPtr->hist_diskreq[row][col] = 0; 483 } 484 } 485 486 raidPtr->numNewFailures = 0; 487 raidPtr->copyback_in_progress = 0; 488 raidPtr->parity_rewrite_in_progress = 0; 489 raidPtr->recon_in_progress = 0; 490 raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs; 491 492 /* autoconfigure and root_partition will actually get filled in 493 after the config is done */ 494 raidPtr->autoconfigure = 0; 495 raidPtr->root_partition = 0; 496 raidPtr->last_unit = raidPtr->raidid; 497 raidPtr->config_order = 0; 498 499 if (rf_keepAccTotals) { 500 raidPtr->keep_acc_totals = 1; 501 } 502 rf_StartUserStats(raidPtr); 503 504 raidPtr->valid = 1; 505 return (0); 506 } 507 508 static int 509 init_rad(desc) 510 RF_RaidAccessDesc_t *desc; 511 { 512 int rc; 513 514 rc = rf_mutex_init(&desc->mutex); 515 if (rc) { 516 RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__, 517 __LINE__, rc); 518 return (rc); 519 } 520 rc = rf_cond_init(&desc->cond); 521 if (rc) { 522 RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", __FILE__, 523 __LINE__, rc); 524 rf_mutex_destroy(&desc->mutex); 525 return (rc); 526 } 527 return (0); 528 } 529 530 static void 531 clean_rad(desc) 532 RF_RaidAccessDesc_t *desc; 533 { 534 rf_mutex_destroy(&desc->mutex); 535 rf_cond_destroy(&desc->cond); 536 } 537 538 static void 539 rf_ShutdownRDFreeList(ignored) 540 void *ignored; 541 { 542 RF_FREELIST_DESTROY_CLEAN(rf_rad_freelist, next, (RF_RaidAccessDesc_t *), clean_rad); 543 } 544 545 static int 546 rf_ConfigureRDFreeList(listp) 547 RF_ShutdownList_t **listp; 548 { 549 int rc; 550 551 RF_FREELIST_CREATE(rf_rad_freelist, RF_MAX_FREE_RAD, 552 RF_RAD_INC, sizeof(RF_RaidAccessDesc_t)); 553 if (rf_rad_freelist == NULL) { 554 return (ENOMEM); 555 } 556 rc = rf_ShutdownCreate(listp, rf_ShutdownRDFreeList, NULL); 557 if (rc) { 558 RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__, 559 __LINE__, rc); 560 rf_ShutdownRDFreeList(NULL); 561 return (rc); 562 } 563 RF_FREELIST_PRIME_INIT(rf_rad_freelist, RF_RAD_INITIAL, next, 564 (RF_RaidAccessDesc_t *), init_rad); 565 return (0); 566 } 567 568 RF_RaidAccessDesc_t * 569 rf_AllocRaidAccDesc( 570 RF_Raid_t * raidPtr, 571 RF_IoType_t type, 572 RF_RaidAddr_t raidAddress, 573 RF_SectorCount_t numBlocks, 574 caddr_t bufPtr, 575 void *bp, 576 RF_RaidAccessFlags_t flags, 577 RF_AccessState_t * states) 578 { 579 RF_RaidAccessDesc_t *desc; 580 581 RF_FREELIST_GET_INIT_NOUNLOCK(rf_rad_freelist, desc, next, (RF_RaidAccessDesc_t *), init_rad); 582 if (raidPtr->waitShutdown) { 583 /* 584 * Actually, we're shutting the array down. Free the desc 585 * and return NULL. 586 */ 587 RF_FREELIST_DO_UNLOCK(rf_rad_freelist); 588 RF_FREELIST_FREE_CLEAN(rf_rad_freelist, desc, next, clean_rad); 589 return (NULL); 590 } 591 raidPtr->nAccOutstanding++; 592 RF_FREELIST_DO_UNLOCK(rf_rad_freelist); 593 594 desc->raidPtr = (void *) raidPtr; 595 desc->type = type; 596 desc->raidAddress = raidAddress; 597 desc->numBlocks = numBlocks; 598 desc->bufPtr = bufPtr; 599 desc->bp = bp; 600 desc->paramDAG = NULL; 601 desc->paramASM = NULL; 602 desc->flags = flags; 603 desc->states = states; 604 desc->state = 0; 605 606 desc->status = 0; 607 memset((char *) &desc->tracerec, 0, sizeof(RF_AccTraceEntry_t)); 608 desc->callbackFunc = NULL; 609 desc->callbackArg = NULL; 610 desc->next = NULL; 611 desc->head = desc; 612 desc->numPending = 0; 613 desc->cleanupList = NULL; 614 rf_MakeAllocList(desc->cleanupList); 615 return (desc); 616 } 617 618 void 619 rf_FreeRaidAccDesc(RF_RaidAccessDesc_t * desc) 620 { 621 RF_Raid_t *raidPtr = desc->raidPtr; 622 623 RF_ASSERT(desc); 624 625 rf_FreeAllocList(desc->cleanupList); 626 RF_FREELIST_FREE_CLEAN_NOUNLOCK(rf_rad_freelist, desc, next, clean_rad); 627 raidPtr->nAccOutstanding--; 628 if (raidPtr->waitShutdown) { 629 RF_SIGNAL_COND(raidPtr->outstandingCond); 630 } 631 RF_FREELIST_DO_UNLOCK(rf_rad_freelist); 632 } 633 /********************************************************************* 634 * Main routine for performing an access. 635 * Accesses are retried until a DAG can not be selected. This occurs 636 * when either the DAG library is incomplete or there are too many 637 * failures in a parity group. 638 ********************************************************************/ 639 int 640 rf_DoAccess( 641 RF_Raid_t * raidPtr, 642 RF_IoType_t type, 643 int async_flag, 644 RF_RaidAddr_t raidAddress, 645 RF_SectorCount_t numBlocks, 646 caddr_t bufPtr, 647 void *bp_in, 648 RF_RaidAccessFlags_t flags) 649 /* 650 type should be read or write 651 async_flag should be RF_TRUE or RF_FALSE 652 bp_in is a buf pointer. void * to facilitate ignoring it outside the kernel 653 */ 654 { 655 RF_RaidAccessDesc_t *desc; 656 caddr_t lbufPtr = bufPtr; 657 struct buf *bp = (struct buf *) bp_in; 658 659 raidAddress += rf_raidSectorOffset; 660 661 if (!raidPtr->valid) { 662 RF_ERRORMSG("RAIDframe driver not successfully configured. Rejecting access.\n"); 663 IO_BUF_ERR(bp, EINVAL); 664 return (EINVAL); 665 } 666 667 if (rf_accessDebug) { 668 669 printf("logBytes is: %d %d %d\n", raidPtr->raidid, 670 raidPtr->logBytesPerSector, 671 (int) rf_RaidAddressToByte(raidPtr, numBlocks)); 672 printf("raid%d: %s raidAddr %d (stripeid %d-%d) numBlocks %d (%d bytes) buf 0x%lx\n", raidPtr->raidid, 673 (type == RF_IO_TYPE_READ) ? "READ" : "WRITE", (int) raidAddress, 674 (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress), 675 (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress + numBlocks - 1), 676 (int) numBlocks, 677 (int) rf_RaidAddressToByte(raidPtr, numBlocks), 678 (long) bufPtr); 679 } 680 if (raidAddress + numBlocks > raidPtr->totalSectors) { 681 682 printf("DoAccess: raid addr %lu too large to access %lu sectors. Max legal addr is %lu\n", 683 (u_long) raidAddress, (u_long) numBlocks, (u_long) raidPtr->totalSectors); 684 685 IO_BUF_ERR(bp, ENOSPC); 686 return (ENOSPC); 687 } 688 desc = rf_AllocRaidAccDesc(raidPtr, type, raidAddress, 689 numBlocks, lbufPtr, bp, flags, raidPtr->Layout.map->states); 690 691 if (desc == NULL) { 692 return (ENOMEM); 693 } 694 RF_ETIMER_START(desc->tracerec.tot_timer); 695 696 desc->async_flag = async_flag; 697 698 rf_ContinueRaidAccess(desc); 699 700 return (0); 701 } 702 #if 0 703 /* force the array into reconfigured mode without doing reconstruction */ 704 int 705 rf_SetReconfiguredMode(raidPtr, row, col) 706 RF_Raid_t *raidPtr; 707 int row; 708 int col; 709 { 710 if (!(raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) { 711 printf("Can't set reconfigured mode in dedicated-spare array\n"); 712 RF_PANIC(); 713 } 714 RF_LOCK_MUTEX(raidPtr->mutex); 715 raidPtr->numFailures++; 716 raidPtr->Disks[row][col].status = rf_ds_dist_spared; 717 raidPtr->status[row] = rf_rs_reconfigured; 718 rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); 719 /* install spare table only if declustering + distributed sparing 720 * architecture. */ 721 if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED) 722 rf_InstallSpareTable(raidPtr, row, col); 723 RF_UNLOCK_MUTEX(raidPtr->mutex); 724 return (0); 725 } 726 #endif 727 728 int 729 rf_FailDisk( 730 RF_Raid_t * raidPtr, 731 int frow, 732 int fcol, 733 int initRecon) 734 { 735 printf("raid%d: Failing disk r%d c%d\n", raidPtr->raidid, frow, fcol); 736 RF_LOCK_MUTEX(raidPtr->mutex); 737 raidPtr->numFailures++; 738 raidPtr->Disks[frow][fcol].status = rf_ds_failed; 739 raidPtr->status[frow] = rf_rs_degraded; 740 rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); 741 RF_UNLOCK_MUTEX(raidPtr->mutex); 742 if (initRecon) 743 rf_ReconstructFailedDisk(raidPtr, frow, fcol); 744 return (0); 745 } 746 /* releases a thread that is waiting for the array to become quiesced. 747 * access_suspend_mutex should be locked upon calling this 748 */ 749 void 750 rf_SignalQuiescenceLock(raidPtr, reconDesc) 751 RF_Raid_t *raidPtr; 752 RF_RaidReconDesc_t *reconDesc; 753 { 754 if (rf_quiesceDebug) { 755 printf("raid%d: Signalling quiescence lock\n", 756 raidPtr->raidid); 757 } 758 raidPtr->access_suspend_release = 1; 759 760 if (raidPtr->waiting_for_quiescence) { 761 SIGNAL_QUIESCENT_COND(raidPtr); 762 } 763 } 764 /* suspends all new requests to the array. No effect on accesses that are in flight. */ 765 int 766 rf_SuspendNewRequestsAndWait(raidPtr) 767 RF_Raid_t *raidPtr; 768 { 769 if (rf_quiesceDebug) 770 printf("Suspending new reqs\n"); 771 772 RF_LOCK_MUTEX(raidPtr->access_suspend_mutex); 773 raidPtr->accesses_suspended++; 774 raidPtr->waiting_for_quiescence = (raidPtr->accs_in_flight == 0) ? 0 : 1; 775 776 if (raidPtr->waiting_for_quiescence) { 777 raidPtr->access_suspend_release = 0; 778 while (!raidPtr->access_suspend_release) { 779 printf("Suspending: Waiting for Quiescence\n"); 780 WAIT_FOR_QUIESCENCE(raidPtr); 781 raidPtr->waiting_for_quiescence = 0; 782 } 783 } 784 printf("Quiescence reached..\n"); 785 786 RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex); 787 return (raidPtr->waiting_for_quiescence); 788 } 789 /* wake up everyone waiting for quiescence to be released */ 790 void 791 rf_ResumeNewRequests(raidPtr) 792 RF_Raid_t *raidPtr; 793 { 794 RF_CallbackDesc_t *t, *cb; 795 796 if (rf_quiesceDebug) 797 printf("Resuming new reqs\n"); 798 799 RF_LOCK_MUTEX(raidPtr->access_suspend_mutex); 800 raidPtr->accesses_suspended--; 801 if (raidPtr->accesses_suspended == 0) 802 cb = raidPtr->quiesce_wait_list; 803 else 804 cb = NULL; 805 raidPtr->quiesce_wait_list = NULL; 806 RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex); 807 808 while (cb) { 809 t = cb; 810 cb = cb->next; 811 (t->callbackFunc) (t->callbackArg); 812 rf_FreeCallbackDesc(t); 813 } 814 } 815 /***************************************************************************************** 816 * 817 * debug routines 818 * 819 ****************************************************************************************/ 820 821 static void 822 set_debug_option(name, val) 823 char *name; 824 long val; 825 { 826 RF_DebugName_t *p; 827 828 for (p = rf_debugNames; p->name; p++) { 829 if (!strcmp(p->name, name)) { 830 *(p->ptr) = val; 831 printf("[Set debug variable %s to %ld]\n", name, val); 832 return; 833 } 834 } 835 RF_ERRORMSG1("Unknown debug string \"%s\"\n", name); 836 } 837 838 839 /* would like to use sscanf here, but apparently not available in kernel */ 840 /*ARGSUSED*/ 841 static void 842 rf_ConfigureDebug(cfgPtr) 843 RF_Config_t *cfgPtr; 844 { 845 char *val_p, *name_p, *white_p; 846 long val; 847 int i; 848 849 rf_ResetDebugOptions(); 850 for (i = 0; cfgPtr->debugVars[i][0] && i < RF_MAXDBGV; i++) { 851 name_p = rf_find_non_white(&cfgPtr->debugVars[i][0]); 852 white_p = rf_find_white(name_p); /* skip to start of 2nd 853 * word */ 854 val_p = rf_find_non_white(white_p); 855 if (*val_p == '0' && *(val_p + 1) == 'x') 856 val = rf_htoi(val_p + 2); 857 else 858 val = rf_atoi(val_p); 859 *white_p = '\0'; 860 set_debug_option(name_p, val); 861 } 862 } 863 /* performance monitoring stuff */ 864 865 #define TIMEVAL_TO_US(t) (((long) t.tv_sec) * 1000000L + (long) t.tv_usec) 866 867 #if !defined(_KERNEL) && !defined(SIMULATE) 868 869 /* 870 * Throughput stats currently only used in user-level RAIDframe 871 */ 872 873 static int 874 rf_InitThroughputStats( 875 RF_ShutdownList_t ** listp, 876 RF_Raid_t * raidPtr, 877 RF_Config_t * cfgPtr) 878 { 879 int rc; 880 881 /* these used by user-level raidframe only */ 882 rc = rf_create_managed_mutex(listp, &raidPtr->throughputstats.mutex); 883 if (rc) { 884 RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__, 885 __LINE__, rc); 886 return (rc); 887 } 888 raidPtr->throughputstats.sum_io_us = 0; 889 raidPtr->throughputstats.num_ios = 0; 890 raidPtr->throughputstats.num_out_ios = 0; 891 return (0); 892 } 893 894 void 895 rf_StartThroughputStats(RF_Raid_t * raidPtr) 896 { 897 RF_LOCK_MUTEX(raidPtr->throughputstats.mutex); 898 raidPtr->throughputstats.num_ios++; 899 raidPtr->throughputstats.num_out_ios++; 900 if (raidPtr->throughputstats.num_out_ios == 1) 901 RF_GETTIME(raidPtr->throughputstats.start); 902 RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex); 903 } 904 905 static void 906 rf_StopThroughputStats(RF_Raid_t * raidPtr) 907 { 908 struct timeval diff; 909 910 RF_LOCK_MUTEX(raidPtr->throughputstats.mutex); 911 raidPtr->throughputstats.num_out_ios--; 912 if (raidPtr->throughputstats.num_out_ios == 0) { 913 RF_GETTIME(raidPtr->throughputstats.stop); 914 RF_TIMEVAL_DIFF(&raidPtr->throughputstats.start, &raidPtr->throughputstats.stop, &diff); 915 raidPtr->throughputstats.sum_io_us += TIMEVAL_TO_US(diff); 916 } 917 RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex); 918 } 919 920 static void 921 rf_PrintThroughputStats(RF_Raid_t * raidPtr) 922 { 923 RF_ASSERT(raidPtr->throughputstats.num_out_ios == 0); 924 if (raidPtr->throughputstats.sum_io_us != 0) { 925 printf("[Througphut: %8.2f IOs/second]\n", raidPtr->throughputstats.num_ios 926 / (raidPtr->throughputstats.sum_io_us / 1000000.0)); 927 } 928 } 929 #endif /* !KERNEL && !SIMULATE */ 930 931 void 932 rf_StartUserStats(RF_Raid_t * raidPtr) 933 { 934 RF_GETTIME(raidPtr->userstats.start); 935 raidPtr->userstats.sum_io_us = 0; 936 raidPtr->userstats.num_ios = 0; 937 raidPtr->userstats.num_sect_moved = 0; 938 } 939 940 void 941 rf_StopUserStats(RF_Raid_t * raidPtr) 942 { 943 RF_GETTIME(raidPtr->userstats.stop); 944 } 945 946 void 947 rf_UpdateUserStats(raidPtr, rt, numsect) 948 RF_Raid_t *raidPtr; 949 int rt; /* resp time in us */ 950 int numsect; /* number of sectors for this access */ 951 { 952 raidPtr->userstats.sum_io_us += rt; 953 raidPtr->userstats.num_ios++; 954 raidPtr->userstats.num_sect_moved += numsect; 955 } 956 957 void 958 rf_PrintUserStats(RF_Raid_t * raidPtr) 959 { 960 long elapsed_us, mbs, mbs_frac; 961 struct timeval diff; 962 963 RF_TIMEVAL_DIFF(&raidPtr->userstats.start, &raidPtr->userstats.stop, &diff); 964 elapsed_us = TIMEVAL_TO_US(diff); 965 966 /* 2000 sectors per megabyte, 10000000 microseconds per second */ 967 if (elapsed_us) 968 mbs = (raidPtr->userstats.num_sect_moved / 2000) / (elapsed_us / 1000000); 969 else 970 mbs = 0; 971 972 /* this computes only the first digit of the fractional mb/s moved */ 973 if (elapsed_us) { 974 mbs_frac = ((raidPtr->userstats.num_sect_moved / 200) / (elapsed_us / 1000000)) 975 - (mbs * 10); 976 } else { 977 mbs_frac = 0; 978 } 979 980 printf("Number of I/Os: %ld\n", raidPtr->userstats.num_ios); 981 printf("Elapsed time (us): %ld\n", elapsed_us); 982 printf("User I/Os per second: %ld\n", RF_DB0_CHECK(raidPtr->userstats.num_ios, (elapsed_us / 1000000))); 983 printf("Average user response time: %ld us\n", RF_DB0_CHECK(raidPtr->userstats.sum_io_us, raidPtr->userstats.num_ios)); 984 printf("Total sectors moved: %ld\n", raidPtr->userstats.num_sect_moved); 985 printf("Average access size (sect): %ld\n", RF_DB0_CHECK(raidPtr->userstats.num_sect_moved, raidPtr->userstats.num_ios)); 986 printf("Achieved data rate: %ld.%ld MB/sec\n", mbs, mbs_frac); 987 } 988 989 990 void 991 rf_print_panic_message(line,file) 992 int line; 993 char *file; 994 { 995 sprintf(rf_panicbuf,"raidframe error at line %d file %s", 996 line, file); 997 } 998 999 void 1000 rf_print_assert_panic_message(line,file,condition) 1001 int line; 1002 char *file; 1003 char *condition; 1004 { 1005 sprintf(rf_panicbuf, 1006 "raidframe error at line %d file %s (failed asserting %s)\n", 1007 line, file, condition); 1008 } 1009