1 /*- 2 * Routines for handling the integrated RAID features LSI MPT Fusion adapters. 3 * 4 * Copyright (c) 2005, WHEEL Sp. z o.o. 5 * Copyright (c) 2005 Justin T. Gibbs. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are 10 * met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 14 * substantially similar to the "NO WARRANTY" disclaimer below 15 * ("Disclaimer") and any redistribution must be conditioned upon including 16 * a substantially similar Disclaimer requirement for further binary 17 * redistribution. 18 * 3. Neither the names of the above listed copyright holders nor the names 19 * of any contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT 32 * OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 /*- 35 * Some Breakage and Bug Fixing added later. 36 * Copyright (c) 2006, by Matthew Jacob 37 * All Rights Reserved 38 * 39 * Support from LSI-Logic has also gone a great deal toward making this a 40 * workable subsystem and is gratefully acknowledged. 41 * $FreeBSD: src/sys/dev/mpt/mpt_raid.c,v 1.20 2009/05/21 12:36:40 jhb Exp $ 42 */ 43 44 #include <sys/cdefs.h> 45 46 #include <dev/disk/mpt/mpt.h> 47 #include <dev/disk/mpt/mpt_raid.h> 48 49 #include "dev/disk/mpt/mpilib/mpi_ioc.h" /* XXX Fix Event Handling!!! */ 50 #include "dev/disk/mpt/mpilib/mpi_raid.h" 51 52 #include <bus/cam/cam.h> 53 #include <bus/cam/cam_ccb.h> 54 #include <bus/cam/cam_sim.h> 55 #include <bus/cam/cam_xpt_periph.h> 56 #include <bus/cam/cam_xpt_sim.h> 57 58 #if __FreeBSD_version < 500000 59 #include <sys/devicestat.h> 60 #define GIANT_REQUIRED 61 #endif 62 #include <bus/cam/cam_periph.h> 63 64 #include <sys/callout.h> 65 #include <sys/kthread.h> 66 #include <sys/sysctl.h> 67 68 #include <machine/stdarg.h> 69 70 struct mpt_raid_action_result 71 { 72 union { 73 MPI_RAID_VOL_INDICATOR indicator_struct; 74 uint32_t new_settings; 75 uint8_t phys_disk_num; 76 } action_data; 77 uint16_t action_status; 78 }; 79 80 #define REQ_TO_RAID_ACTION_RESULT(req) ((struct mpt_raid_action_result *) \ 81 (((MSG_RAID_ACTION_REQUEST *)(req->req_vbuf)) + 1)) 82 83 #define REQ_IOCSTATUS(req) ((req)->IOCStatus & MPI_IOCSTATUS_MASK) 84 85 86 static mpt_probe_handler_t mpt_raid_probe; 87 static mpt_attach_handler_t mpt_raid_attach; 88 static mpt_enable_handler_t mpt_raid_enable; 89 static mpt_event_handler_t mpt_raid_event; 90 static mpt_shutdown_handler_t mpt_raid_shutdown; 91 static mpt_reset_handler_t mpt_raid_ioc_reset; 92 static mpt_detach_handler_t mpt_raid_detach; 93 94 static struct mpt_personality mpt_raid_personality = 95 { 96 .name = "mpt_raid", 97 .probe = mpt_raid_probe, 98 .attach = mpt_raid_attach, 99 .enable = mpt_raid_enable, 100 .event = mpt_raid_event, 101 .reset = mpt_raid_ioc_reset, 102 .shutdown = mpt_raid_shutdown, 103 .detach = mpt_raid_detach, 104 }; 105 106 DECLARE_MPT_PERSONALITY(mpt_raid, SI_ORDER_THIRD); 107 MPT_PERSONALITY_DEPEND(mpt_raid, mpt_cam, 1, 1, 1); 108 109 static mpt_reply_handler_t mpt_raid_reply_handler; 110 static int mpt_raid_reply_frame_handler(struct mpt_softc *mpt, request_t *req, 111 MSG_DEFAULT_REPLY *reply_frame); 112 static int mpt_spawn_raid_thread(struct mpt_softc *mpt); 113 static void mpt_terminate_raid_thread(struct mpt_softc *mpt); 114 static void mpt_raid_thread(void *arg); 115 static timeout_t mpt_raid_timer; 116 #if 0 117 static void mpt_enable_vol(struct mpt_softc *mpt, 118 struct mpt_raid_volume *mpt_vol, int enable); 119 #endif 120 static void mpt_verify_mwce(struct mpt_softc *, struct mpt_raid_volume *); 121 static void mpt_adjust_queue_depth(struct mpt_softc *, struct mpt_raid_volume *, 122 struct cam_path *); 123 #if __FreeBSD_version < 500000 124 #define mpt_raid_sysctl_attach(x) do { } while (0) 125 #else 126 static void mpt_raid_sysctl_attach(struct mpt_softc *); 127 #endif 128 129 static uint32_t raid_handler_id = MPT_HANDLER_ID_NONE; 130 131 const char * 132 mpt_vol_type(struct mpt_raid_volume *vol) 133 { 134 switch (vol->config_page->VolumeType) { 135 case MPI_RAID_VOL_TYPE_IS: 136 return ("RAID-0"); 137 case MPI_RAID_VOL_TYPE_IME: 138 return ("RAID-1E"); 139 case MPI_RAID_VOL_TYPE_IM: 140 return ("RAID-1"); 141 default: 142 return ("Unknown"); 143 } 144 } 145 146 const char * 147 mpt_vol_state(struct mpt_raid_volume *vol) 148 { 149 switch (vol->config_page->VolumeStatus.State) { 150 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL: 151 return ("Optimal"); 152 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED: 153 return ("Degraded"); 154 case MPI_RAIDVOL0_STATUS_STATE_FAILED: 155 return ("Failed"); 156 default: 157 return ("Unknown"); 158 } 159 } 160 161 const char * 162 mpt_disk_state(struct mpt_raid_disk *disk) 163 { 164 switch (disk->config_page.PhysDiskStatus.State) { 165 case MPI_PHYSDISK0_STATUS_ONLINE: 166 return ("Online"); 167 case MPI_PHYSDISK0_STATUS_MISSING: 168 return ("Missing"); 169 case MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE: 170 return ("Incompatible"); 171 case MPI_PHYSDISK0_STATUS_FAILED: 172 return ("Failed"); 173 case MPI_PHYSDISK0_STATUS_INITIALIZING: 174 return ("Initializing"); 175 case MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED: 176 return ("Offline Requested"); 177 case MPI_PHYSDISK0_STATUS_FAILED_REQUESTED: 178 return ("Failed per Host Request"); 179 case MPI_PHYSDISK0_STATUS_OTHER_OFFLINE: 180 return ("Offline"); 181 default: 182 return ("Unknown"); 183 } 184 } 185 186 void 187 mpt_vol_prt(struct mpt_softc *mpt, struct mpt_raid_volume *vol, 188 const char *fmt, ...) 189 { 190 __va_list ap; 191 192 kprintf("%s:vol%d(%s:%d:%d): ", device_get_nameunit(mpt->dev), 193 (u_int)(vol - mpt->raid_volumes), device_get_nameunit(mpt->dev), 194 vol->config_page->VolumeBus, vol->config_page->VolumeID); 195 __va_start(ap, fmt); 196 kvprintf(fmt, ap); 197 __va_end(ap); 198 } 199 200 void 201 mpt_disk_prt(struct mpt_softc *mpt, struct mpt_raid_disk *disk, 202 const char *fmt, ...) 203 { 204 __va_list ap; 205 206 if (disk->volume != NULL) { 207 kprintf("(%s:vol%d:%d): ", 208 device_get_nameunit(mpt->dev), 209 disk->volume->config_page->VolumeID, 210 disk->member_number); 211 } else { 212 kprintf("(%s:%d:%d): ", device_get_nameunit(mpt->dev), 213 disk->config_page.PhysDiskBus, 214 disk->config_page.PhysDiskID); 215 } 216 __va_start(ap, fmt); 217 kvprintf(fmt, ap); 218 __va_end(ap); 219 } 220 221 static void 222 mpt_raid_async(void *callback_arg, u_int32_t code, 223 struct cam_path *path, void *arg) 224 { 225 struct mpt_softc *mpt; 226 227 mpt = (struct mpt_softc*)callback_arg; 228 switch (code) { 229 case AC_FOUND_DEVICE: 230 { 231 struct ccb_getdev *cgd; 232 struct mpt_raid_volume *mpt_vol; 233 234 cgd = (struct ccb_getdev *)arg; 235 if (cgd == NULL) { 236 break; 237 } 238 239 mpt_lprt(mpt, MPT_PRT_DEBUG, "Callback for %d\n", 240 cgd->ccb_h.target_id); 241 242 RAID_VOL_FOREACH(mpt, mpt_vol) { 243 if ((mpt_vol->flags & MPT_RVF_ACTIVE) == 0) 244 continue; 245 246 if (mpt_vol->config_page->VolumeID 247 == cgd->ccb_h.target_id) { 248 mpt_adjust_queue_depth(mpt, mpt_vol, path); 249 break; 250 } 251 } 252 } 253 default: 254 break; 255 } 256 } 257 258 int 259 mpt_raid_probe(struct mpt_softc *mpt) 260 { 261 if (mpt->ioc_page2 == NULL || mpt->ioc_page2->MaxPhysDisks == 0) { 262 return (ENODEV); 263 } 264 return (0); 265 } 266 267 int 268 mpt_raid_attach(struct mpt_softc *mpt) 269 { 270 struct ccb_setasync csa; 271 mpt_handler_t handler; 272 int error; 273 274 mpt_callout_init(&mpt->raid_timer); 275 276 error = mpt_spawn_raid_thread(mpt); 277 if (error != 0) { 278 mpt_prt(mpt, "Unable to spawn RAID thread!\n"); 279 goto cleanup; 280 } 281 282 MPT_LOCK(mpt); 283 handler.reply_handler = mpt_raid_reply_handler; 284 error = mpt_register_handler(mpt, MPT_HANDLER_REPLY, handler, 285 &raid_handler_id); 286 if (error != 0) { 287 mpt_prt(mpt, "Unable to register RAID haandler!\n"); 288 goto cleanup; 289 } 290 291 xpt_setup_ccb(&csa.ccb_h, mpt->path, 5); 292 csa.ccb_h.func_code = XPT_SASYNC_CB; 293 csa.event_enable = AC_FOUND_DEVICE; 294 csa.callback = mpt_raid_async; 295 csa.callback_arg = mpt; 296 xpt_action((union ccb *)&csa); 297 if (csa.ccb_h.status != CAM_REQ_CMP) { 298 mpt_prt(mpt, "mpt_raid_attach: Unable to register " 299 "CAM async handler.\n"); 300 } 301 MPT_UNLOCK(mpt); 302 303 mpt_raid_sysctl_attach(mpt); 304 return (0); 305 cleanup: 306 MPT_UNLOCK(mpt); 307 mpt_raid_detach(mpt); 308 return (error); 309 } 310 311 int 312 mpt_raid_enable(struct mpt_softc *mpt) 313 { 314 return (0); 315 } 316 317 void 318 mpt_raid_detach(struct mpt_softc *mpt) 319 { 320 struct ccb_setasync csa; 321 mpt_handler_t handler; 322 323 callout_stop(&mpt->raid_timer); 324 MPT_LOCK(mpt); 325 mpt_terminate_raid_thread(mpt); 326 327 handler.reply_handler = mpt_raid_reply_handler; 328 mpt_deregister_handler(mpt, MPT_HANDLER_REPLY, handler, 329 raid_handler_id); 330 xpt_setup_ccb(&csa.ccb_h, mpt->path, /*priority*/5); 331 csa.ccb_h.func_code = XPT_SASYNC_CB; 332 csa.event_enable = 0; 333 csa.callback = mpt_raid_async; 334 csa.callback_arg = mpt; 335 xpt_action((union ccb *)&csa); 336 MPT_UNLOCK(mpt); 337 } 338 339 static void 340 mpt_raid_ioc_reset(struct mpt_softc *mpt, int type) 341 { 342 /* Nothing to do yet. */ 343 } 344 345 static const char *raid_event_txt[] = 346 { 347 "Volume Created", 348 "Volume Deleted", 349 "Volume Settings Changed", 350 "Volume Status Changed", 351 "Volume Physical Disk Membership Changed", 352 "Physical Disk Created", 353 "Physical Disk Deleted", 354 "Physical Disk Settings Changed", 355 "Physical Disk Status Changed", 356 "Domain Validation Required", 357 "SMART Data Received", 358 "Replace Action Started", 359 }; 360 361 static int 362 mpt_raid_event(struct mpt_softc *mpt, request_t *req, 363 MSG_EVENT_NOTIFY_REPLY *msg) 364 { 365 EVENT_DATA_RAID *raid_event; 366 struct mpt_raid_volume *mpt_vol; 367 struct mpt_raid_disk *mpt_disk; 368 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 369 int i; 370 int print_event; 371 372 if (msg->Event != MPI_EVENT_INTEGRATED_RAID) { 373 return (0); 374 } 375 376 raid_event = (EVENT_DATA_RAID *)&msg->Data; 377 378 mpt_vol = NULL; 379 vol_pg = NULL; 380 if (mpt->raid_volumes != NULL && mpt->ioc_page2 != NULL) { 381 for (i = 0; i < mpt->ioc_page2->MaxVolumes; i++) { 382 mpt_vol = &mpt->raid_volumes[i]; 383 vol_pg = mpt_vol->config_page; 384 385 if ((mpt_vol->flags & MPT_RVF_ACTIVE) == 0) 386 continue; 387 388 if (vol_pg->VolumeID == raid_event->VolumeID 389 && vol_pg->VolumeBus == raid_event->VolumeBus) 390 break; 391 } 392 if (i >= mpt->ioc_page2->MaxVolumes) { 393 mpt_vol = NULL; 394 vol_pg = NULL; 395 } 396 } 397 398 mpt_disk = NULL; 399 if (raid_event->PhysDiskNum != 0xFF && mpt->raid_disks != NULL) { 400 mpt_disk = mpt->raid_disks + raid_event->PhysDiskNum; 401 if ((mpt_disk->flags & MPT_RDF_ACTIVE) == 0) { 402 mpt_disk = NULL; 403 } 404 } 405 406 print_event = 1; 407 switch(raid_event->ReasonCode) { 408 case MPI_EVENT_RAID_RC_VOLUME_CREATED: 409 case MPI_EVENT_RAID_RC_VOLUME_DELETED: 410 break; 411 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED: 412 if (mpt_vol != NULL) { 413 if ((mpt_vol->flags & MPT_RVF_UP2DATE) != 0) { 414 mpt_vol->flags &= ~MPT_RVF_UP2DATE; 415 } else { 416 /* 417 * Coalesce status messages into one 418 * per background run of our RAID thread. 419 * This removes "spurious" status messages 420 * from our output. 421 */ 422 print_event = 0; 423 } 424 } 425 break; 426 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED: 427 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED: 428 mpt->raid_rescan++; 429 if (mpt_vol != NULL) { 430 mpt_vol->flags &= ~(MPT_RVF_UP2DATE|MPT_RVF_ANNOUNCED); 431 } 432 break; 433 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED: 434 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED: 435 mpt->raid_rescan++; 436 break; 437 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED: 438 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED: 439 mpt->raid_rescan++; 440 if (mpt_disk != NULL) { 441 mpt_disk->flags &= ~MPT_RDF_UP2DATE; 442 } 443 break; 444 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED: 445 mpt->raid_rescan++; 446 break; 447 case MPI_EVENT_RAID_RC_SMART_DATA: 448 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED: 449 break; 450 } 451 452 if (print_event) { 453 if (mpt_disk != NULL) { 454 mpt_disk_prt(mpt, mpt_disk, ""); 455 } else if (mpt_vol != NULL) { 456 mpt_vol_prt(mpt, mpt_vol, ""); 457 } else { 458 mpt_prt(mpt, "Volume(%d:%d", raid_event->VolumeBus, 459 raid_event->VolumeID); 460 461 if (raid_event->PhysDiskNum != 0xFF) 462 mpt_prtc(mpt, ":%d): ", 463 raid_event->PhysDiskNum); 464 else 465 mpt_prtc(mpt, "): "); 466 } 467 468 if (raid_event->ReasonCode >= NUM_ELEMENTS(raid_event_txt)) 469 mpt_prtc(mpt, "Unhandled RaidEvent %#x\n", 470 raid_event->ReasonCode); 471 else 472 mpt_prtc(mpt, "%s\n", 473 raid_event_txt[raid_event->ReasonCode]); 474 } 475 476 if (raid_event->ReasonCode == MPI_EVENT_RAID_RC_SMART_DATA) { 477 /* XXX Use CAM's print sense for this... */ 478 if (mpt_disk != NULL) 479 mpt_disk_prt(mpt, mpt_disk, ""); 480 else 481 mpt_prt(mpt, "Volume(%d:%d:%d: ", 482 raid_event->VolumeBus, raid_event->VolumeID, 483 raid_event->PhysDiskNum); 484 mpt_prtc(mpt, "ASC 0x%x, ASCQ 0x%x)\n", 485 raid_event->ASC, raid_event->ASCQ); 486 } 487 488 mpt_raid_wakeup(mpt); 489 return (1); 490 } 491 492 static void 493 mpt_raid_shutdown(struct mpt_softc *mpt) 494 { 495 struct mpt_raid_volume *mpt_vol; 496 497 if (mpt->raid_mwce_setting != MPT_RAID_MWCE_REBUILD_ONLY) { 498 return; 499 } 500 501 mpt->raid_mwce_setting = MPT_RAID_MWCE_OFF; 502 RAID_VOL_FOREACH(mpt, mpt_vol) { 503 mpt_verify_mwce(mpt, mpt_vol); 504 } 505 } 506 507 static int 508 mpt_raid_reply_handler(struct mpt_softc *mpt, request_t *req, 509 uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 510 { 511 int free_req; 512 513 if (req == NULL) 514 return (TRUE); 515 516 free_req = TRUE; 517 if (reply_frame != NULL) 518 free_req = mpt_raid_reply_frame_handler(mpt, req, reply_frame); 519 #ifdef NOTYET 520 else if (req->ccb != NULL) { 521 /* Complete Quiesce CCB with error... */ 522 } 523 #endif 524 525 req->state &= ~REQ_STATE_QUEUED; 526 req->state |= REQ_STATE_DONE; 527 TAILQ_REMOVE(&mpt->request_pending_list, req, links); 528 529 if ((req->state & REQ_STATE_NEED_WAKEUP) != 0) { 530 wakeup(req); 531 } else if (free_req) { 532 mpt_free_request(mpt, req); 533 } 534 535 return (TRUE); 536 } 537 538 /* 539 * Parse additional completion information in the reply 540 * frame for RAID I/O requests. 541 */ 542 static int 543 mpt_raid_reply_frame_handler(struct mpt_softc *mpt, request_t *req, 544 MSG_DEFAULT_REPLY *reply_frame) 545 { 546 MSG_RAID_ACTION_REPLY *reply; 547 struct mpt_raid_action_result *action_result; 548 MSG_RAID_ACTION_REQUEST *rap; 549 550 reply = (MSG_RAID_ACTION_REPLY *)reply_frame; 551 req->IOCStatus = le16toh(reply->IOCStatus); 552 rap = (MSG_RAID_ACTION_REQUEST *)req->req_vbuf; 553 554 switch (rap->Action) { 555 case MPI_RAID_ACTION_QUIESCE_PHYS_IO: 556 mpt_prt(mpt, "QUIESCE PHYSIO DONE\n"); 557 break; 558 case MPI_RAID_ACTION_ENABLE_PHYS_IO: 559 mpt_prt(mpt, "ENABLY PHYSIO DONE\n"); 560 break; 561 default: 562 break; 563 } 564 action_result = REQ_TO_RAID_ACTION_RESULT(req); 565 memcpy(&action_result->action_data, &reply->ActionData, 566 sizeof(action_result->action_data)); 567 action_result->action_status = le16toh(reply->ActionStatus); 568 return (TRUE); 569 } 570 571 /* 572 * Utiltity routine to perform a RAID action command; 573 */ 574 int 575 mpt_issue_raid_req(struct mpt_softc *mpt, struct mpt_raid_volume *vol, 576 struct mpt_raid_disk *disk, request_t *req, u_int Action, 577 uint32_t ActionDataWord, bus_addr_t addr, bus_size_t len, 578 int write, int wait) 579 { 580 MSG_RAID_ACTION_REQUEST *rap; 581 SGE_SIMPLE32 *se; 582 583 rap = req->req_vbuf; 584 memset(rap, 0, sizeof *rap); 585 rap->Action = Action; 586 rap->ActionDataWord = htole32(ActionDataWord); 587 rap->Function = MPI_FUNCTION_RAID_ACTION; 588 rap->VolumeID = vol->config_page->VolumeID; 589 rap->VolumeBus = vol->config_page->VolumeBus; 590 if (disk != 0) 591 rap->PhysDiskNum = disk->config_page.PhysDiskNum; 592 else 593 rap->PhysDiskNum = 0xFF; 594 se = (SGE_SIMPLE32 *)&rap->ActionDataSGE; 595 se->Address = htole32(addr); 596 MPI_pSGE_SET_LENGTH(se, len); 597 MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT | 598 MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER | 599 MPI_SGE_FLAGS_END_OF_LIST | 600 write ? MPI_SGE_FLAGS_HOST_TO_IOC : MPI_SGE_FLAGS_IOC_TO_HOST)); 601 se->FlagsLength = htole32(se->FlagsLength); 602 rap->MsgContext = htole32(req->index | raid_handler_id); 603 604 mpt_check_doorbell(mpt); 605 mpt_send_cmd(mpt, req); 606 607 if (wait) { 608 return (mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE, 609 /*sleep_ok*/FALSE, /*time_ms*/2000)); 610 } else { 611 return (0); 612 } 613 } 614 615 /*************************** RAID Status Monitoring ***************************/ 616 static int 617 mpt_spawn_raid_thread(struct mpt_softc *mpt) 618 { 619 int error; 620 621 /* 622 * Freeze out any CAM transactions until our thread 623 * is able to run at least once. We need to update 624 * our RAID pages before acception I/O or we may 625 * reject I/O to an ID we later determine is for a 626 * hidden physdisk. 627 */ 628 MPT_LOCK(mpt); 629 xpt_freeze_simq(mpt->phydisk_sim, 1); 630 MPT_UNLOCK(mpt); 631 error = mpt_kthread_create(mpt_raid_thread, mpt, 632 &mpt->raid_thread, /*flags*/0, /*altstack*/0, 633 "mpt_raid%d", mpt->unit); 634 if (error != 0) { 635 MPT_LOCK(mpt); 636 xpt_release_simq(mpt->phydisk_sim, /*run_queue*/FALSE); 637 MPT_UNLOCK(mpt); 638 } 639 return (error); 640 } 641 642 static void 643 mpt_terminate_raid_thread(struct mpt_softc *mpt) 644 { 645 646 if (mpt->raid_thread == NULL) { 647 return; 648 } 649 mpt->shutdwn_raid = 1; 650 wakeup(mpt->raid_volumes); 651 /* 652 * Sleep on a slightly different location 653 * for this interlock just for added safety. 654 */ 655 mpt_sleep(mpt, &mpt->raid_thread, PUSER, "thtrm", 0); 656 } 657 658 static void 659 mpt_cam_rescan_callback(struct cam_periph *periph, union ccb *ccb) 660 { 661 662 xpt_free_path(ccb->ccb_h.path); 663 xpt_free_ccb(ccb); 664 } 665 666 static void 667 mpt_raid_thread(void *arg) 668 { 669 struct mpt_softc *mpt; 670 int firstrun; 671 672 mpt = (struct mpt_softc *)arg; 673 firstrun = 1; 674 MPT_LOCK(mpt); 675 while (mpt->shutdwn_raid == 0) { 676 677 if (mpt->raid_wakeup == 0) { 678 mpt_sleep(mpt, &mpt->raid_volumes, PUSER, "idle", 0); 679 continue; 680 } 681 682 mpt->raid_wakeup = 0; 683 684 if (mpt_refresh_raid_data(mpt)) { 685 mpt_schedule_raid_refresh(mpt); /* XX NOT QUITE RIGHT */ 686 continue; 687 } 688 689 /* 690 * Now that we have our first snapshot of RAID data, 691 * allow CAM to access our physical disk bus. 692 */ 693 if (firstrun) { 694 firstrun = 0; 695 MPTLOCK_2_CAMLOCK(mpt); 696 xpt_release_simq(mpt->phydisk_sim, TRUE); 697 CAMLOCK_2_MPTLOCK(mpt); 698 } 699 700 if (mpt->raid_rescan != 0) { 701 union ccb *ccb; 702 struct cam_path *path; 703 int error; 704 705 mpt->raid_rescan = 0; 706 MPT_UNLOCK(mpt); 707 708 ccb = xpt_alloc_ccb(); 709 710 MPT_LOCK(mpt); 711 error = xpt_create_path(&path, xpt_periph, 712 cam_sim_path(mpt->phydisk_sim), 713 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 714 if (error != CAM_REQ_CMP) { 715 xpt_free_ccb(ccb); 716 mpt_prt(mpt, "Unable to rescan RAID Bus!\n"); 717 } else { 718 xpt_setup_ccb(&ccb->ccb_h, path, 5); 719 ccb->ccb_h.func_code = XPT_SCAN_BUS; 720 ccb->ccb_h.cbfcnp = mpt_cam_rescan_callback; 721 ccb->crcn.flags = CAM_FLAG_NONE; 722 MPTLOCK_2_CAMLOCK(mpt); 723 xpt_action(ccb); 724 CAMLOCK_2_MPTLOCK(mpt); 725 } 726 } 727 } 728 mpt->raid_thread = NULL; 729 wakeup(&mpt->raid_thread); 730 MPT_UNLOCK(mpt); 731 mpt_kthread_exit(0); 732 } 733 734 #if 0 735 static void 736 mpt_raid_quiesce_timeout(void *arg) 737 { 738 /* Complete the CCB with error */ 739 /* COWWWW */ 740 } 741 742 static timeout_t mpt_raid_quiesce_timeout; 743 cam_status 744 mpt_raid_quiesce_disk(struct mpt_softc *mpt, struct mpt_raid_disk *mpt_disk, 745 request_t *req) 746 { 747 union ccb *ccb; 748 749 ccb = req->ccb; 750 if ((mpt_disk->flags & MPT_RDF_QUIESCED) != 0) 751 return (CAM_REQ_CMP); 752 753 if ((mpt_disk->flags & MPT_RDF_QUIESCING) == 0) { 754 int rv; 755 756 mpt_disk->flags |= MPT_RDF_QUIESCING; 757 xpt_freeze_devq(ccb->ccb_h.path, 1); 758 759 rv = mpt_issue_raid_req(mpt, mpt_disk->volume, mpt_disk, req, 760 MPI_RAID_ACTION_QUIESCE_PHYS_IO, 761 /*ActionData*/0, /*addr*/0, 762 /*len*/0, /*write*/FALSE, 763 /*wait*/FALSE); 764 if (rv != 0) 765 return (CAM_REQ_CMP_ERR); 766 767 mpt_req_timeout(req, mpt_raid_quiesce_timeout, ccb, 5 * hz); 768 #if 0 769 if (rv == ETIMEDOUT) { 770 mpt_disk_prt(mpt, mpt_disk, "mpt_raid_quiesce_disk: " 771 "Quiece Timed-out\n"); 772 xpt_release_devq(ccb->ccb_h.path, 1, /*run*/0); 773 return (CAM_REQ_CMP_ERR); 774 } 775 776 ar = REQ_TO_RAID_ACTION_RESULT(req); 777 if (rv != 0 778 || REQ_IOCSTATUS(req) != MPI_IOCSTATUS_SUCCESS 779 || (ar->action_status != MPI_RAID_ACTION_ASTATUS_SUCCESS)) { 780 mpt_disk_prt(mpt, mpt_disk, "Quiece Failed" 781 "%d:%x:%x\n", rv, req->IOCStatus, 782 ar->action_status); 783 xpt_release_devq(ccb->ccb_h.path, 1, /*run*/0); 784 return (CAM_REQ_CMP_ERR); 785 } 786 #endif 787 return (CAM_REQ_INPROG); 788 } 789 return (CAM_REQUEUE_REQ); 790 } 791 #endif 792 793 /* XXX Ignores that there may be multiple busses/IOCs involved. */ 794 cam_status 795 mpt_map_physdisk(struct mpt_softc *mpt, union ccb *ccb, u_int *tgt) 796 { 797 struct mpt_raid_disk *mpt_disk; 798 799 mpt_disk = mpt->raid_disks + ccb->ccb_h.target_id; 800 if (ccb->ccb_h.target_id < mpt->raid_max_disks 801 && (mpt_disk->flags & MPT_RDF_ACTIVE) != 0) { 802 *tgt = mpt_disk->config_page.PhysDiskID; 803 return (0); 804 } 805 mpt_lprt(mpt, MPT_PRT_DEBUG1, "mpt_map_physdisk(%d) - Not Active\n", 806 ccb->ccb_h.target_id); 807 return (-1); 808 } 809 810 /* XXX Ignores that there may be multiple busses/IOCs involved. */ 811 int 812 mpt_is_raid_volume(struct mpt_softc *mpt, int tgt) 813 { 814 CONFIG_PAGE_IOC_2_RAID_VOL *ioc_vol; 815 CONFIG_PAGE_IOC_2_RAID_VOL *ioc_last_vol; 816 817 if (mpt->ioc_page2 == NULL || mpt->ioc_page2->MaxPhysDisks == 0) { 818 return (0); 819 } 820 ioc_vol = mpt->ioc_page2->RaidVolume; 821 ioc_last_vol = ioc_vol + mpt->ioc_page2->NumActiveVolumes; 822 for (;ioc_vol != ioc_last_vol; ioc_vol++) { 823 if (ioc_vol->VolumeID == tgt) { 824 return (1); 825 } 826 } 827 return (0); 828 } 829 830 #if 0 831 static void 832 mpt_enable_vol(struct mpt_softc *mpt, struct mpt_raid_volume *mpt_vol, 833 int enable) 834 { 835 request_t *req; 836 struct mpt_raid_action_result *ar; 837 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 838 int enabled; 839 int rv; 840 841 vol_pg = mpt_vol->config_page; 842 enabled = vol_pg->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED; 843 844 /* 845 * If the setting matches the configuration, 846 * there is nothing to do. 847 */ 848 if ((enabled && enable) 849 || (!enabled && !enable)) 850 return; 851 852 req = mpt_get_request(mpt, /*sleep_ok*/TRUE); 853 if (req == NULL) { 854 mpt_vol_prt(mpt, mpt_vol, 855 "mpt_enable_vol: Get request failed!\n"); 856 return; 857 } 858 859 rv = mpt_issue_raid_req(mpt, mpt_vol, /*disk*/NULL, req, 860 enable ? MPI_RAID_ACTION_ENABLE_VOLUME 861 : MPI_RAID_ACTION_DISABLE_VOLUME, 862 /*data*/0, /*addr*/0, /*len*/0, 863 /*write*/FALSE, /*wait*/TRUE); 864 if (rv == ETIMEDOUT) { 865 mpt_vol_prt(mpt, mpt_vol, "mpt_enable_vol: " 866 "%s Volume Timed-out\n", 867 enable ? "Enable" : "Disable"); 868 return; 869 } 870 ar = REQ_TO_RAID_ACTION_RESULT(req); 871 if (rv != 0 872 || REQ_IOCSTATUS(req) != MPI_IOCSTATUS_SUCCESS 873 || (ar->action_status != MPI_RAID_ACTION_ASTATUS_SUCCESS)) { 874 mpt_vol_prt(mpt, mpt_vol, "%s Volume Failed: %d:%x:%x\n", 875 enable ? "Enable" : "Disable", 876 rv, req->IOCStatus, ar->action_status); 877 } 878 879 mpt_free_request(mpt, req); 880 } 881 #endif 882 883 static void 884 mpt_verify_mwce(struct mpt_softc *mpt, struct mpt_raid_volume *mpt_vol) 885 { 886 request_t *req; 887 struct mpt_raid_action_result *ar; 888 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 889 uint32_t data; 890 int rv; 891 int resyncing; 892 int mwce; 893 894 vol_pg = mpt_vol->config_page; 895 resyncing = vol_pg->VolumeStatus.Flags 896 & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS; 897 mwce = vol_pg->VolumeSettings.Settings 898 & MPI_RAIDVOL0_SETTING_WRITE_CACHING_ENABLE; 899 900 /* 901 * If the setting matches the configuration, 902 * there is nothing to do. 903 */ 904 switch (mpt->raid_mwce_setting) { 905 case MPT_RAID_MWCE_REBUILD_ONLY: 906 if ((resyncing && mwce) || (!resyncing && !mwce)) { 907 return; 908 } 909 mpt_vol->flags ^= MPT_RVF_WCE_CHANGED; 910 if ((mpt_vol->flags & MPT_RVF_WCE_CHANGED) == 0) { 911 /* 912 * Wait one more status update to see if 913 * resyncing gets enabled. It gets disabled 914 * temporarilly when WCE is changed. 915 */ 916 return; 917 } 918 break; 919 case MPT_RAID_MWCE_ON: 920 if (mwce) 921 return; 922 break; 923 case MPT_RAID_MWCE_OFF: 924 if (!mwce) 925 return; 926 break; 927 case MPT_RAID_MWCE_NC: 928 return; 929 } 930 931 req = mpt_get_request(mpt, /*sleep_ok*/TRUE); 932 if (req == NULL) { 933 mpt_vol_prt(mpt, mpt_vol, 934 "mpt_verify_mwce: Get request failed!\n"); 935 return; 936 } 937 938 vol_pg->VolumeSettings.Settings ^= 939 MPI_RAIDVOL0_SETTING_WRITE_CACHING_ENABLE; 940 memcpy(&data, &vol_pg->VolumeSettings, sizeof(data)); 941 vol_pg->VolumeSettings.Settings ^= 942 MPI_RAIDVOL0_SETTING_WRITE_CACHING_ENABLE; 943 rv = mpt_issue_raid_req(mpt, mpt_vol, /*disk*/NULL, req, 944 MPI_RAID_ACTION_CHANGE_VOLUME_SETTINGS, 945 data, /*addr*/0, /*len*/0, 946 /*write*/FALSE, /*wait*/TRUE); 947 if (rv == ETIMEDOUT) { 948 mpt_vol_prt(mpt, mpt_vol, "mpt_verify_mwce: " 949 "Write Cache Enable Timed-out\n"); 950 return; 951 } 952 ar = REQ_TO_RAID_ACTION_RESULT(req); 953 if (rv != 0 954 || REQ_IOCSTATUS(req) != MPI_IOCSTATUS_SUCCESS 955 || (ar->action_status != MPI_RAID_ACTION_ASTATUS_SUCCESS)) { 956 mpt_vol_prt(mpt, mpt_vol, "Write Cache Enable Failed: " 957 "%d:%x:%x\n", rv, req->IOCStatus, 958 ar->action_status); 959 } else { 960 vol_pg->VolumeSettings.Settings ^= 961 MPI_RAIDVOL0_SETTING_WRITE_CACHING_ENABLE; 962 } 963 mpt_free_request(mpt, req); 964 } 965 966 static void 967 mpt_verify_resync_rate(struct mpt_softc *mpt, struct mpt_raid_volume *mpt_vol) 968 { 969 request_t *req; 970 struct mpt_raid_action_result *ar; 971 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 972 u_int prio; 973 int rv; 974 975 vol_pg = mpt_vol->config_page; 976 977 if (mpt->raid_resync_rate == MPT_RAID_RESYNC_RATE_NC) 978 return; 979 980 /* 981 * If the current RAID resync rate does not 982 * match our configured rate, update it. 983 */ 984 prio = vol_pg->VolumeSettings.Settings 985 & MPI_RAIDVOL0_SETTING_PRIORITY_RESYNC; 986 if (vol_pg->ResyncRate != 0 987 && vol_pg->ResyncRate != mpt->raid_resync_rate) { 988 989 req = mpt_get_request(mpt, /*sleep_ok*/TRUE); 990 if (req == NULL) { 991 mpt_vol_prt(mpt, mpt_vol, "mpt_verify_resync_rate: " 992 "Get request failed!\n"); 993 return; 994 } 995 996 rv = mpt_issue_raid_req(mpt, mpt_vol, /*disk*/NULL, req, 997 MPI_RAID_ACTION_SET_RESYNC_RATE, 998 mpt->raid_resync_rate, /*addr*/0, 999 /*len*/0, /*write*/FALSE, /*wait*/TRUE); 1000 if (rv == ETIMEDOUT) { 1001 mpt_vol_prt(mpt, mpt_vol, "mpt_refresh_raid_data: " 1002 "Resync Rate Setting Timed-out\n"); 1003 return; 1004 } 1005 1006 ar = REQ_TO_RAID_ACTION_RESULT(req); 1007 if (rv != 0 1008 || REQ_IOCSTATUS(req) != MPI_IOCSTATUS_SUCCESS 1009 || (ar->action_status != MPI_RAID_ACTION_ASTATUS_SUCCESS)) { 1010 mpt_vol_prt(mpt, mpt_vol, "Resync Rate Setting Failed: " 1011 "%d:%x:%x\n", rv, req->IOCStatus, 1012 ar->action_status); 1013 } else 1014 vol_pg->ResyncRate = mpt->raid_resync_rate; 1015 mpt_free_request(mpt, req); 1016 } else if ((prio && mpt->raid_resync_rate < 128) 1017 || (!prio && mpt->raid_resync_rate >= 128)) { 1018 uint32_t data; 1019 1020 req = mpt_get_request(mpt, /*sleep_ok*/TRUE); 1021 if (req == NULL) { 1022 mpt_vol_prt(mpt, mpt_vol, "mpt_verify_resync_rate: " 1023 "Get request failed!\n"); 1024 return; 1025 } 1026 1027 vol_pg->VolumeSettings.Settings ^= 1028 MPI_RAIDVOL0_SETTING_PRIORITY_RESYNC; 1029 memcpy(&data, &vol_pg->VolumeSettings, sizeof(data)); 1030 vol_pg->VolumeSettings.Settings ^= 1031 MPI_RAIDVOL0_SETTING_PRIORITY_RESYNC; 1032 rv = mpt_issue_raid_req(mpt, mpt_vol, /*disk*/NULL, req, 1033 MPI_RAID_ACTION_CHANGE_VOLUME_SETTINGS, 1034 data, /*addr*/0, /*len*/0, 1035 /*write*/FALSE, /*wait*/TRUE); 1036 if (rv == ETIMEDOUT) { 1037 mpt_vol_prt(mpt, mpt_vol, "mpt_refresh_raid_data: " 1038 "Resync Rate Setting Timed-out\n"); 1039 return; 1040 } 1041 ar = REQ_TO_RAID_ACTION_RESULT(req); 1042 if (rv != 0 1043 || REQ_IOCSTATUS(req) != MPI_IOCSTATUS_SUCCESS 1044 || (ar->action_status != MPI_RAID_ACTION_ASTATUS_SUCCESS)) { 1045 mpt_vol_prt(mpt, mpt_vol, "Resync Rate Setting Failed: " 1046 "%d:%x:%x\n", rv, req->IOCStatus, 1047 ar->action_status); 1048 } else { 1049 vol_pg->VolumeSettings.Settings ^= 1050 MPI_RAIDVOL0_SETTING_PRIORITY_RESYNC; 1051 } 1052 1053 mpt_free_request(mpt, req); 1054 } 1055 } 1056 1057 static void 1058 mpt_adjust_queue_depth(struct mpt_softc *mpt, struct mpt_raid_volume *mpt_vol, 1059 struct cam_path *path) 1060 { 1061 struct ccb_relsim crs; 1062 1063 xpt_setup_ccb(&crs.ccb_h, path, /*priority*/5); 1064 crs.ccb_h.func_code = XPT_REL_SIMQ; 1065 crs.release_flags = RELSIM_ADJUST_OPENINGS; 1066 crs.openings = mpt->raid_queue_depth; 1067 xpt_action((union ccb *)&crs); 1068 if (crs.ccb_h.status != CAM_REQ_CMP) 1069 mpt_vol_prt(mpt, mpt_vol, "mpt_adjust_queue_depth failed " 1070 "with CAM status %#x\n", crs.ccb_h.status); 1071 } 1072 1073 static void 1074 mpt_announce_vol(struct mpt_softc *mpt, struct mpt_raid_volume *mpt_vol) 1075 { 1076 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 1077 u_int i; 1078 1079 vol_pg = mpt_vol->config_page; 1080 mpt_vol_prt(mpt, mpt_vol, "Settings ("); 1081 for (i = 1; i <= 0x8000; i <<= 1) { 1082 switch (vol_pg->VolumeSettings.Settings & i) { 1083 case MPI_RAIDVOL0_SETTING_WRITE_CACHING_ENABLE: 1084 mpt_prtc(mpt, " Member-WCE"); 1085 break; 1086 case MPI_RAIDVOL0_SETTING_OFFLINE_ON_SMART: 1087 mpt_prtc(mpt, " Offline-On-SMART-Err"); 1088 break; 1089 case MPI_RAIDVOL0_SETTING_AUTO_CONFIGURE: 1090 mpt_prtc(mpt, " Hot-Plug-Spares"); 1091 break; 1092 case MPI_RAIDVOL0_SETTING_PRIORITY_RESYNC: 1093 mpt_prtc(mpt, " High-Priority-ReSync"); 1094 break; 1095 default: 1096 break; 1097 } 1098 } 1099 mpt_prtc(mpt, " )\n"); 1100 if (vol_pg->VolumeSettings.HotSparePool != 0) { 1101 mpt_vol_prt(mpt, mpt_vol, "Using Spare Pool%s", 1102 powerof2(vol_pg->VolumeSettings.HotSparePool) 1103 ? ":" : "s:"); 1104 for (i = 0; i < 8; i++) { 1105 u_int mask; 1106 1107 mask = 0x1 << i; 1108 if ((vol_pg->VolumeSettings.HotSparePool & mask) == 0) 1109 continue; 1110 mpt_prtc(mpt, " %d", i); 1111 } 1112 mpt_prtc(mpt, "\n"); 1113 } 1114 mpt_vol_prt(mpt, mpt_vol, "%d Members:\n", vol_pg->NumPhysDisks); 1115 for (i = 0; i < vol_pg->NumPhysDisks; i++){ 1116 struct mpt_raid_disk *mpt_disk; 1117 CONFIG_PAGE_RAID_PHYS_DISK_0 *disk_pg; 1118 int pt_bus = cam_sim_bus(mpt->phydisk_sim); 1119 U8 f, s; 1120 1121 mpt_disk = mpt->raid_disks + vol_pg->PhysDisk[i].PhysDiskNum; 1122 disk_pg = &mpt_disk->config_page; 1123 mpt_prtc(mpt, " "); 1124 mpt_prtc(mpt, "(%s:%d:%d:0): ", device_get_nameunit(mpt->dev), 1125 pt_bus, disk_pg->PhysDiskID); 1126 if (vol_pg->VolumeType == MPI_RAID_VOL_TYPE_IM) { 1127 mpt_prtc(mpt, "%s", mpt_disk->member_number == 0? 1128 "Primary" : "Secondary"); 1129 } else { 1130 mpt_prtc(mpt, "Stripe Position %d", 1131 mpt_disk->member_number); 1132 } 1133 f = disk_pg->PhysDiskStatus.Flags; 1134 s = disk_pg->PhysDiskStatus.State; 1135 if (f & MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC) { 1136 mpt_prtc(mpt, " Out of Sync"); 1137 } 1138 if (f & MPI_PHYSDISK0_STATUS_FLAG_QUIESCED) { 1139 mpt_prtc(mpt, " Quiesced"); 1140 } 1141 if (f & MPI_PHYSDISK0_STATUS_FLAG_INACTIVE_VOLUME) { 1142 mpt_prtc(mpt, " Inactive"); 1143 } 1144 if (f & MPI_PHYSDISK0_STATUS_FLAG_OPTIMAL_PREVIOUS) { 1145 mpt_prtc(mpt, " Was Optimal"); 1146 } 1147 if (f & MPI_PHYSDISK0_STATUS_FLAG_NOT_OPTIMAL_PREVIOUS) { 1148 mpt_prtc(mpt, " Was Non-Optimal"); 1149 } 1150 switch (s) { 1151 case MPI_PHYSDISK0_STATUS_ONLINE: 1152 mpt_prtc(mpt, " Online"); 1153 break; 1154 case MPI_PHYSDISK0_STATUS_MISSING: 1155 mpt_prtc(mpt, " Missing"); 1156 break; 1157 case MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE: 1158 mpt_prtc(mpt, " Incompatible"); 1159 break; 1160 case MPI_PHYSDISK0_STATUS_FAILED: 1161 mpt_prtc(mpt, " Failed"); 1162 break; 1163 case MPI_PHYSDISK0_STATUS_INITIALIZING: 1164 mpt_prtc(mpt, " Initializing"); 1165 break; 1166 case MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED: 1167 mpt_prtc(mpt, " Requested Offline"); 1168 break; 1169 case MPI_PHYSDISK0_STATUS_FAILED_REQUESTED: 1170 mpt_prtc(mpt, " Requested Failed"); 1171 break; 1172 case MPI_PHYSDISK0_STATUS_OTHER_OFFLINE: 1173 default: 1174 mpt_prtc(mpt, " Offline Other (%x)", s); 1175 break; 1176 } 1177 mpt_prtc(mpt, "\n"); 1178 } 1179 } 1180 1181 static void 1182 mpt_announce_disk(struct mpt_softc *mpt, struct mpt_raid_disk *mpt_disk) 1183 { 1184 CONFIG_PAGE_RAID_PHYS_DISK_0 *disk_pg; 1185 int rd_bus = cam_sim_bus(mpt->sim); 1186 int pt_bus = cam_sim_bus(mpt->phydisk_sim); 1187 u_int i; 1188 1189 disk_pg = &mpt_disk->config_page; 1190 mpt_disk_prt(mpt, mpt_disk, 1191 "Physical (%s:%d:%d:0), Pass-thru (%s:%d:%d:0)\n", 1192 device_get_nameunit(mpt->dev), rd_bus, 1193 disk_pg->PhysDiskID, device_get_nameunit(mpt->dev), 1194 pt_bus, mpt_disk - mpt->raid_disks); 1195 if (disk_pg->PhysDiskSettings.HotSparePool == 0) 1196 return; 1197 mpt_disk_prt(mpt, mpt_disk, "Member of Hot Spare Pool%s", 1198 powerof2(disk_pg->PhysDiskSettings.HotSparePool) 1199 ? ":" : "s:"); 1200 for (i = 0; i < 8; i++) { 1201 u_int mask; 1202 1203 mask = 0x1 << i; 1204 if ((disk_pg->PhysDiskSettings.HotSparePool & mask) == 0) 1205 continue; 1206 mpt_prtc(mpt, " %d", i); 1207 } 1208 mpt_prtc(mpt, "\n"); 1209 } 1210 1211 static void 1212 mpt_refresh_raid_disk(struct mpt_softc *mpt, struct mpt_raid_disk *mpt_disk, 1213 IOC_3_PHYS_DISK *ioc_disk) 1214 { 1215 int rv; 1216 1217 rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_RAID_PHYSDISK, 1218 /*PageNumber*/0, ioc_disk->PhysDiskNum, 1219 &mpt_disk->config_page.Header, 1220 /*sleep_ok*/TRUE, /*timeout_ms*/5000); 1221 if (rv != 0) { 1222 mpt_prt(mpt, "mpt_refresh_raid_disk: " 1223 "Failed to read RAID Disk Hdr(%d)\n", 1224 ioc_disk->PhysDiskNum); 1225 return; 1226 } 1227 rv = mpt_read_cur_cfg_page(mpt, ioc_disk->PhysDiskNum, 1228 &mpt_disk->config_page.Header, 1229 sizeof(mpt_disk->config_page), 1230 /*sleep_ok*/TRUE, /*timeout_ms*/5000); 1231 if (rv != 0) 1232 mpt_prt(mpt, "mpt_refresh_raid_disk: " 1233 "Failed to read RAID Disk Page(%d)\n", 1234 ioc_disk->PhysDiskNum); 1235 mpt2host_config_page_raid_phys_disk_0(&mpt_disk->config_page); 1236 } 1237 1238 static void 1239 mpt_refresh_raid_vol(struct mpt_softc *mpt, struct mpt_raid_volume *mpt_vol, 1240 CONFIG_PAGE_IOC_2_RAID_VOL *ioc_vol) 1241 { 1242 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 1243 struct mpt_raid_action_result *ar; 1244 request_t *req; 1245 int rv; 1246 int i; 1247 1248 vol_pg = mpt_vol->config_page; 1249 mpt_vol->flags &= ~MPT_RVF_UP2DATE; 1250 1251 rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_RAID_VOLUME, 0, 1252 ioc_vol->VolumePageNumber, &vol_pg->Header, TRUE, 5000); 1253 if (rv != 0) { 1254 mpt_vol_prt(mpt, mpt_vol, 1255 "mpt_refresh_raid_vol: Failed to read RAID Vol Hdr(%d)\n", 1256 ioc_vol->VolumePageNumber); 1257 return; 1258 } 1259 1260 rv = mpt_read_cur_cfg_page(mpt, ioc_vol->VolumePageNumber, 1261 &vol_pg->Header, mpt->raid_page0_len, TRUE, 5000); 1262 if (rv != 0) { 1263 mpt_vol_prt(mpt, mpt_vol, 1264 "mpt_refresh_raid_vol: Failed to read RAID Vol Page(%d)\n", 1265 ioc_vol->VolumePageNumber); 1266 return; 1267 } 1268 mpt2host_config_page_raid_vol_0(vol_pg); 1269 1270 mpt_vol->flags |= MPT_RVF_ACTIVE; 1271 1272 /* Update disk entry array data. */ 1273 for (i = 0; i < vol_pg->NumPhysDisks; i++) { 1274 struct mpt_raid_disk *mpt_disk; 1275 mpt_disk = mpt->raid_disks + vol_pg->PhysDisk[i].PhysDiskNum; 1276 mpt_disk->volume = mpt_vol; 1277 mpt_disk->member_number = vol_pg->PhysDisk[i].PhysDiskMap; 1278 if (vol_pg->VolumeType == MPI_RAID_VOL_TYPE_IM) { 1279 mpt_disk->member_number--; 1280 } 1281 } 1282 1283 if ((vol_pg->VolumeStatus.Flags 1284 & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) == 0) 1285 return; 1286 1287 req = mpt_get_request(mpt, TRUE); 1288 if (req == NULL) { 1289 mpt_vol_prt(mpt, mpt_vol, 1290 "mpt_refresh_raid_vol: Get request failed!\n"); 1291 return; 1292 } 1293 rv = mpt_issue_raid_req(mpt, mpt_vol, NULL, req, 1294 MPI_RAID_ACTION_INDICATOR_STRUCT, 0, 0, 0, FALSE, TRUE); 1295 if (rv == ETIMEDOUT) { 1296 mpt_vol_prt(mpt, mpt_vol, 1297 "mpt_refresh_raid_vol: Progress Indicator fetch timeout\n"); 1298 mpt_free_request(mpt, req); 1299 return; 1300 } 1301 1302 ar = REQ_TO_RAID_ACTION_RESULT(req); 1303 if (rv == 0 1304 && ar->action_status == MPI_RAID_ACTION_ASTATUS_SUCCESS 1305 && REQ_IOCSTATUS(req) == MPI_IOCSTATUS_SUCCESS) { 1306 memcpy(&mpt_vol->sync_progress, 1307 &ar->action_data.indicator_struct, 1308 sizeof(mpt_vol->sync_progress)); 1309 mpt2host_mpi_raid_vol_indicator(&mpt_vol->sync_progress); 1310 } else { 1311 mpt_vol_prt(mpt, mpt_vol, 1312 "mpt_refresh_raid_vol: Progress indicator fetch failed!\n"); 1313 } 1314 mpt_free_request(mpt, req); 1315 } 1316 1317 /* 1318 * Update in-core information about RAID support. We update any entries 1319 * that didn't previously exists or have been marked as needing to 1320 * be updated by our event handler. Interesting changes are displayed 1321 * to the console. 1322 */ 1323 int 1324 mpt_refresh_raid_data(struct mpt_softc *mpt) 1325 { 1326 CONFIG_PAGE_IOC_2_RAID_VOL *ioc_vol; 1327 CONFIG_PAGE_IOC_2_RAID_VOL *ioc_last_vol; 1328 IOC_3_PHYS_DISK *ioc_disk; 1329 IOC_3_PHYS_DISK *ioc_last_disk; 1330 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 1331 size_t len; 1332 int rv; 1333 int i; 1334 u_int nonopt_volumes; 1335 1336 if (mpt->ioc_page2 == NULL || mpt->ioc_page3 == NULL) { 1337 return (0); 1338 } 1339 1340 /* 1341 * Mark all items as unreferenced by the configuration. 1342 * This allows us to find, report, and discard stale 1343 * entries. 1344 */ 1345 for (i = 0; i < mpt->ioc_page2->MaxPhysDisks; i++) { 1346 mpt->raid_disks[i].flags &= ~MPT_RDF_REFERENCED; 1347 } 1348 for (i = 0; i < mpt->ioc_page2->MaxVolumes; i++) { 1349 mpt->raid_volumes[i].flags &= ~MPT_RVF_REFERENCED; 1350 } 1351 1352 /* 1353 * Get Physical Disk information. 1354 */ 1355 len = mpt->ioc_page3->Header.PageLength * sizeof(uint32_t); 1356 rv = mpt_read_cur_cfg_page(mpt, /*PageAddress*/0, 1357 &mpt->ioc_page3->Header, len, 1358 /*sleep_ok*/TRUE, /*timeout_ms*/5000); 1359 if (rv) { 1360 mpt_prt(mpt, 1361 "mpt_refresh_raid_data: Failed to read IOC Page 3\n"); 1362 return (-1); 1363 } 1364 mpt2host_config_page_ioc3(mpt->ioc_page3); 1365 1366 ioc_disk = mpt->ioc_page3->PhysDisk; 1367 ioc_last_disk = ioc_disk + mpt->ioc_page3->NumPhysDisks; 1368 for (; ioc_disk != ioc_last_disk; ioc_disk++) { 1369 struct mpt_raid_disk *mpt_disk; 1370 1371 mpt_disk = mpt->raid_disks + ioc_disk->PhysDiskNum; 1372 mpt_disk->flags |= MPT_RDF_REFERENCED; 1373 if ((mpt_disk->flags & (MPT_RDF_ACTIVE|MPT_RDF_UP2DATE)) 1374 != (MPT_RDF_ACTIVE|MPT_RDF_UP2DATE)) { 1375 1376 mpt_refresh_raid_disk(mpt, mpt_disk, ioc_disk); 1377 1378 } 1379 mpt_disk->flags |= MPT_RDF_ACTIVE; 1380 mpt->raid_rescan++; 1381 } 1382 1383 /* 1384 * Refresh volume data. 1385 */ 1386 len = mpt->ioc_page2->Header.PageLength * sizeof(uint32_t); 1387 rv = mpt_read_cur_cfg_page(mpt, /*PageAddress*/0, 1388 &mpt->ioc_page2->Header, len, 1389 /*sleep_ok*/TRUE, /*timeout_ms*/5000); 1390 if (rv) { 1391 mpt_prt(mpt, "mpt_refresh_raid_data: " 1392 "Failed to read IOC Page 2\n"); 1393 return (-1); 1394 } 1395 mpt2host_config_page_ioc2(mpt->ioc_page2); 1396 1397 ioc_vol = mpt->ioc_page2->RaidVolume; 1398 ioc_last_vol = ioc_vol + mpt->ioc_page2->NumActiveVolumes; 1399 for (;ioc_vol != ioc_last_vol; ioc_vol++) { 1400 struct mpt_raid_volume *mpt_vol; 1401 1402 mpt_vol = mpt->raid_volumes + ioc_vol->VolumePageNumber; 1403 mpt_vol->flags |= MPT_RVF_REFERENCED; 1404 vol_pg = mpt_vol->config_page; 1405 if (vol_pg == NULL) 1406 continue; 1407 if (((mpt_vol->flags & (MPT_RVF_ACTIVE|MPT_RVF_UP2DATE)) 1408 != (MPT_RVF_ACTIVE|MPT_RVF_UP2DATE)) 1409 || (vol_pg->VolumeStatus.Flags 1410 & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) != 0) { 1411 1412 mpt_refresh_raid_vol(mpt, mpt_vol, ioc_vol); 1413 } 1414 mpt_vol->flags |= MPT_RVF_ACTIVE; 1415 } 1416 1417 nonopt_volumes = 0; 1418 for (i = 0; i < mpt->ioc_page2->MaxVolumes; i++) { 1419 struct mpt_raid_volume *mpt_vol; 1420 uint64_t total; 1421 uint64_t left; 1422 int m; 1423 u_int prio; 1424 1425 mpt_vol = &mpt->raid_volumes[i]; 1426 1427 if ((mpt_vol->flags & MPT_RVF_ACTIVE) == 0) { 1428 continue; 1429 } 1430 1431 vol_pg = mpt_vol->config_page; 1432 if ((mpt_vol->flags & (MPT_RVF_REFERENCED|MPT_RVF_ANNOUNCED)) 1433 == MPT_RVF_ANNOUNCED) { 1434 mpt_vol_prt(mpt, mpt_vol, "No longer configured\n"); 1435 mpt_vol->flags = 0; 1436 continue; 1437 } 1438 1439 if ((mpt_vol->flags & MPT_RVF_ANNOUNCED) == 0) { 1440 mpt_announce_vol(mpt, mpt_vol); 1441 mpt_vol->flags |= MPT_RVF_ANNOUNCED; 1442 } 1443 1444 if (vol_pg->VolumeStatus.State != 1445 MPI_RAIDVOL0_STATUS_STATE_OPTIMAL) 1446 nonopt_volumes++; 1447 1448 if ((mpt_vol->flags & MPT_RVF_UP2DATE) != 0) 1449 continue; 1450 1451 mpt_vol->flags |= MPT_RVF_UP2DATE; 1452 mpt_vol_prt(mpt, mpt_vol, "%s - %s\n", 1453 mpt_vol_type(mpt_vol), mpt_vol_state(mpt_vol)); 1454 mpt_verify_mwce(mpt, mpt_vol); 1455 1456 if (vol_pg->VolumeStatus.Flags == 0) { 1457 continue; 1458 } 1459 1460 mpt_vol_prt(mpt, mpt_vol, "Status ("); 1461 for (m = 1; m <= 0x80; m <<= 1) { 1462 switch (vol_pg->VolumeStatus.Flags & m) { 1463 case MPI_RAIDVOL0_STATUS_FLAG_ENABLED: 1464 mpt_prtc(mpt, " Enabled"); 1465 break; 1466 case MPI_RAIDVOL0_STATUS_FLAG_QUIESCED: 1467 mpt_prtc(mpt, " Quiesced"); 1468 break; 1469 case MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS: 1470 mpt_prtc(mpt, " Re-Syncing"); 1471 break; 1472 case MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE: 1473 mpt_prtc(mpt, " Inactive"); 1474 break; 1475 default: 1476 break; 1477 } 1478 } 1479 mpt_prtc(mpt, " )\n"); 1480 1481 if ((vol_pg->VolumeStatus.Flags 1482 & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) == 0) 1483 continue; 1484 1485 mpt_verify_resync_rate(mpt, mpt_vol); 1486 1487 left = MPT_U64_2_SCALAR(mpt_vol->sync_progress.BlocksRemaining); 1488 total = MPT_U64_2_SCALAR(mpt_vol->sync_progress.TotalBlocks); 1489 if (vol_pg->ResyncRate != 0) { 1490 1491 prio = ((u_int)vol_pg->ResyncRate * 100000) / 0xFF; 1492 mpt_vol_prt(mpt, mpt_vol, "Rate %d.%d%%\n", 1493 prio / 1000, prio % 1000); 1494 } else { 1495 prio = vol_pg->VolumeSettings.Settings 1496 & MPI_RAIDVOL0_SETTING_PRIORITY_RESYNC; 1497 mpt_vol_prt(mpt, mpt_vol, "%s Priority Re-Sync\n", 1498 prio ? "High" : "Low"); 1499 } 1500 #if __FreeBSD_version >= 500000 1501 mpt_vol_prt(mpt, mpt_vol, "%ju of %ju " 1502 "blocks remaining\n", (uintmax_t)left, 1503 (uintmax_t)total); 1504 #else 1505 mpt_vol_prt(mpt, mpt_vol, "%llu of %llu " 1506 "blocks remaining\n", (uint64_t)left, 1507 (uint64_t)total); 1508 #endif 1509 1510 /* Periodically report on sync progress. */ 1511 mpt_schedule_raid_refresh(mpt); 1512 } 1513 1514 for (i = 0; i < mpt->ioc_page2->MaxPhysDisks; i++) { 1515 struct mpt_raid_disk *mpt_disk; 1516 CONFIG_PAGE_RAID_PHYS_DISK_0 *disk_pg; 1517 int m; 1518 1519 mpt_disk = &mpt->raid_disks[i]; 1520 disk_pg = &mpt_disk->config_page; 1521 1522 if ((mpt_disk->flags & MPT_RDF_ACTIVE) == 0) 1523 continue; 1524 1525 if ((mpt_disk->flags & (MPT_RDF_REFERENCED|MPT_RDF_ANNOUNCED)) 1526 == MPT_RDF_ANNOUNCED) { 1527 mpt_disk_prt(mpt, mpt_disk, "No longer configured\n"); 1528 mpt_disk->flags = 0; 1529 mpt->raid_rescan++; 1530 continue; 1531 } 1532 1533 if ((mpt_disk->flags & MPT_RDF_ANNOUNCED) == 0) { 1534 1535 mpt_announce_disk(mpt, mpt_disk); 1536 mpt_disk->flags |= MPT_RVF_ANNOUNCED; 1537 } 1538 1539 if ((mpt_disk->flags & MPT_RDF_UP2DATE) != 0) 1540 continue; 1541 1542 mpt_disk->flags |= MPT_RDF_UP2DATE; 1543 mpt_disk_prt(mpt, mpt_disk, "%s\n", mpt_disk_state(mpt_disk)); 1544 if (disk_pg->PhysDiskStatus.Flags == 0) 1545 continue; 1546 1547 mpt_disk_prt(mpt, mpt_disk, "Status ("); 1548 for (m = 1; m <= 0x80; m <<= 1) { 1549 switch (disk_pg->PhysDiskStatus.Flags & m) { 1550 case MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC: 1551 mpt_prtc(mpt, " Out-Of-Sync"); 1552 break; 1553 case MPI_PHYSDISK0_STATUS_FLAG_QUIESCED: 1554 mpt_prtc(mpt, " Quiesced"); 1555 break; 1556 default: 1557 break; 1558 } 1559 } 1560 mpt_prtc(mpt, " )\n"); 1561 } 1562 1563 mpt->raid_nonopt_volumes = nonopt_volumes; 1564 return (0); 1565 } 1566 1567 static void 1568 mpt_raid_timer(void *arg) 1569 { 1570 struct mpt_softc *mpt; 1571 1572 mpt = (struct mpt_softc *)arg; 1573 MPT_LOCK(mpt); 1574 mpt_raid_wakeup(mpt); 1575 MPT_UNLOCK(mpt); 1576 } 1577 1578 void 1579 mpt_schedule_raid_refresh(struct mpt_softc *mpt) 1580 { 1581 callout_reset(&mpt->raid_timer, MPT_RAID_SYNC_REPORT_INTERVAL, 1582 mpt_raid_timer, mpt); 1583 } 1584 1585 void 1586 mpt_raid_free_mem(struct mpt_softc *mpt) 1587 { 1588 1589 if (mpt->raid_volumes) { 1590 struct mpt_raid_volume *mpt_raid; 1591 int i; 1592 for (i = 0; i < mpt->raid_max_volumes; i++) { 1593 mpt_raid = &mpt->raid_volumes[i]; 1594 if (mpt_raid->config_page) { 1595 kfree(mpt_raid->config_page, M_DEVBUF); 1596 mpt_raid->config_page = NULL; 1597 } 1598 } 1599 kfree(mpt->raid_volumes, M_DEVBUF); 1600 mpt->raid_volumes = NULL; 1601 } 1602 if (mpt->raid_disks) { 1603 kfree(mpt->raid_disks, M_DEVBUF); 1604 mpt->raid_disks = NULL; 1605 } 1606 if (mpt->ioc_page2) { 1607 kfree(mpt->ioc_page2, M_DEVBUF); 1608 mpt->ioc_page2 = NULL; 1609 } 1610 if (mpt->ioc_page3) { 1611 kfree(mpt->ioc_page3, M_DEVBUF); 1612 mpt->ioc_page3 = NULL; 1613 } 1614 mpt->raid_max_volumes = 0; 1615 mpt->raid_max_disks = 0; 1616 } 1617 1618 #if __FreeBSD_version >= 500000 1619 static int 1620 mpt_raid_set_vol_resync_rate(struct mpt_softc *mpt, u_int rate) 1621 { 1622 struct mpt_raid_volume *mpt_vol; 1623 1624 if ((rate > MPT_RAID_RESYNC_RATE_MAX 1625 || rate < MPT_RAID_RESYNC_RATE_MIN) 1626 && rate != MPT_RAID_RESYNC_RATE_NC) 1627 return (EINVAL); 1628 1629 MPT_LOCK(mpt); 1630 mpt->raid_resync_rate = rate; 1631 RAID_VOL_FOREACH(mpt, mpt_vol) { 1632 if ((mpt_vol->flags & MPT_RVF_ACTIVE) == 0) { 1633 continue; 1634 } 1635 mpt_verify_resync_rate(mpt, mpt_vol); 1636 } 1637 MPT_UNLOCK(mpt); 1638 return (0); 1639 } 1640 1641 static int 1642 mpt_raid_set_vol_queue_depth(struct mpt_softc *mpt, u_int vol_queue_depth) 1643 { 1644 struct mpt_raid_volume *mpt_vol; 1645 1646 if (vol_queue_depth > 255 || vol_queue_depth < 1) 1647 return (EINVAL); 1648 1649 MPT_LOCK(mpt); 1650 mpt->raid_queue_depth = vol_queue_depth; 1651 RAID_VOL_FOREACH(mpt, mpt_vol) { 1652 struct cam_path *path; 1653 int error; 1654 1655 if ((mpt_vol->flags & MPT_RVF_ACTIVE) == 0) 1656 continue; 1657 1658 mpt->raid_rescan = 0; 1659 1660 MPTLOCK_2_CAMLOCK(mpt); 1661 error = xpt_create_path(&path, xpt_periph, 1662 cam_sim_path(mpt->sim), 1663 mpt_vol->config_page->VolumeID, 1664 /*lun*/0); 1665 if (error != CAM_REQ_CMP) { 1666 CAMLOCK_2_MPTLOCK(mpt); 1667 mpt_vol_prt(mpt, mpt_vol, "Unable to allocate path!\n"); 1668 continue; 1669 } 1670 mpt_adjust_queue_depth(mpt, mpt_vol, path); 1671 xpt_free_path(path); 1672 CAMLOCK_2_MPTLOCK(mpt); 1673 } 1674 MPT_UNLOCK(mpt); 1675 return (0); 1676 } 1677 1678 static int 1679 mpt_raid_set_vol_mwce(struct mpt_softc *mpt, mpt_raid_mwce_t mwce) 1680 { 1681 struct mpt_raid_volume *mpt_vol; 1682 int force_full_resync; 1683 1684 MPT_LOCK(mpt); 1685 if (mwce == mpt->raid_mwce_setting) { 1686 MPT_UNLOCK(mpt); 1687 return (0); 1688 } 1689 1690 /* 1691 * Catch MWCE being left on due to a failed shutdown. Since 1692 * sysctls cannot be set by the loader, we treat the first 1693 * setting of this varible specially and force a full volume 1694 * resync if MWCE is enabled and a resync is in progress. 1695 */ 1696 force_full_resync = 0; 1697 if (mpt->raid_mwce_set == 0 1698 && mpt->raid_mwce_setting == MPT_RAID_MWCE_NC 1699 && mwce == MPT_RAID_MWCE_REBUILD_ONLY) 1700 force_full_resync = 1; 1701 1702 mpt->raid_mwce_setting = mwce; 1703 RAID_VOL_FOREACH(mpt, mpt_vol) { 1704 CONFIG_PAGE_RAID_VOL_0 *vol_pg; 1705 int resyncing; 1706 int mwce; 1707 1708 if ((mpt_vol->flags & MPT_RVF_ACTIVE) == 0) 1709 continue; 1710 1711 vol_pg = mpt_vol->config_page; 1712 resyncing = vol_pg->VolumeStatus.Flags 1713 & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS; 1714 mwce = vol_pg->VolumeSettings.Settings 1715 & MPI_RAIDVOL0_SETTING_WRITE_CACHING_ENABLE; 1716 if (force_full_resync && resyncing && mwce) { 1717 1718 /* 1719 * XXX disable/enable volume should force a resync, 1720 * but we'll need to queice, drain, and restart 1721 * I/O to do that. 1722 */ 1723 mpt_vol_prt(mpt, mpt_vol, "WARNING - Unsafe shutdown " 1724 "detected. Suggest full resync.\n"); 1725 } 1726 mpt_verify_mwce(mpt, mpt_vol); 1727 } 1728 mpt->raid_mwce_set = 1; 1729 MPT_UNLOCK(mpt); 1730 return (0); 1731 } 1732 const char *mpt_vol_mwce_strs[] = 1733 { 1734 "On", 1735 "Off", 1736 "On-During-Rebuild", 1737 "NC" 1738 }; 1739 1740 static int 1741 mpt_raid_sysctl_vol_member_wce(SYSCTL_HANDLER_ARGS) 1742 { 1743 char inbuf[20]; 1744 struct mpt_softc *mpt; 1745 const char *str; 1746 int error; 1747 u_int size; 1748 u_int i; 1749 1750 GIANT_REQUIRED; 1751 1752 mpt = (struct mpt_softc *)arg1; 1753 str = mpt_vol_mwce_strs[mpt->raid_mwce_setting]; 1754 error = SYSCTL_OUT(req, str, strlen(str) + 1); 1755 if (error || !req->newptr) { 1756 return (error); 1757 } 1758 1759 size = req->newlen - req->newidx; 1760 if (size >= sizeof(inbuf)) { 1761 return (EINVAL); 1762 } 1763 1764 error = SYSCTL_IN(req, inbuf, size); 1765 if (error) { 1766 return (error); 1767 } 1768 inbuf[size] = '\0'; 1769 for (i = 0; i < NUM_ELEMENTS(mpt_vol_mwce_strs); i++) { 1770 if (strcmp(mpt_vol_mwce_strs[i], inbuf) == 0) { 1771 return (mpt_raid_set_vol_mwce(mpt, i)); 1772 } 1773 } 1774 return (EINVAL); 1775 } 1776 1777 static int 1778 mpt_raid_sysctl_vol_resync_rate(SYSCTL_HANDLER_ARGS) 1779 { 1780 struct mpt_softc *mpt; 1781 u_int raid_resync_rate; 1782 int error; 1783 1784 GIANT_REQUIRED; 1785 1786 mpt = (struct mpt_softc *)arg1; 1787 raid_resync_rate = mpt->raid_resync_rate; 1788 1789 error = sysctl_handle_int(oidp, &raid_resync_rate, 0, req); 1790 if (error || !req->newptr) { 1791 return error; 1792 } 1793 1794 return (mpt_raid_set_vol_resync_rate(mpt, raid_resync_rate)); 1795 } 1796 1797 static int 1798 mpt_raid_sysctl_vol_queue_depth(SYSCTL_HANDLER_ARGS) 1799 { 1800 struct mpt_softc *mpt; 1801 u_int raid_queue_depth; 1802 int error; 1803 1804 GIANT_REQUIRED; 1805 1806 mpt = (struct mpt_softc *)arg1; 1807 raid_queue_depth = mpt->raid_queue_depth; 1808 1809 error = sysctl_handle_int(oidp, &raid_queue_depth, 0, req); 1810 if (error || !req->newptr) { 1811 return error; 1812 } 1813 1814 return (mpt_raid_set_vol_queue_depth(mpt, raid_queue_depth)); 1815 } 1816 1817 static void 1818 mpt_raid_sysctl_attach(struct mpt_softc *mpt) 1819 { 1820 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(mpt->dev); 1821 struct sysctl_oid *tree = device_get_sysctl_tree(mpt->dev); 1822 1823 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 1824 "vol_member_wce", CTLTYPE_STRING | CTLFLAG_RW, mpt, 0, 1825 mpt_raid_sysctl_vol_member_wce, "A", 1826 "volume member WCE(On,Off,On-During-Rebuild,NC)"); 1827 1828 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 1829 "vol_queue_depth", CTLTYPE_INT | CTLFLAG_RW, mpt, 0, 1830 mpt_raid_sysctl_vol_queue_depth, "I", 1831 "default volume queue depth"); 1832 1833 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 1834 "vol_resync_rate", CTLTYPE_INT | CTLFLAG_RW, mpt, 0, 1835 mpt_raid_sysctl_vol_resync_rate, "I", 1836 "volume resync priority (0 == NC, 1 - 255)"); 1837 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 1838 "nonoptimal_volumes", CTLFLAG_RD, 1839 &mpt->raid_nonopt_volumes, 0, 1840 "number of nonoptimal volumes"); 1841 } 1842 #endif 1843