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 2018 Nexenta Systems, Inc. 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 char *cmd_state_str(pqi_cmd_state_t state); 25 static void dump_raid(pqi_state_t s, void *v, pqi_index_t idx); 26 static void dump_aio(void *v); 27 static void show_error_detail(pqi_state_t s); 28 static void cmd_finish_task(void *v); 29 30 /* 31 * []------------------------------------------------------------------[] 32 * | Entry points for this file | 33 * []------------------------------------------------------------------[] 34 */ 35 36 int 37 pqi_is_offline(pqi_state_t s) 38 { 39 return (s->s_offline); 40 } 41 42 /* 43 * pqi_alloc_io -- return next available slot. 44 */ 45 pqi_io_request_t * 46 pqi_alloc_io(pqi_state_t s) 47 { 48 pqi_io_request_t *io = NULL; 49 uint16_t loop; 50 uint16_t i; 51 52 mutex_enter(&s->s_io_mutex); 53 i = s->s_next_io_slot; /* just a hint */ 54 s->s_io_need++; 55 for (;;) { 56 for (loop = 0; loop < s->s_max_io_slots; loop++) { 57 io = &s->s_io_rqst_pool[i]; 58 i = (i + 1) % s->s_max_io_slots; 59 if (io->io_refcount == 0) { 60 io->io_refcount = 1; 61 break; 62 } 63 } 64 if (loop != s->s_max_io_slots) 65 break; 66 67 s->s_io_had2wait++; 68 s->s_io_wait_cnt++; 69 if (cv_wait_sig(&s->s_io_condvar, &s->s_io_mutex) == 0) { 70 s->s_io_sig++; 71 io = NULL; 72 break; 73 } 74 i = s->s_next_io_slot; /* just a hint */ 75 } 76 s->s_next_io_slot = i; 77 mutex_exit(&s->s_io_mutex); 78 79 if (io != NULL) 80 reinit_io(io); 81 return (io); 82 } 83 84 void 85 pqi_free_io(pqi_io_request_t *io) 86 { 87 pqi_state_t s = io->io_softc; 88 89 mutex_enter(&s->s_io_mutex); 90 ASSERT(io->io_refcount == 1); 91 io->io_refcount = 0; 92 reinit_io(io); 93 if (s->s_io_wait_cnt != 0) { 94 s->s_io_wait_cnt--; 95 cv_signal(&s->s_io_condvar); 96 } 97 mutex_exit(&s->s_io_mutex); 98 } 99 100 101 void 102 pqi_dump_io(pqi_io_request_t *io) 103 { 104 pqi_iu_header_t *hdr = io->io_iu; 105 pqi_state_t s; 106 107 if (io->io_cmd != NULL) { 108 s = io->io_cmd->pc_softc; 109 } else { 110 /* 111 * Early on, during driver attach, commands are run without 112 * a pqi_cmd_t structure associated. These io requests are 113 * low level operations direct to the HBA. So, grab a 114 * reference to the first and only instance through the 115 * DDI interface. Even though there might be multiple HBA's 116 * grabbing the first is okay since dump_raid() only references 117 * the debug level which will be the same for all the 118 * controllers. 119 */ 120 s = ddi_get_soft_state(pqi_state, 0); 121 } 122 123 if (hdr->iu_type == PQI_REQUEST_IU_AIO_PATH_IO) { 124 dump_aio(io->io_iu); 125 } else if (hdr->iu_type == PQI_REQUEST_IU_RAID_PATH_IO) { 126 dump_raid(s, io->io_iu, io->io_pi); 127 } 128 } 129 130 /* 131 * pqi_cmd_sm -- state machine for command 132 * 133 * NOTE: PQI_CMD_CMPLT and PQI_CMD_FATAL will drop the pd_mutex and regain 134 * it even if grab_lock==B_FALSE. 135 */ 136 void 137 pqi_cmd_sm(pqi_cmd_t cmd, pqi_cmd_state_t new_state, boolean_t grab_lock) 138 { 139 pqi_device_t devp = cmd->pc_device; 140 pqi_state_t s = cmd->pc_softc; 141 142 if (cmd->pc_softc->s_debug_level & DBG_LVL_STATE) { 143 cmn_err(CE_NOTE, "%s: cmd=%p (%s) -> (%s)\n", __func__, 144 (void *)cmd, cmd_state_str(cmd->pc_cmd_state), 145 cmd_state_str(new_state)); 146 } 147 cmd->pc_last_state = cmd->pc_cmd_state; 148 cmd->pc_cmd_state = new_state; 149 switch (new_state) { 150 case PQI_CMD_UNINIT: 151 break; 152 153 case PQI_CMD_CONSTRUCT: 154 break; 155 156 case PQI_CMD_INIT: 157 break; 158 159 case PQI_CMD_QUEUED: 160 if (cmd->pc_last_state == PQI_CMD_STARTED) 161 break; 162 if (grab_lock == B_TRUE) 163 mutex_enter(&devp->pd_mutex); 164 cmd->pc_start_time = gethrtime(); 165 cmd->pc_expiration = cmd->pc_start_time + 166 ((hrtime_t)cmd->pc_pkt->pkt_time * NANOSEC); 167 devp->pd_active_cmds++; 168 atomic_inc_32(&s->s_cmd_queue_len); 169 list_insert_tail(&devp->pd_cmd_list, cmd); 170 if (grab_lock == B_TRUE) 171 mutex_exit(&devp->pd_mutex); 172 break; 173 174 case PQI_CMD_STARTED: 175 if (s->s_debug_level & (DBG_LVL_CDB | DBG_LVL_RQST)) 176 pqi_dump_io(cmd->pc_io_rqst); 177 break; 178 179 case PQI_CMD_CMPLT: 180 if (grab_lock == B_TRUE) 181 mutex_enter(&devp->pd_mutex); 182 183 if ((cmd->pc_flags & PQI_FLAG_ABORTED) == 0) { 184 list_remove(&devp->pd_cmd_list, cmd); 185 186 devp->pd_active_cmds--; 187 atomic_dec_32(&s->s_cmd_queue_len); 188 pqi_free_io(cmd->pc_io_rqst); 189 190 cmd->pc_flags &= ~PQI_FLAG_FINISHING; 191 (void) ddi_taskq_dispatch(s->s_complete_taskq, 192 cmd_finish_task, cmd, 0); 193 } 194 195 if (grab_lock == B_TRUE) 196 mutex_exit(&devp->pd_mutex); 197 198 break; 199 200 case PQI_CMD_FATAL: 201 if ((cmd->pc_last_state == PQI_CMD_QUEUED) || 202 (cmd->pc_last_state == PQI_CMD_STARTED)) { 203 if (grab_lock == B_TRUE) 204 mutex_enter(&devp->pd_mutex); 205 206 cmd->pc_flags |= PQI_FLAG_ABORTED; 207 208 /* 209 * If this call came from aio_io_complete() when 210 * dealing with a drive offline the flags will contain 211 * PQI_FLAG_FINISHING so just clear it here to be 212 * safe. 213 */ 214 cmd->pc_flags &= ~PQI_FLAG_FINISHING; 215 216 list_remove(&devp->pd_cmd_list, cmd); 217 218 devp->pd_active_cmds--; 219 atomic_dec_32(&s->s_cmd_queue_len); 220 if (cmd->pc_io_rqst) 221 pqi_free_io(cmd->pc_io_rqst); 222 223 (void) ddi_taskq_dispatch(s->s_complete_taskq, 224 cmd_finish_task, cmd, 0); 225 226 if (grab_lock == B_TRUE) 227 mutex_exit(&devp->pd_mutex); 228 } 229 break; 230 231 case PQI_CMD_DESTRUCT: 232 if (grab_lock == B_TRUE) 233 mutex_enter(&devp->pd_mutex); 234 235 if (list_link_active(&cmd->pc_list)) { 236 list_remove(&devp->pd_cmd_list, cmd); 237 devp->pd_active_cmds--; 238 if (cmd->pc_io_rqst) 239 pqi_free_io(cmd->pc_io_rqst); 240 } 241 242 if (grab_lock == B_TRUE) 243 mutex_exit(&devp->pd_mutex); 244 break; 245 246 default: 247 /* 248 * Normally a panic or ASSERT(0) would be called 249 * for here. Except that in this case the 'cmd' 250 * memory could be coming from the kmem_cache pool 251 * which during debug gets wiped with 0xbaddcafe 252 */ 253 break; 254 } 255 } 256 257 258 static uint_t supported_event_types[] = { 259 PQI_EVENT_TYPE_HOTPLUG, 260 PQI_EVENT_TYPE_HARDWARE, 261 PQI_EVENT_TYPE_PHYSICAL_DEVICE, 262 PQI_EVENT_TYPE_LOGICAL_DEVICE, 263 PQI_EVENT_TYPE_AIO_STATE_CHANGE, 264 PQI_EVENT_TYPE_AIO_CONFIG_CHANGE, 265 PQI_EVENT_TYPE_HEARTBEAT 266 }; 267 268 int 269 pqi_map_event(uint8_t event) 270 { 271 int i; 272 273 for (i = 0; i < sizeof (supported_event_types) / sizeof (uint_t); i++) 274 if (supported_event_types[i] == event) 275 return (i); 276 return (-1); 277 } 278 279 boolean_t 280 pqi_supported_event(uint8_t event) 281 { 282 return (pqi_map_event(event) == -1 ? B_FALSE : B_TRUE); 283 } 284 285 char * 286 pqi_event_to_str(uint8_t event) 287 { 288 switch (event) { 289 case PQI_EVENT_TYPE_HOTPLUG: return ("Hotplug"); 290 case PQI_EVENT_TYPE_HARDWARE: return ("Hardware"); 291 case PQI_EVENT_TYPE_PHYSICAL_DEVICE: 292 return ("Physical Device"); 293 case PQI_EVENT_TYPE_LOGICAL_DEVICE: return ("logical Device"); 294 case PQI_EVENT_TYPE_AIO_STATE_CHANGE: 295 return ("AIO State Change"); 296 case PQI_EVENT_TYPE_AIO_CONFIG_CHANGE: 297 return ("AIO Config Change"); 298 case PQI_EVENT_TYPE_HEARTBEAT: return ("Heartbeat"); 299 default: return ("Unsupported Event Type"); 300 } 301 } 302 303 char * 304 bool_to_str(int v) 305 { 306 return (v ? "T" : "f"); 307 } 308 309 char * 310 dtype_to_str(int t) 311 { 312 switch (t) { 313 case DTYPE_DIRECT: return ("Direct"); 314 case DTYPE_SEQUENTIAL: return ("Sequential"); 315 case DTYPE_ESI: return ("ESI"); 316 case DTYPE_ARRAY_CTRL: return ("RAID"); 317 default: return ("Ughknown"); 318 } 319 } 320 321 static ddi_dma_attr_t single_dma_attrs = { 322 DMA_ATTR_V0, /* attribute layout version */ 323 0x0ull, /* address low - should be 0 (longlong) */ 324 0xffffffffffffffffull, /* address high - 64-bit max */ 325 0x7ffffull, /* count max - max DMA object size */ 326 4096, /* allocation alignment requirements */ 327 0x78, /* burstsizes - binary encoded values */ 328 1, /* minxfer - gran. of DMA engine */ 329 0x007ffffull, /* maxxfer - gran. of DMA engine */ 330 0xffffffffull, /* max segment size (DMA boundary) */ 331 1, /* For pqi_alloc_single must be contig memory */ 332 512, /* granularity - device transfer size */ 333 0 /* flags, set to 0 */ 334 }; 335 336 pqi_dma_overhead_t * 337 pqi_alloc_single(pqi_state_t s, size_t len) 338 { 339 pqi_dma_overhead_t *d; 340 ddi_dma_cookie_t cookie; 341 342 d = kmem_zalloc(sizeof (*d), KM_SLEEP); 343 d->len_to_alloc = len; 344 345 if (ddi_dma_alloc_handle(s->s_dip, &single_dma_attrs, 346 DDI_DMA_SLEEP, 0, &d->handle) != DDI_SUCCESS) 347 goto error_out; 348 349 if (ddi_dma_mem_alloc(d->handle, len, &s->s_reg_acc_attr, 350 DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, 0, 351 &d->alloc_memory, &len, &d->acc) != DDI_SUCCESS) 352 goto error_out; 353 354 (void) memset(d->alloc_memory, 0, len); 355 if (ddi_dma_addr_bind_handle(d->handle, NULL, d->alloc_memory, len, 356 DDI_DMA_RDWR, DDI_DMA_SLEEP, 0, &cookie, &d->cookie_count) != 357 DDI_SUCCESS) 358 goto error_out; 359 360 d->dma_addr = cookie.dmac_laddress; 361 if (d->cookie_count != 1) 362 ddi_dma_nextcookie(d->handle, &d->second); 363 364 return (d); 365 366 error_out: 367 pqi_free_single(s, d); 368 return (NULL); 369 } 370 371 void 372 pqi_free_single(pqi_state_t s, pqi_dma_overhead_t *d) 373 { 374 (void) ddi_dma_unbind_handle(d->handle); 375 if (d->alloc_memory != NULL) 376 ddi_dma_mem_free(&d->acc); 377 if (d->handle != NULL) 378 ddi_dma_free_handle(&d->handle); 379 ASSERT(s->s_dip != NULL); 380 kmem_free(d, sizeof (*d)); 381 } 382 383 void 384 pqi_show_dev_state(pqi_state_t s) 385 { 386 uint32_t dev_status = G32(s, pqi_registers.device_status); 387 388 switch (dev_status & 0xf) { 389 case 0: 390 cmn_err(CE_NOTE, "Power_On_And_Reset\n"); 391 break; 392 393 case 1: 394 cmn_err(CE_NOTE, "PQI_Status_Available\n"); 395 break; 396 397 case 2: 398 cmn_err(CE_NOTE, "All_Registers_Ready\n"); 399 break; 400 401 case 3: 402 cmn_err(CE_NOTE, 403 "Adminstrator_Queue_Pair_Ready\n"); 404 break; 405 406 case 4: 407 cmn_err(CE_NOTE, "Error: %s %s\n", 408 dev_status & 0x100 ? "(OP OQ Error)" : "", 409 dev_status & 0x200 ? "(OP IQ Error)" : ""); 410 show_error_detail(s); 411 break; 412 } 413 } 414 415 char * 416 cdb_to_str(uint8_t scsi_cmd) 417 { 418 switch (scsi_cmd) { 419 case SCMD_INQUIRY: return ("Inquiry"); 420 case SCMD_TEST_UNIT_READY: return ("TestUnitReady"); 421 case SCMD_READ: return ("Read"); 422 case SCMD_READ_G1: return ("Read G1"); 423 case SCMD_RESERVE: return ("Reserve"); 424 case SCMD_RELEASE: return ("Release"); 425 case SCMD_WRITE: return ("Write"); 426 case SCMD_WRITE_G1: return ("Write G1"); 427 case SCMD_START_STOP: return ("StartStop"); 428 case SCMD_READ_CAPACITY: return ("ReadCap"); 429 case SCMD_MODE_SENSE: return ("ModeSense"); 430 case SCMD_MODE_SELECT: return ("ModeSelect"); 431 case SCMD_SVC_ACTION_IN_G4: return ("ActionInG4"); 432 case SCMD_MAINTENANCE_IN: return ("MaintenanceIn"); 433 case SCMD_GDIAG: return ("ReceiveDiag"); 434 case SCMD_SDIAG: return ("SendDiag"); 435 case SCMD_LOG_SENSE_G1: return ("LogSenseG1"); 436 case SCMD_PERSISTENT_RESERVE_IN: return ("PgrReserveIn"); 437 case SCMD_PERSISTENT_RESERVE_OUT: return ("PgrReserveOut"); 438 case BMIC_READ: return ("BMIC Read"); 439 case BMIC_WRITE: return ("BMIC Write"); 440 case CISS_REPORT_LOG: return ("CISS Report Logical"); 441 case CISS_REPORT_PHYS: return ("CISS Report Physical"); 442 default: return ("unmapped"); 443 } 444 } 445 446 char * 447 io_status_to_str(int val) 448 { 449 switch (val) { 450 case PQI_DATA_IN_OUT_GOOD: return ("Good"); 451 case PQI_DATA_IN_OUT_UNDERFLOW: return ("Underflow"); 452 case PQI_DATA_IN_OUT_ERROR: return ("ERROR"); 453 case PQI_DATA_IN_OUT_PROTOCOL_ERROR: return ("Protocol Error"); 454 case PQI_DATA_IN_OUT_HARDWARE_ERROR: return ("Hardware Error"); 455 default: return ("UNHANDLED"); 456 } 457 } 458 459 char * 460 scsi_status_to_str(uint8_t val) 461 { 462 switch (val) { 463 case STATUS_GOOD: return ("Good"); 464 case STATUS_CHECK: return ("Check"); 465 case STATUS_MET: return ("Met"); 466 case STATUS_BUSY: return ("Busy"); 467 case STATUS_INTERMEDIATE: return ("Intermediate"); 468 case STATUS_RESERVATION_CONFLICT: return ("Reservation Conflict"); 469 case STATUS_TERMINATED: return ("Terminated"); 470 case STATUS_QFULL: return ("QFull"); 471 case STATUS_ACA_ACTIVE: return ("ACA Active"); 472 case STATUS_TASK_ABORT: return ("Task Abort"); 473 default: return ("Illegal Status"); 474 } 475 } 476 477 char * 478 iu_type_to_str(int val) 479 { 480 switch (val) { 481 case PQI_RESPONSE_IU_RAID_PATH_IO_SUCCESS: return ("Success"); 482 case PQI_RESPONSE_IU_AIO_PATH_IO_SUCCESS: return ("AIO Success"); 483 case PQI_RESPONSE_IU_GENERAL_MANAGEMENT: return ("General"); 484 case PQI_RESPONSE_IU_RAID_PATH_IO_ERROR: return ("IO Error"); 485 case PQI_RESPONSE_IU_AIO_PATH_IO_ERROR: return ("AIO IO Error"); 486 case PQI_RESPONSE_IU_AIO_PATH_DISABLED: return ("AIO Path Disabled"); 487 default: return ("UNHANDLED"); 488 } 489 } 490 491 /* 492 * []------------------------------------------------------------------[] 493 * | Support/utility functions for main functions above | 494 * []------------------------------------------------------------------[] 495 */ 496 497 /* 498 * cmd_finish_task -- taskq to complete command processing 499 * 500 * Under high load the driver will run out of IO slots which causes command 501 * requests to pause until a slot is free. Calls to pkt_comp below can circle 502 * through the SCSI layer and back into the driver to start another command 503 * request and therefore possibly pause. If cmd_finish_task() was called on 504 * the interrupt thread a hang condition could occur because IO slots wouldn't 505 * be processed and then freed. So, this portion of the command completion 506 * is run on a taskq. 507 */ 508 static void 509 cmd_finish_task(void *v) 510 { 511 pqi_cmd_t cmd = v; 512 struct scsi_pkt *pkt; 513 514 pkt = cmd->pc_pkt; 515 if (cmd->pc_poll) 516 sema_v(cmd->pc_poll); 517 if ((pkt->pkt_flags & FLAG_NOINTR) == 0 && 518 (pkt->pkt_comp != NULL)) 519 (*pkt->pkt_comp)(pkt); 520 } 521 522 typedef struct qual { 523 int q_val; 524 char *q_str; 525 } qual_t; 526 527 typedef struct code_qual { 528 int cq_code; 529 qual_t *cq_list; 530 } code_qual_t; 531 532 /* 533 * These messages come from pqi2r01 spec section 5.6 table 18. 534 */ 535 static qual_t pair0[] = { {0, "No error"}, {0, NULL} }; 536 static qual_t pair1[] = { {0, "Error detected during initialization"}, 537 { 0, NULL } }; 538 static qual_t pair2[] = { {1, "Invalid PD Function"}, 539 {2, "Invalid paramter for PD function"}, 540 {0, NULL } }; 541 static qual_t pair3[] = { {0, "Error creating admin queue pair"}, 542 { 1, "Error delete admin queue pair"}, 543 { 0, NULL} }; 544 static qual_t pair4[] = { {1, "Invalid IU type in general" }, 545 {2, "Invalid IU length in general admin request"}, 546 {0, NULL} }; 547 static qual_t pair5[] = { {1, "Internal error" }, 548 {2, "OQ spanning conflict"}, 549 {0, NULL} }; 550 static qual_t pair6[] = { {1, "Error completing PQI soft reset"}, 551 {2, "Error completing PQI firmware reset"}, 552 {3, "Error completing PQI hardware reset"}, 553 {0, NULL} }; 554 static code_qual_t cq_table[] = { 555 { 0, pair0 }, 556 { 1, pair1 }, 557 { 2, pair2 }, 558 { 3, pair3 }, 559 { 4, pair4 }, 560 { 5, pair5 }, 561 { 6, pair6 }, 562 { 0, NULL }, 563 }; 564 565 static void 566 show_error_detail(pqi_state_t s) 567 { 568 uint32_t error_reg = G32(s, pqi_registers.device_error); 569 uint8_t code, qualifier; 570 qual_t *p; 571 code_qual_t *cq; 572 573 code = error_reg & 0xff; 574 qualifier = (error_reg >> 8) & 0xff; 575 576 for (cq = cq_table; cq->cq_list != NULL; cq++) { 577 if (cq->cq_code == code) { 578 for (p = cq->cq_list; p->q_str != NULL; p++) { 579 if (p->q_val == qualifier) { 580 cmn_err(CE_NOTE, 581 "[code=%x,qual=%x]: %s\n", 582 code, qualifier, p->q_str); 583 return; 584 } 585 } 586 } 587 } 588 cmn_err(CE_NOTE, "Undefined code(%x)/qualifier(%x)\n", 589 code, qualifier); 590 } 591 592 /*ARGSUSED*/ 593 static void 594 pqi_catch_release(pqi_io_request_t *io, void *v) 595 { 596 /* 597 * This call can occur if the software times out a command because 598 * the HBA hasn't responded in the default amount of time, 10 seconds, 599 * and then the HBA responds. It's occurred a few times during testing 600 * so catch and ignore. 601 */ 602 } 603 604 static void 605 reinit_io(pqi_io_request_t *io) 606 { 607 io->io_cb = pqi_catch_release; 608 io->io_status = 0; 609 io->io_error_info = NULL; 610 io->io_raid_bypass = B_FALSE; 611 io->io_context = NULL; 612 io->io_cmd = NULL; 613 } 614 615 /* ---- Non-thread safe, for debugging state display code only ---- */ 616 static char bad_state_buf[64]; 617 618 static char * 619 cmd_state_str(pqi_cmd_state_t state) 620 { 621 switch (state) { 622 case PQI_CMD_UNINIT: return ("Uninitialized"); 623 case PQI_CMD_CONSTRUCT: return ("Construct"); 624 case PQI_CMD_INIT: return ("Init"); 625 case PQI_CMD_QUEUED: return ("Queued"); 626 case PQI_CMD_STARTED: return ("Started"); 627 case PQI_CMD_CMPLT: return ("Completed"); 628 case PQI_CMD_FATAL: return ("Fatal"); 629 case PQI_CMD_DESTRUCT: return ("Destruct"); 630 default: 631 (void) snprintf(bad_state_buf, sizeof (bad_state_buf), 632 "BAD STATE (%x)", state); 633 return (bad_state_buf); 634 } 635 } 636 637 638 #define MEMP(args...) (void) snprintf(buf + strlen(buf), sz - strlen(buf), args) 639 640 static void 641 build_cdb_str(uint8_t *cdb, char *buf, size_t sz) 642 { 643 *buf = '\0'; 644 645 switch (cdb[0]) { 646 case SCMD_INQUIRY: 647 MEMP("%s", cdb_to_str(cdb[0])); 648 if ((cdb[1] & 0x1) != 0) 649 MEMP(".vpd=%x", cdb[2]); 650 else if (cdb[2]) 651 MEMP("Illegal CDB"); 652 MEMP(".len=%x", cdb[3] << 8 | cdb[4]); 653 break; 654 655 case SCMD_READ: 656 MEMP("%s.lba=%x.len=%x", cdb_to_str(cdb[0]), 657 (cdb[1] & 0x1f) << 16 | cdb[2] << 8 | cdb[3], 658 cdb[4]); 659 break; 660 661 case SCMD_MODE_SENSE: 662 MEMP("%s.dbd=%s.pc=%x.page_code=%x.subpage=%x." 663 "len=%x", cdb_to_str(cdb[0]), 664 bool_to_str(cdb[1] & 8), cdb[2] >> 6 & 0x3, 665 cdb[2] & 0x3f, cdb[3], cdb[4]); 666 break; 667 668 case SCMD_START_STOP: 669 MEMP("%s.immed=%s.power=%x.start=%s", 670 cdb_to_str(cdb[0]), bool_to_str(cdb[1] & 1), 671 (cdb[4] >> 4) & 0xf, bool_to_str(cdb[4] & 1)); 672 break; 673 674 case SCMD_SVC_ACTION_IN_G4: 675 case SCMD_READ_CAPACITY: 676 case SCMD_TEST_UNIT_READY: 677 default: 678 MEMP("%s (%x)", cdb_to_str(cdb[0]), cdb[0]); 679 break; 680 } 681 } 682 683 static char lun_str[64]; 684 static char * 685 lun_to_str(uint8_t *lun) 686 { 687 int i; 688 lun_str[0] = '\0'; 689 for (i = 0; i < 8; i++) 690 (void) snprintf(lun_str + strlen(lun_str), 691 sizeof (lun_str) - strlen(lun_str), "%02x.", *lun++); 692 return (lun_str); 693 } 694 695 static char * 696 dir_to_str(int dir) 697 { 698 switch (dir) { 699 case SOP_NO_DIRECTION_FLAG: return ("NoDir"); 700 case SOP_WRITE_FLAG: return ("Write"); 701 case SOP_READ_FLAG: return ("Read"); 702 case SOP_BIDIRECTIONAL: return ("RW"); 703 default: return ("Oops"); 704 } 705 } 706 707 static char * 708 flags_to_str(uint32_t flag) 709 { 710 switch (flag) { 711 case CISS_SG_LAST: return ("Last"); 712 case CISS_SG_CHAIN: return ("Chain"); 713 case CISS_SG_NORMAL: return ("Norm"); 714 default: return ("Ooops"); 715 } 716 } 717 718 /* ---- Only for use in dump_raid and dump_aio ---- */ 719 #define SCRATCH_PRINT(args...) (void)snprintf(scratch + strlen(scratch), \ 720 len - strlen(scratch), args) 721 722 static void 723 dump_raid(pqi_state_t s, void *v, pqi_index_t idx) 724 { 725 int i; 726 int len = 512; 727 caddr_t scratch; 728 pqi_raid_path_request_t *rqst = v; 729 caddr_t raw = v; 730 731 scratch = kmem_alloc(len, KM_SLEEP); 732 scratch[0] = '\0'; 733 734 if (s->s_debug_level & DBG_LVL_RAW_RQST) { 735 SCRATCH_PRINT("RAW RQST: "); 736 for (i = 0; i < sizeof (*rqst); i++) 737 SCRATCH_PRINT("%02x:", *raw++ & 0xff); 738 cmn_err(CE_NOTE, "%s\n", scratch); 739 scratch[0] = '\0'; 740 } 741 742 if (s->s_debug_level & DBG_LVL_CDB) { 743 char buf[64]; 744 build_cdb_str(rqst->rp_cdb, buf, sizeof (buf)); 745 SCRATCH_PRINT("cdb(%s),", buf); 746 } 747 748 ASSERT0(rqst->header.reserved); 749 ASSERT0(rqst->reserved1); 750 ASSERT0(rqst->reserved2); 751 ASSERT0(rqst->reserved3); 752 ASSERT0(rqst->reserved4); 753 ASSERT0(rqst->reserved5); 754 755 if (s->s_debug_level & DBG_LVL_RQST) { 756 SCRATCH_PRINT("pi=%x,h(type=%x,len=%x,id=%x)", idx, 757 rqst->header.iu_type, rqst->header.iu_length, 758 rqst->header.iu_id); 759 SCRATCH_PRINT("rqst_id=%x,nexus_id=%x,len=%x,lun=(%s)," 760 "proto=%x,dir=%s,partial=%s,", 761 rqst->rp_id, rqst->rp_nexus_id, rqst->rp_data_len, 762 lun_to_str(rqst->rp_lun), rqst->protocol_specific, 763 dir_to_str(rqst->rp_data_dir), 764 bool_to_str(rqst->rp_partial)); 765 SCRATCH_PRINT("fence=%s,error_idx=%x,task_attr=%x," 766 "priority=%x,additional=%x,sg=(", 767 bool_to_str(rqst->rp_fence), rqst->rp_error_index, 768 rqst->rp_task_attr, 769 rqst->rp_pri, rqst->rp_additional_cdb); 770 for (i = 0; i < PQI_MAX_EMBEDDED_SG_DESCRIPTORS; i++) { 771 SCRATCH_PRINT("%lx:%x:%s,", 772 (long unsigned int)rqst->rp_sglist[i].sg_addr, 773 rqst->rp_sglist[i].sg_len, 774 flags_to_str(rqst->rp_sglist[i].sg_flags)); 775 } 776 SCRATCH_PRINT(")"); 777 } 778 779 cmn_err(CE_NOTE, "%s\n", scratch); 780 kmem_free(scratch, len); 781 } 782 783 static void 784 dump_aio(void *v) 785 { 786 pqi_aio_path_request_t *rqst = v; 787 int i; 788 int len = 512; 789 caddr_t scratch; 790 char buf[64]; 791 792 scratch = kmem_alloc(len, KM_SLEEP); 793 scratch[0] = '\0'; 794 795 build_cdb_str(rqst->cdb, buf, sizeof (buf)); 796 SCRATCH_PRINT("cdb(%s)", buf); 797 798 SCRATCH_PRINT("h(type=%x,len=%x,id=%x)", 799 rqst->header.iu_type, rqst->header.iu_length, 800 rqst->header.iu_id); 801 SCRATCH_PRINT("rqst_id=%x,nexus_id=%x,len=%x,lun=(%s),dir=%s," 802 "partial=%s,", 803 rqst->request_id, rqst->nexus_id, rqst->buffer_length, 804 lun_to_str(rqst->lun_number), 805 dir_to_str(rqst->data_direction), bool_to_str(rqst->partial)); 806 SCRATCH_PRINT("fence=%s,error_idx=%x,task_attr=%x,priority=%x," 807 "num_sg=%x,cdb_len=%x,sg=(", 808 bool_to_str(rqst->fence), rqst->error_index, rqst->task_attribute, 809 rqst->command_priority, rqst->num_sg_descriptors, rqst->cdb_length); 810 for (i = 0; i < PQI_MAX_EMBEDDED_SG_DESCRIPTORS; i++) { 811 SCRATCH_PRINT("%lx:%x:%s,", 812 (long unsigned int)rqst->ap_sglist[i].sg_addr, 813 rqst->ap_sglist[i].sg_len, 814 flags_to_str(rqst->ap_sglist[i].sg_flags)); 815 } 816 SCRATCH_PRINT(")"); 817 818 cmn_err(CE_NOTE, "%s\n", scratch); 819 kmem_free(scratch, len); 820 } 821