1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2023 Tintri by DDN, Inc. All rights reserved. 14 * Copyright 2019 RackTop Systems, Inc. 15 */ 16 17 /* 18 * Utility routines that have common usage throughout the driver. 19 */ 20 #include <smartpqi.h> 21 22 /* ---- Forward declarations for support/utility functions ---- */ 23 static void reinit_io(pqi_io_request_t *io); 24 static void dump_raid(pqi_state_t *s, void *v, pqi_index_t idx); 25 static void dump_aio(void *v); 26 static void show_error_detail(pqi_state_t *s); 27 static void cmd_start_time(pqi_cmd_t *c); 28 static void cmd_finish_task(void *v); 29 30 31 /* 32 * Entry points for this file 33 */ 34 35 #ifdef DEBUG 36 int pqi_shuffle_delay = 0; 37 #endif /* DEBUG */ 38 39 static void 40 cmd_remove_group(pqi_cmd_t *c) 41 { 42 pqi_io_request_t *io = c->pc_io_rqst; 43 pqi_device_t *d = c->pc_device; 44 45 /* 46 * This would be a good place to send a SCSI TASK MANAGEMENT 47 * command to cancel an individual command, but we don't 48 * have any documentation on the HBA to describe how that 49 * might be done. 50 */ 51 if (io != NULL) { 52 pqi_queue_group_t *qg = io->io_queue_group; 53 int path = io->io_queue_path; 54 55 /* 56 * The lock ordering is such that the driver must drop 57 * the device lock in order to grab the queue lock. 58 * We must also drop the cmd mutex to prevent possible deadlock. 59 */ 60 mutex_exit(&c->pc_mutex); 61 mutex_exit(&d->pd_mutex); 62 mutex_enter(&qg->submit_lock[path]); 63 if (list_link_active(&io->io_list_node)) { 64 list_remove(&qg->request_list[path], io); 65 } 66 mutex_exit(&qg->submit_lock[path]); 67 #ifdef DEBUG 68 if (pqi_shuffle_delay != 0) { /* try to force deadlock error */ 69 pqi_state_t *s = c->pc_softc; 70 pqi_lun_reset(s, d); 71 delay(pqi_shuffle_delay * drv_usectohz(1000000)); 72 } 73 #endif /* DEBUG */ 74 mutex_enter(&d->pd_mutex); 75 mutex_enter(&c->pc_mutex); 76 } 77 } 78 79 pqi_cmd_action_t 80 pqi_cmd_action_nolock(pqi_cmd_t *c, pqi_cmd_action_t a) 81 { 82 pqi_device_t *d = c->pc_device; 83 pqi_state_t *s = c->pc_softc; 84 struct scsi_pkt *pkt; 85 86 mutex_enter(&c->pc_mutex); 87 /* 88 * Don't change cmd if we are in middle of a timeout. 89 */ 90 if ((c->pc_flags & PQI_FLAG_TIMED_OUT) != 0) { 91 a = PQI_CMD_FAIL; 92 goto skipto; 93 } 94 c->pc_last_action = c->pc_cur_action; 95 c->pc_cur_action = a; 96 switch (a) { 97 case PQI_CMD_QUEUE: 98 list_insert_tail(&d->pd_cmd_list, c); 99 100 /* 101 * Set the start time now in case the HBA hangs. That will 102 * allow the timeout processing to handle these commands, which 103 * in theory have been started but not really started, without 104 * the need for special handling logic in the timeout scan. 105 */ 106 cmd_start_time(c); 107 break; 108 109 case PQI_CMD_START: 110 if (c->pc_last_action == PQI_CMD_FAIL) { 111 list_remove(&d->pd_cmd_list, c); 112 113 pkt = CMD2PKT(c); 114 if (pkt == NULL) { 115 pqi_io_request_t *io = c->pc_io_rqst; 116 117 io->io_status = PQI_DATA_IN_OUT_TIMEOUT; 118 (*io->io_cb)(io, io->io_context); 119 pqi_free_io(io); 120 c->pc_io_rqst = NULL; 121 } else { 122 pqi_free_io(c->pc_io_rqst); 123 c->pc_io_rqst = NULL; 124 (void) ddi_taskq_dispatch(s->s_complete_taskq, 125 cmd_finish_task, c, 0); 126 } 127 a = PQI_CMD_FAIL; 128 } else { 129 /* 130 * Now that the command is actually being sent to the 131 * HBA reset the start so that a timeout will occur 132 * only after the HBA has had the command for some 133 * amount of time as defined by the SCSI packet. 134 */ 135 cmd_start_time(c); 136 } 137 break; 138 139 case PQI_CMD_FAIL: 140 if (c->pc_last_action == PQI_CMD_START) { 141 /* 142 * There's no means to cancel a command that has 143 * been passed to the HBA, at least none without more 144 * documentation. So, if the command has been passed 145 * to the HBA the queue slot must remain active until 146 * the command completes. If it fails to complete 147 * then it will be freed by cmd_timeout_scan() when 148 * the action is PQI_CMD_TIMEOUT. So, for now keep 149 * the action as being PQI_CMD_START. 150 */ 151 a = PQI_CMD_START; 152 } else { 153 /* 154 * Don't do any actual processing here to cancel and 155 * free the command. By leaving the pc_cur_action 156 * set to PQI_CMD_FAIL the command will be freed 157 * when pqi_start_io() calls pqi_cmd_action(). The need 158 * for handling the error case in this manner is due 159 * to a small window in pqi_start_io() where the command 160 * has been removed from the group queue and before 161 * pqi_cmd_action() is called. It would be possible 162 * to fix by adding an additional lock to 163 * pqi_io_request_t or handle the issue in this manner. 164 * Less locks == good. 165 */ 166 /* 167 * We could have come in here during a cmd timeout 168 * lock shuffle so last action might be timeout here. 169 */ 170 ASSERT(c->pc_last_action == PQI_CMD_TIMEOUT || 171 c->pc_last_action == PQI_CMD_QUEUE); 172 } 173 break; 174 175 case PQI_CMD_TIMEOUT: 176 list_remove(&d->pd_cmd_list, c); 177 /* 178 * Set a flag to prevent this command from changing while we 179 * shuffle locks below. 180 */ 181 c->pc_flags |= PQI_FLAG_TIMED_OUT; 182 cmd_remove_group(c); 183 184 /* 185 * When a timeout has occurred it means something has gone 186 * wrong with the HBA or drive. Timed out io requests are 187 * marked and the cmd was marked and removed from the chain 188 * above so it should not have changed state when we dropped 189 * and re-grabbed the locks. 190 */ 191 ASSERT3U(c->pc_cur_action, ==, PQI_CMD_TIMEOUT); 192 193 c->pc_flags &= ~PQI_FLAG_TIMED_OUT; 194 /* 195 * Internal commands to the driver will not have a SCSI packet 196 * associated. 197 */ 198 pkt = CMD2PKT(c); 199 if (pkt == NULL) { 200 pqi_io_request_t *io = c->pc_io_rqst; 201 202 io->io_status = PQI_DATA_IN_OUT_TIMEOUT; 203 (*io->io_cb)(io, io->io_context); 204 pqi_free_io(c->pc_io_rqst); 205 c->pc_io_rqst = NULL; 206 } else { 207 pqi_free_io(c->pc_io_rqst); 208 c->pc_io_rqst = NULL; 209 mutex_exit(&c->pc_mutex); 210 (void) ddi_taskq_dispatch(s->s_complete_taskq, 211 cmd_finish_task, c, 0); 212 return (a); 213 } 214 break; 215 216 case PQI_CMD_CMPLT: 217 if (c->pc_last_action == PQI_CMD_TIMEOUT) 218 break; 219 220 list_remove(&d->pd_cmd_list, c); 221 222 pqi_free_io(c->pc_io_rqst); 223 c->pc_io_rqst = NULL; 224 if (CMD2PKT(c) != NULL) { 225 /* 226 * ddi_taskq_dispatch doesn't always start a separate 227 * thread. Under some conditions this will turn into 228 * a direct call to cmd_finish_task(). That in turn 229 * calls into the SCSA layer which can call 230 * tran_ini_pkt which will eventually try to call 231 * pqi_cmd_action(). So, need to drop the mutex before 232 * making the call to ddi_taskq_dispatch and then 233 * return. 234 */ 235 mutex_exit(&c->pc_mutex); 236 (void) ddi_taskq_dispatch(s->s_complete_taskq, 237 cmd_finish_task, c, 0); 238 return (a); 239 } 240 break; 241 242 default: 243 cmn_err(CE_PANIC, 244 "%s: Unknown action request: %d", __func__, a); 245 } 246 skipto: 247 mutex_exit(&c->pc_mutex); 248 return (a); 249 } 250 251 pqi_cmd_action_t 252 pqi_cmd_action(pqi_cmd_t *c, pqi_cmd_action_t a) 253 { 254 pqi_device_t *d = c->pc_device; 255 pqi_cmd_action_t rval; 256 257 mutex_enter(&d->pd_mutex); 258 rval = pqi_cmd_action_nolock(c, a); 259 mutex_exit(&d->pd_mutex); 260 261 return (rval); 262 } 263 264 boolean_t 265 pqi_is_offline(pqi_state_t *s) 266 { 267 return (s->s_offline); 268 } 269 270 /* 271 * pqi_alloc_io -- return next available slot. 272 */ 273 pqi_io_request_t * 274 pqi_alloc_io(pqi_state_t *s) 275 { 276 pqi_io_request_t *io = NULL; 277 uint16_t loop; 278 uint16_t i; 279 280 mutex_enter(&s->s_io_mutex); 281 i = s->s_next_io_slot; /* just a hint */ 282 s->s_io_need++; 283 for (;;) { 284 for (loop = 0; loop < s->s_max_io_slots; loop++) { 285 /* 286 * Controller offline can only occur if the HBA is going 287 * through reset due to firmware hang. 288 */ 289 if (pqi_is_offline(s)) { 290 mutex_exit(&s->s_io_mutex); 291 return (NULL); 292 } 293 io = &s->s_io_rqst_pool[i]; 294 i = (i + 1) % s->s_max_io_slots; 295 if (io->io_refcount == 0) { 296 io->io_refcount = 1; 297 break; 298 } 299 } 300 if (loop != s->s_max_io_slots) 301 break; 302 303 s->s_io_had2wait++; 304 s->s_io_wait_cnt++; 305 if (cv_wait_sig(&s->s_io_condvar, &s->s_io_mutex) == 0) { 306 s->s_io_sig++; 307 io = NULL; 308 break; 309 } 310 i = s->s_next_io_slot; /* just a hint */ 311 } 312 s->s_next_io_slot = i; 313 mutex_exit(&s->s_io_mutex); 314 315 if (io != NULL) 316 reinit_io(io); 317 return (io); 318 } 319 320 void 321 pqi_free_io(pqi_io_request_t *io) 322 { 323 pqi_state_t *s = io->io_softc; 324 325 mutex_enter(&s->s_io_mutex); 326 ASSERT(io->io_refcount == 1); 327 io->io_refcount = 0; 328 reinit_io(io); 329 if (s->s_io_wait_cnt != 0) { 330 s->s_io_wait_cnt--; 331 cv_signal(&s->s_io_condvar); 332 } 333 mutex_exit(&s->s_io_mutex); 334 } 335 336 337 /* 338 * Time out an in progress i/o. 339 * If the i/o has been serviced then return false (can't timeout), 340 * otherwise increment the generation counter and return true. 341 */ 342 boolean_t 343 pqi_timeout_io(pqi_io_request_t *io) 344 { 345 mutex_enter(&io->io_lock); 346 if (io->io_serviced) { 347 /* 348 * Can't timeout this io, it's already been serviced. 349 */ 350 mutex_exit(&io->io_lock); 351 return (B_FALSE); 352 } 353 io->io_gen = (io->io_gen + 1) % PQI_NGENS; 354 mutex_exit(&io->io_lock); 355 return (B_TRUE); 356 } 357 358 /* 359 * Check if an i/o is serviceable (generation counter matches). 360 * If so, mark it as serviced and return true. 361 * Otherwise, return false. 362 */ 363 boolean_t 364 pqi_service_io(pqi_io_request_t *io, uint8_t generation) 365 { 366 mutex_enter(&io->io_lock); 367 if (io->io_gen != generation) { 368 /* 369 * Can't service this io, it's already been timed out. 370 */ 371 mutex_exit(&io->io_lock); 372 return (B_FALSE); 373 } 374 io->io_serviced = B_TRUE; 375 mutex_exit(&io->io_lock); 376 return (B_TRUE); 377 } 378 379 void 380 pqi_dump_io(pqi_io_request_t *io) 381 { 382 pqi_iu_header_t *hdr = io->io_iu; 383 pqi_state_t *s; 384 385 if (io->io_cmd != NULL) { 386 s = io->io_cmd->pc_softc; 387 } else { 388 /* 389 * Early on, during driver attach, commands are run without 390 * a pqi_cmd_t structure associated. These io requests are 391 * low level operations direct to the HBA. So, grab a 392 * reference to the first and only instance through the 393 * DDI interface. Even though there might be multiple HBA's 394 * grabbing the first is okay since dump_raid() only references 395 * the debug level which will be the same for all the 396 * controllers. 397 */ 398 s = ddi_get_soft_state(pqi_state, 0); 399 } 400 401 if (hdr->iu_type == PQI_REQUEST_IU_AIO_PATH_IO) { 402 dump_aio(io->io_iu); 403 } else if (hdr->iu_type == PQI_REQUEST_IU_RAID_PATH_IO) { 404 dump_raid(s, io->io_iu, io->io_pi); 405 } 406 } 407 408 static uint_t supported_event_types[] = { 409 PQI_EVENT_TYPE_HOTPLUG, 410 PQI_EVENT_TYPE_HARDWARE, 411 PQI_EVENT_TYPE_PHYSICAL_DEVICE, 412 PQI_EVENT_TYPE_LOGICAL_DEVICE, 413 PQI_EVENT_TYPE_AIO_STATE_CHANGE, 414 PQI_EVENT_TYPE_AIO_CONFIG_CHANGE, 415 PQI_EVENT_TYPE_HEARTBEAT 416 }; 417 418 int 419 pqi_map_event(uint8_t event) 420 { 421 int i; 422 423 for (i = 0; i < sizeof (supported_event_types) / sizeof (uint_t); i++) 424 if (supported_event_types[i] == event) 425 return (i); 426 return (-1); 427 } 428 429 boolean_t 430 pqi_supported_event(uint8_t event) 431 { 432 return (pqi_map_event(event) == -1 ? B_FALSE : B_TRUE); 433 } 434 435 char * 436 pqi_event_to_str(uint8_t event) 437 { 438 switch (event) { 439 case PQI_EVENT_TYPE_HOTPLUG: return ("Hotplug"); 440 case PQI_EVENT_TYPE_HARDWARE: return ("Hardware"); 441 case PQI_EVENT_TYPE_PHYSICAL_DEVICE: 442 return ("Physical Device"); 443 case PQI_EVENT_TYPE_LOGICAL_DEVICE: return ("logical Device"); 444 case PQI_EVENT_TYPE_AIO_STATE_CHANGE: 445 return ("AIO State Change"); 446 case PQI_EVENT_TYPE_AIO_CONFIG_CHANGE: 447 return ("AIO Config Change"); 448 case PQI_EVENT_TYPE_HEARTBEAT: return ("Heartbeat"); 449 default: return ("Unsupported Event Type"); 450 } 451 } 452 453 char * 454 bool_to_str(int v) 455 { 456 return (v ? "T" : "f"); 457 } 458 459 char * 460 dtype_to_str(int t) 461 { 462 switch (t) { 463 case DTYPE_DIRECT: return ("Direct"); 464 case DTYPE_SEQUENTIAL: return ("Sequential"); 465 case DTYPE_ESI: return ("ESI"); 466 case DTYPE_ARRAY_CTRL: return ("RAID"); 467 default: return ("Ughknown"); 468 } 469 } 470 471 static ddi_dma_attr_t single_dma_attrs = { 472 .dma_attr_version = DMA_ATTR_V0, 473 .dma_attr_addr_lo = 0x0ull, 474 .dma_attr_addr_hi = 0xffffffffffffffffull, 475 .dma_attr_count_max = 0x7ffffull, 476 .dma_attr_align = 4096, 477 .dma_attr_burstsizes = 0x78, 478 .dma_attr_minxfer = 1, 479 .dma_attr_maxxfer = 0x007ffffull, 480 .dma_attr_seg = 0xffffffffull, 481 .dma_attr_sgllen = 1, 482 .dma_attr_granular = 512, 483 .dma_attr_flags = 0, 484 }; 485 486 pqi_dma_overhead_t * 487 pqi_alloc_single(pqi_state_t *s, size_t len) 488 { 489 pqi_dma_overhead_t *d; 490 ddi_dma_cookie_t cookie; 491 492 d = kmem_zalloc(sizeof (*d), KM_SLEEP); 493 d->len_to_alloc = len; 494 495 if (ddi_dma_alloc_handle(s->s_dip, &single_dma_attrs, 496 DDI_DMA_SLEEP, 0, &d->handle) != DDI_SUCCESS) 497 goto error_out; 498 499 if (ddi_dma_mem_alloc(d->handle, len, &s->s_reg_acc_attr, 500 DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, 0, 501 &d->alloc_memory, &len, &d->acc) != DDI_SUCCESS) 502 goto error_out; 503 504 bzero(d->alloc_memory, len); 505 if (ddi_dma_addr_bind_handle(d->handle, NULL, d->alloc_memory, len, 506 DDI_DMA_RDWR, DDI_DMA_SLEEP, 0, &cookie, &d->cookie_count) != 507 DDI_SUCCESS) 508 goto error_out; 509 510 d->dma_addr = cookie.dmac_laddress; 511 if (d->cookie_count != 1) 512 ddi_dma_nextcookie(d->handle, &d->second); 513 514 return (d); 515 516 error_out: 517 pqi_free_single(s, d); 518 return (NULL); 519 } 520 521 void 522 pqi_free_single(pqi_state_t *s __unused, pqi_dma_overhead_t *d) 523 { 524 (void) ddi_dma_unbind_handle(d->handle); 525 if (d->alloc_memory != NULL) 526 ddi_dma_mem_free(&d->acc); 527 if (d->handle != NULL) 528 ddi_dma_free_handle(&d->handle); 529 kmem_free(d, sizeof (*d)); 530 } 531 532 void 533 pqi_show_dev_state(pqi_state_t *s) 534 { 535 uint32_t dev_status = G32(s, pqi_registers.device_status); 536 537 switch (dev_status & 0xf) { 538 case 0: 539 cmn_err(CE_NOTE, "Power_On_And_Reset"); 540 break; 541 542 case 1: 543 cmn_err(CE_NOTE, "PQI_Status_Available"); 544 break; 545 546 case 2: 547 cmn_err(CE_NOTE, "All_Registers_Ready"); 548 break; 549 550 case 3: 551 cmn_err(CE_NOTE, 552 "Adminstrator_Queue_Pair_Ready"); 553 break; 554 555 case 4: 556 cmn_err(CE_NOTE, "Error: %s %s", 557 dev_status & 0x100 ? "(OP OQ Error)" : "", 558 dev_status & 0x200 ? "(OP IQ Error)" : ""); 559 show_error_detail(s); 560 break; 561 562 default: 563 cmn_err(CE_WARN, "Unknown HBA status: 0x%x", dev_status); 564 break; 565 } 566 } 567 568 char * 569 cdb_to_str(uint8_t scsi_cmd) 570 { 571 switch (scsi_cmd) { 572 case SCMD_INQUIRY: return ("Inquiry"); 573 case SCMD_TEST_UNIT_READY: return ("TestUnitReady"); 574 case SCMD_READ: return ("Read"); 575 case SCMD_READ_G1: return ("Read G1"); 576 case SCMD_RESERVE: return ("Reserve"); 577 case SCMD_RELEASE: return ("Release"); 578 case SCMD_WRITE: return ("Write"); 579 case SCMD_WRITE_G1: return ("Write G1"); 580 case SCMD_START_STOP: return ("StartStop"); 581 case SCMD_READ_CAPACITY: return ("ReadCap"); 582 case SCMD_MODE_SENSE: return ("ModeSense"); 583 case SCMD_MODE_SELECT: return ("ModeSelect"); 584 case SCMD_SVC_ACTION_IN_G4: return ("ActionInG4"); 585 case SCMD_MAINTENANCE_IN: return ("MaintenanceIn"); 586 case SCMD_GDIAG: return ("ReceiveDiag"); 587 case SCMD_SDIAG: return ("SendDiag"); 588 case SCMD_LOG_SENSE_G1: return ("LogSenseG1"); 589 case SCMD_PERSISTENT_RESERVE_IN: return ("PgrReserveIn"); 590 case SCMD_PERSISTENT_RESERVE_OUT: return ("PgrReserveOut"); 591 case BMIC_READ: return ("BMIC Read"); 592 case BMIC_WRITE: return ("BMIC Write"); 593 case CISS_REPORT_LOG: return ("CISS Report Logical"); 594 case CISS_REPORT_PHYS: return ("CISS Report Physical"); 595 default: return ("unmapped"); 596 } 597 } 598 599 char * 600 io_status_to_str(int val) 601 { 602 switch (val) { 603 case PQI_DATA_IN_OUT_GOOD: return ("Good"); 604 case PQI_DATA_IN_OUT_UNDERFLOW: return ("Underflow"); 605 case PQI_DATA_IN_OUT_ERROR: return ("ERROR"); 606 case PQI_DATA_IN_OUT_PROTOCOL_ERROR: return ("Protocol Error"); 607 case PQI_DATA_IN_OUT_HARDWARE_ERROR: return ("Hardware Error"); 608 default: return ("UNHANDLED"); 609 } 610 } 611 612 char * 613 scsi_status_to_str(uint8_t val) 614 { 615 switch (val) { 616 case STATUS_GOOD: return ("Good"); 617 case STATUS_CHECK: return ("Check"); 618 case STATUS_MET: return ("Met"); 619 case STATUS_BUSY: return ("Busy"); 620 case STATUS_INTERMEDIATE: return ("Intermediate"); 621 case STATUS_RESERVATION_CONFLICT: return ("Reservation Conflict"); 622 case STATUS_TERMINATED: return ("Terminated"); 623 case STATUS_QFULL: return ("QFull"); 624 case STATUS_ACA_ACTIVE: return ("ACA Active"); 625 case STATUS_TASK_ABORT: return ("Task Abort"); 626 default: return ("Illegal Status"); 627 } 628 } 629 630 char * 631 iu_type_to_str(int val) 632 { 633 switch (val) { 634 case PQI_RESPONSE_IU_RAID_PATH_IO_SUCCESS: return ("Success"); 635 case PQI_RESPONSE_IU_AIO_PATH_IO_SUCCESS: return ("AIO Success"); 636 case PQI_RESPONSE_IU_GENERAL_MANAGEMENT: return ("General"); 637 case PQI_RESPONSE_IU_RAID_PATH_IO_ERROR: return ("IO Error"); 638 case PQI_RESPONSE_IU_AIO_PATH_IO_ERROR: return ("AIO IO Error"); 639 case PQI_RESPONSE_IU_AIO_PATH_DISABLED: return ("AIO Path Disabled"); 640 default: return ("UNHANDLED"); 641 } 642 } 643 644 void 645 pqi_free_mem_len(mem_len_pair_t *m) 646 { 647 kmem_free(m->mem, m->len); 648 } 649 650 mem_len_pair_t 651 pqi_alloc_mem_len(int len) 652 { 653 mem_len_pair_t m; 654 m.len = len; 655 m.mem = kmem_alloc(m.len, KM_SLEEP); 656 *m.mem = '\0'; 657 return (m); 658 } 659 660 /* 661 * []------------------------------------------------------------------[] 662 * | Support/utility functions for main functions above | 663 * []------------------------------------------------------------------[] 664 */ 665 666 typedef struct qual { 667 int q_val; 668 char *q_str; 669 } qual_t; 670 671 typedef struct code_qual { 672 int cq_code; 673 qual_t *cq_list; 674 } code_qual_t; 675 676 /* 677 * These messages come from pqi2r01 spec section 5.6 table 18. 678 */ 679 static qual_t pair0[] = { {0, "No error"}, {0, NULL} }; 680 static qual_t pair1[] = { {0, "Error detected during initialization"}, 681 { 0, NULL } }; 682 static qual_t pair2[] = { {1, "Invalid PD Function"}, 683 {2, "Invalid paramter for PD function"}, 684 {0, NULL } }; 685 static qual_t pair3[] = { {0, "Error creating admin queue pair"}, 686 { 1, "Error deleting admin queue pair"}, 687 { 0, NULL} }; 688 static qual_t pair4[] = { {1, "Invalid IU type in general" }, 689 {2, "Invalid IU length in general admin request"}, 690 {0, NULL} }; 691 static qual_t pair5[] = { {1, "Internal error" }, 692 {2, "OQ spanning conflict"}, 693 {0, NULL} }; 694 static qual_t pair6[] = { {1, "Error completing PQI soft reset"}, 695 {2, "Error completing PQI firmware reset"}, 696 {3, "Error completing PQI hardware reset"}, 697 {0, NULL} }; 698 static code_qual_t cq_table[] = { 699 { 0, pair0 }, 700 { 1, pair1 }, 701 { 2, pair2 }, 702 { 3, pair3 }, 703 { 4, pair4 }, 704 { 5, pair5 }, 705 { 6, pair6 }, 706 { 0, NULL }, 707 }; 708 709 /* 710 * cmd_finish_task -- taskq to complete command processing 711 * 712 * Under high load the driver will run out of IO slots which causes command 713 * requests to pause until a slot is free. Calls to pkt_comp below can circle 714 * through the SCSI layer and back into the driver to start another command 715 * request and therefore possibly pause. If cmd_finish_task() was called on 716 * the interrupt thread a hang condition could occur because IO slots wouldn't 717 * be processed and then freed. So, this portion of the command completion 718 * is run on a taskq. 719 */ 720 static void 721 cmd_finish_task(void *v) 722 { 723 pqi_cmd_t *c = v; 724 struct scsi_pkt *pkt = CMD2PKT(c); 725 726 if (c->pc_poll) 727 sema_v(c->pc_poll); 728 729 if (pkt != NULL && (pkt->pkt_flags & FLAG_NOINTR) == 0 && 730 (pkt->pkt_comp != NULL)) 731 (*pkt->pkt_comp)(pkt); 732 } 733 734 static void 735 cmd_start_time(pqi_cmd_t *c) 736 { 737 c->pc_start_time = gethrtime(); 738 if (CMD2PKT(c) != NULL) { 739 c->pc_expiration = c->pc_start_time + 740 ((hrtime_t)c->pc_pkt->pkt_time * NANOSEC); 741 } else { 742 c->pc_expiration = c->pc_start_time + 5 * NANOSEC; 743 } 744 } 745 746 static void 747 show_error_detail(pqi_state_t *s) 748 { 749 uint32_t error_reg = G32(s, pqi_registers.device_error); 750 uint8_t code, qualifier; 751 qual_t *p; 752 code_qual_t *cq; 753 754 code = error_reg & 0xff; 755 qualifier = (error_reg >> 8) & 0xff; 756 757 for (cq = cq_table; cq->cq_list != NULL; cq++) { 758 if (cq->cq_code == code) { 759 for (p = cq->cq_list; p->q_str != NULL; p++) { 760 if (p->q_val == qualifier) { 761 cmn_err(CE_NOTE, 762 "[code=%x,qual=%x]: %s", 763 code, qualifier, p->q_str); 764 return; 765 } 766 } 767 } 768 } 769 cmn_err(CE_NOTE, "Undefined code(%x)/qualifier(%x)", 770 code, qualifier); 771 } 772 773 static void 774 pqi_catch_release(pqi_io_request_t *io __unused, void *v __unused) 775 { 776 /* 777 * This call can occur if the software times out a command because 778 * the HBA hasn't responded in the default amount of time, 10 seconds, 779 * and then the HBA responds. It's occurred a few times during testing 780 * so catch and ignore. 781 */ 782 cmn_err(CE_NOTE, "%s: caught", __func__); 783 } 784 785 static void 786 reinit_io(pqi_io_request_t *io) 787 { 788 io->io_cb = pqi_catch_release; 789 io->io_status = 0; 790 io->io_serviced = B_FALSE; 791 io->io_error_info = NULL; 792 io->io_raid_bypass = B_FALSE; 793 io->io_context = NULL; 794 io->io_cmd = NULL; 795 } 796 797 mem_len_pair_t 798 build_cdb_str(uint8_t *cdb) 799 { 800 mem_len_pair_t m = pqi_alloc_mem_len(64); 801 802 m.mem[0] = '\0'; 803 804 switch (cdb[0]) { 805 case SCMD_INQUIRY: 806 MEMP("%s", cdb_to_str(cdb[0])); 807 if ((cdb[1] & 0x1) != 0) 808 MEMP(".vpd=%x", cdb[2]); 809 else if (cdb[2]) 810 MEMP("Illegal CDB"); 811 MEMP(".len=%x", cdb[3] << 8 | cdb[4]); 812 break; 813 814 case SCMD_READ: 815 MEMP("%s.lba=%x.len=%x", cdb_to_str(cdb[0]), 816 (cdb[1] & 0x1f) << 16 | cdb[2] << 8 | cdb[3], 817 cdb[4]); 818 break; 819 820 case SCMD_MODE_SENSE: 821 MEMP("%s.dbd=%s.pc=%x.page_code=%x.subpage=%x." 822 "len=%x", cdb_to_str(cdb[0]), 823 bool_to_str(cdb[1] & 8), cdb[2] >> 6 & 0x3, 824 cdb[2] & 0x3f, cdb[3], cdb[4]); 825 break; 826 827 case SCMD_START_STOP: 828 MEMP("%s.immed=%s.power=%x.start=%s", 829 cdb_to_str(cdb[0]), bool_to_str(cdb[1] & 1), 830 (cdb[4] >> 4) & 0xf, bool_to_str(cdb[4] & 1)); 831 break; 832 833 case SCMD_SVC_ACTION_IN_G4: 834 case SCMD_READ_CAPACITY: 835 case SCMD_TEST_UNIT_READY: 836 default: 837 MEMP("%s (%x)", cdb_to_str(cdb[0]), cdb[0]); 838 break; 839 } 840 return (m); 841 } 842 843 mem_len_pair_t 844 mem_to_arraystr(uint8_t *ptr, size_t len) 845 { 846 mem_len_pair_t m = pqi_alloc_mem_len(len * 3 + 20); 847 int i; 848 849 m.mem[0] = '\0'; 850 MEMP("{ "); 851 for (i = 0; i < len; i++) { 852 MEMP("%02x ", *ptr++ & 0xff); 853 } 854 MEMP(" }"); 855 856 return (m); 857 } 858 859 static char lun_str[64]; 860 static char * 861 lun_to_str(uint8_t *lun) 862 { 863 int i; 864 lun_str[0] = '\0'; 865 for (i = 0; i < 8; i++) 866 (void) snprintf(lun_str + strlen(lun_str), 867 sizeof (lun_str) - strlen(lun_str), "%02x.", *lun++); 868 return (lun_str); 869 } 870 871 static char * 872 dir_to_str(int dir) 873 { 874 switch (dir) { 875 case SOP_NO_DIRECTION_FLAG: return ("NoDir"); 876 case SOP_WRITE_FLAG: return ("Write"); 877 case SOP_READ_FLAG: return ("Read"); 878 case SOP_BIDIRECTIONAL: return ("RW"); 879 default: return ("Oops"); 880 } 881 } 882 883 static char * 884 flags_to_str(uint32_t flag) 885 { 886 switch (flag) { 887 case CISS_SG_LAST: return ("Last"); 888 case CISS_SG_CHAIN: return ("Chain"); 889 case CISS_SG_NORMAL: return ("Norm"); 890 default: return ("Ooops"); 891 } 892 } 893 894 /* ---- Only for use in dump_raid and dump_aio ---- */ 895 #define SCRATCH_PRINT(args...) (void)snprintf(scratch + strlen(scratch), \ 896 len - strlen(scratch), args) 897 898 static void 899 dump_raid(pqi_state_t *s, void *v, pqi_index_t idx) 900 { 901 int i; 902 int len = 512; 903 caddr_t scratch; 904 pqi_raid_path_request_t *rqst = v; 905 mem_len_pair_t cdb_data; 906 caddr_t raw = v; 907 908 scratch = kmem_alloc(len, KM_SLEEP); 909 scratch[0] = '\0'; 910 911 if (s->s_debug_level & DBG_LVL_RAW_RQST) { 912 SCRATCH_PRINT("RAW RQST: "); 913 for (i = 0; i < sizeof (*rqst); i++) 914 SCRATCH_PRINT("%02x:", *raw++ & 0xff); 915 cmn_err(CE_NOTE, "%s", scratch); 916 scratch[0] = '\0'; 917 } 918 919 if (s->s_debug_level & DBG_LVL_CDB) { 920 cdb_data = build_cdb_str(rqst->rp_cdb); 921 SCRATCH_PRINT("cdb(%s),", cdb_data.mem); 922 pqi_free_mem_len(&cdb_data); 923 } 924 925 ASSERT0(rqst->header.reserved); 926 ASSERT0(rqst->reserved1); 927 ASSERT0(rqst->reserved2); 928 ASSERT0(rqst->reserved3); 929 ASSERT0(rqst->reserved4); 930 ASSERT0(rqst->reserved5); 931 932 if (s->s_debug_level & DBG_LVL_RQST) { 933 SCRATCH_PRINT("pi=%x,h(type=%x,len=%x,id=%x)", idx, 934 rqst->header.iu_type, rqst->header.iu_length, 935 rqst->header.iu_id); 936 SCRATCH_PRINT("rqst_id=%x,nexus_id=%x,len=%x,lun=(%s)," 937 "proto=%x,dir=%s,partial=%s,", 938 rqst->rp_id, rqst->rp_nexus_id, rqst->rp_data_len, 939 lun_to_str(rqst->rp_lun), rqst->protocol_specific, 940 dir_to_str(rqst->rp_data_dir), 941 bool_to_str(rqst->rp_partial)); 942 SCRATCH_PRINT("fence=%s,error_idx=%x,task_attr=%x," 943 "priority=%x,additional=%x,sg=(", 944 bool_to_str(rqst->rp_fence), rqst->rp_error_index, 945 rqst->rp_task_attr, 946 rqst->rp_pri, rqst->rp_additional_cdb); 947 for (i = 0; i < PQI_MAX_EMBEDDED_SG_DESCRIPTORS; i++) { 948 SCRATCH_PRINT("%lx:%x:%s,", 949 (long unsigned int)rqst->rp_sglist[i].sg_addr, 950 rqst->rp_sglist[i].sg_len, 951 flags_to_str(rqst->rp_sglist[i].sg_flags)); 952 } 953 SCRATCH_PRINT(")"); 954 } 955 956 cmn_err(CE_NOTE, "%s", scratch); 957 kmem_free(scratch, len); 958 } 959 960 static void 961 dump_aio(void *v) 962 { 963 pqi_aio_path_request_t *rqst = v; 964 int i; 965 int len = 512; 966 caddr_t scratch; 967 mem_len_pair_t cdb_data; 968 969 scratch = kmem_alloc(len, KM_SLEEP); 970 scratch[0] = '\0'; 971 972 cdb_data = build_cdb_str(rqst->cdb); 973 SCRATCH_PRINT("cdb(%s)", cdb_data.mem); 974 pqi_free_mem_len(&cdb_data); 975 976 SCRATCH_PRINT("h(type=%x,len=%x,id=%x)", 977 rqst->header.iu_type, rqst->header.iu_length, 978 rqst->header.iu_id); 979 SCRATCH_PRINT("rqst_id=%x,nexus_id=%x,len=%x,lun=(%s),dir=%s," 980 "partial=%s,", 981 rqst->request_id, rqst->nexus_id, rqst->buffer_length, 982 lun_to_str(rqst->lun_number), 983 dir_to_str(rqst->data_direction), bool_to_str(rqst->partial)); 984 SCRATCH_PRINT("fence=%s,error_idx=%x,task_attr=%x,priority=%x," 985 "num_sg=%x,cdb_len=%x,sg=(", 986 bool_to_str(rqst->fence), rqst->error_index, rqst->task_attribute, 987 rqst->command_priority, rqst->num_sg_descriptors, rqst->cdb_length); 988 for (i = 0; i < PQI_MAX_EMBEDDED_SG_DESCRIPTORS; i++) { 989 SCRATCH_PRINT("%lx:%x:%s,", 990 (long unsigned int)rqst->ap_sglist[i].sg_addr, 991 rqst->ap_sglist[i].sg_len, 992 flags_to_str(rqst->ap_sglist[i].sg_flags)); 993 } 994 SCRATCH_PRINT(")"); 995 996 cmn_err(CE_NOTE, "%s", scratch); 997 kmem_free(scratch, len); 998 } 999