sys/dev/mpt/mpt_raid.c

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