1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 /* 26 * Utility SCSI configuration routines 27 */ 28 /* 29 * Many routines in this file have built in parallel bus assumption 30 * which might need to change as other interconnect evolve. 31 */ 32 33 #include <sys/scsi/scsi.h> 34 #include <sys/modctl.h> 35 #include <sys/bitmap.h> 36 #include <sys/fm/protocol.h> 37 38 /* 39 * macro for filling in lun value for scsi-1 support 40 */ 41 42 #define FILL_SCSI1_LUN(sd, pkt) \ 43 if ((sd->sd_address.a_lun > 0) && \ 44 (sd->sd_inq->inq_ansi == 0x1)) { \ 45 ((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun = \ 46 sd->sd_address.a_lun; \ 47 } 48 49 extern struct mod_ops mod_miscops; 50 51 static struct modlmisc modlmisc = { 52 &mod_miscops, /* Type of module */ 53 "SCSI Bus Utility Routines" 54 }; 55 56 static struct modlinkage modlinkage = { 57 MODREV_1, (void *)&modlmisc, NULL 58 }; 59 60 /* 61 * Contexts from which we call scsi_test 62 */ 63 enum scsi_test_ctxt { 64 /* 65 * Those in scsi_hba_probe_pi() 66 */ 67 STC_PROBE_FIRST_INQ, 68 STC_PROBE_FIRST_INQ_RETRY, 69 STC_PROBE_PARTIAL_SUCCESS, 70 STC_PROBE_RQSENSE1, 71 STC_PROBE_CHK_CLEARED, 72 STC_PROBE_RQSENSE2, 73 STC_PROBE_INQ_FINAL, 74 /* 75 * Those in check_vpd_page_support8083() 76 */ 77 STC_VPD_CHECK, 78 /* 79 * Those in scsi_device_identity() 80 */ 81 STC_IDENTITY_PG80, 82 STC_IDENTITY_PG83, 83 }; 84 85 static void create_inquiry_props(struct scsi_device *); 86 87 static int scsi_check_ss2_LUN_limit(struct scsi_device *); 88 static void scsi_establish_LUN_limit(struct scsi_device *); 89 static void scsi_update_parent_ss2_prop(dev_info_t *, int, int); 90 91 static int check_vpd_page_support8083(struct scsi_device *sd, 92 int (*callback)(), int *, int *); 93 static int send_scsi_INQUIRY(struct scsi_device *sd, 94 int (*callback)(), uchar_t *bufaddr, size_t buflen, 95 uchar_t evpd, uchar_t page_code, size_t *lenp, 96 enum scsi_test_ctxt); 97 98 /* 99 * this int-array HBA-node property keeps track of strictly SCSI-2 100 * target IDs 101 */ 102 #define SS2_LUN0_TGT_LIST_PROP "ss2-targets" 103 104 /* 105 * for keeping track of nodes for which we do *NOT* want to probe above LUN 7 106 * (i.e. strict SCSI-2 targets) 107 * 108 * note that we could also keep track of dtype (SCSI device type) and 109 * ANSI (SCSI standard conformance level), but all currently-known cases of 110 * this problem are on SCSI-2 PROCESSOR device types 111 */ 112 typedef struct ss2_lun0_info { 113 const char *sli_vid; /* SCSI inquiry VID */ 114 const char *sli_pid; /* SCSI inquiry PID */ 115 const char *sli_rev; /* SCSI inquiry REV */ 116 } ss2_lun0_info_t; 117 118 /* 119 * these two workarounds are for the SCSI-2 GEM2* chips used in the 120 * D1000 and D240 121 */ 122 #define SES_D1000_VID "SYMBIOS" 123 #define SES_D1000_PID "D1000" /* the D1000 */ 124 #define SES_D1000_REV "2" 125 126 #define SES_D240_VID "SUN" 127 #define SES_D240_PID "D240" /* the D240 */ 128 #define SES_D240_REV "2" 129 130 /* 131 * a static list of targets where we do *not* want to probe above LUN 7 132 */ 133 static const ss2_lun0_info_t scsi_probe_strict_s2_list[] = { 134 {SES_D1000_VID, SES_D1000_PID, SES_D1000_REV}, 135 {SES_D240_VID, SES_D240_PID, SES_D240_REV}, 136 }; 137 138 static const int scsi_probe_strict_s2_size = 139 sizeof (scsi_probe_strict_s2_list) / sizeof (struct ss2_lun0_info); 140 141 142 #ifdef DEBUG 143 144 int scsi_probe_debug = 0; 145 146 #define SCSI_PROBE_DEBUG0(l, s) \ 147 if (scsi_probe_debug >= (l)) printf(s) 148 #define SCSI_PROBE_DEBUG1(l, s, a1) \ 149 if (scsi_probe_debug >= (l)) printf(s, a1) 150 #define SCSI_PROBE_DEBUG2(l, s, a1, a2) \ 151 if (scsi_probe_debug >= (l)) printf(s, a1, a2) 152 #define SCSI_PROBE_DEBUG3(l, s, a1, a2, a3) \ 153 if (scsi_probe_debug >= (l)) printf(s, a1, a2, a3) 154 155 #else /* DEBUG */ 156 157 #define SCSI_PROBE_DEBUG0(l, s) 158 #define SCSI_PROBE_DEBUG1(l, s, a1) 159 #define SCSI_PROBE_DEBUG2(l, s, a1, a2) 160 #define SCSI_PROBE_DEBUG3(l, s, a1, a2, a3) 161 162 #endif /* DEBUG */ 163 164 int scsi_test_busy_timeout = SCSI_POLL_TIMEOUT; /* in seconds */ 165 int scsi_test_busy_delay = 10000; /* 10msec in usec */ 166 167 168 /* 169 * Returns from scsi_test. 170 * 171 * SCSI_TEST_CMPLT_GOOD => TRAN_ACCEPT, CMD_CMPLT, STATUS_GOOD 172 * 173 * SCSI_TEST_CMPLT_BUSY => TRAN_ACCEPT, CMD_CMPLT, STATUS_BUSY 174 * 175 * SCSI_TEST_CMPLT_CHECK => TRAN_ACCEPT, CMD_CMPLT, STATUS_CHECK 176 * 177 * SCSI_TEST_CMPLT_OTHER => TRAN_ACCEPT, CMD_CMPLT, !STATUS_{GOOD,BUSY,CHECK} 178 * 179 * SCSI_TEST_CMD_INCOMPLETE => TRAN_ACCEPT, CMD_INCOMPLETE 180 * 181 * SCSI_TEST_NOTCMPLT => TRAN_ACCEPT, pkt_reason != CMD_{CMPLT,INCOMPLETE} 182 * 183 * SCSI_TEST_TRAN_BUSY => (Repeated) TRAN_BUSY from attempt scsi_transport 184 * 185 * SCSI_TEST_TRAN_REJECT => TRAN_BADPKT or TRAN_FATAL_ERROR 186 * 187 */ 188 #define SCSI_TEST_CMPLT_GOOD 0x01U 189 #define SCSI_TEST_CMPLT_BUSY 0x02U 190 #define SCSI_TEST_CMPLT_CHECK 0x04U 191 #define SCSI_TEST_CMPLT_OTHER 0x08U 192 193 #define SCSI_TEST_CMPLTMASK \ 194 (SCSI_TEST_CMPLT_GOOD | SCSI_TEST_CMPLT_BUSY | \ 195 SCSI_TEST_CMPLT_CHECK | SCSI_TEST_CMPLT_OTHER) 196 197 #define SCSI_TEST_PARTCMPLTMASK \ 198 (SCSI_TEST_CMPLTMASK & ~SCSI_TEST_CMPLT_GOOD) 199 200 #define SCSI_TEST_CMD_INCOMPLETE 0x10U 201 #define SCSI_TEST_NOTCMPLT 0x20U 202 #define SCSI_TEST_TRAN_BUSY 0x40U 203 #define SCSI_TEST_TRAN_REJECT 0x80U 204 205 #define SCSI_TEST_FAILMASK \ 206 (SCSI_TEST_CMD_INCOMPLETE | SCSI_TEST_NOTCMPLT | \ 207 SCSI_TEST_TRAN_BUSY | SCSI_TEST_TRAN_REJECT) 208 209 #define SCSI_TEST_FAILURE(x) (((x) & SCSI_TEST_FAILMASK) != 0) 210 211 /* 212 * architecture dependent allocation restrictions. For x86, we'll set 213 * dma_attr_addr_hi to scsi_max_phys_addr and dma_attr_sgllen to 214 * scsi_sgl_size during _init(). 215 */ 216 #if defined(__sparc) 217 ddi_dma_attr_t scsi_alloc_attr = { 218 DMA_ATTR_V0, /* version number */ 219 0x0, /* lowest usable address */ 220 0xFFFFFFFFull, /* high DMA address range */ 221 0xFFFFFFFFull, /* DMA counter register */ 222 1, /* DMA address alignment */ 223 1, /* DMA burstsizes */ 224 1, /* min effective DMA size */ 225 0xFFFFFFFFull, /* max DMA xfer size */ 226 0xFFFFFFFFull, /* segment boundary */ 227 1, /* s/g list length */ 228 512, /* granularity of device */ 229 0 /* DMA transfer flags */ 230 }; 231 #elif defined(__x86) 232 ddi_dma_attr_t scsi_alloc_attr = { 233 DMA_ATTR_V0, /* version number */ 234 0x0, /* lowest usable address */ 235 0x0, /* high DMA address range [set in _init()] */ 236 0xFFFFull, /* DMA counter register */ 237 1, /* DMA address alignment */ 238 1, /* DMA burstsizes */ 239 1, /* min effective DMA size */ 240 0xFFFFFFFFull, /* max DMA xfer size */ 241 0xFFFFFFFFull, /* segment boundary */ 242 0, /* s/g list length */ 243 512, /* granularity of device [set in _init()] */ 244 0 /* DMA transfer flags */ 245 }; 246 uint64_t scsi_max_phys_addr = 0xFFFFFFFFull; 247 int scsi_sgl_size = 0xFF; 248 #endif 249 250 ulong_t *scsi_pkt_bad_alloc_bitmap; 251 252 int 253 _init() 254 { 255 scsi_initialize_hba_interface(); 256 scsi_watch_init(); 257 258 #if defined(__x86) 259 /* set the max physical address for iob allocs on x86 */ 260 scsi_alloc_attr.dma_attr_addr_hi = scsi_max_phys_addr; 261 262 /* 263 * set the sgllen for iob allocs on x86. If this is set less than 264 * the number of pages the buffer will take (taking into account 265 * alignment), it would force the allocator to try and allocate 266 * contiguous pages. 267 */ 268 scsi_alloc_attr.dma_attr_sgllen = scsi_sgl_size; 269 #endif 270 271 /* bitmap to limit scsi_pkt allocation violation messages */ 272 scsi_pkt_bad_alloc_bitmap = kmem_zalloc(BT_SIZEOFMAP(devcnt), KM_SLEEP); 273 274 return (mod_install(&modlinkage)); 275 } 276 277 /* 278 * there is no _fini() routine because this module is never unloaded 279 */ 280 281 int 282 _info(struct modinfo *modinfop) 283 { 284 return (mod_info(&modlinkage, modinfop)); 285 } 286 287 #define ROUTE (&sd->sd_address) 288 289 static int 290 scsi_slave_do_rqsense(struct scsi_device *sd, int (*callback)()) 291 { 292 struct scsi_pkt *rq_pkt = NULL; 293 struct buf *rq_bp = NULL; 294 int rval = SCSIPROBE_EXISTS; 295 296 /* 297 * prepare rqsense packet 298 */ 299 rq_bp = scsi_alloc_consistent_buf(ROUTE, (struct buf *)NULL, 300 (uint_t)SENSE_LENGTH, B_READ, callback, NULL); 301 if (rq_bp == NULL) { 302 rval = SCSIPROBE_NOMEM; 303 goto out; 304 } 305 306 rq_pkt = scsi_init_pkt(ROUTE, (struct scsi_pkt *)NULL, 307 rq_bp, CDB_GROUP0, 1, 0, PKT_CONSISTENT, 308 callback, NULL); 309 310 if (rq_pkt == NULL) { 311 if (rq_bp->b_error == 0) 312 rval = SCSIPROBE_NOMEM_CB; 313 else 314 rval = SCSIPROBE_NOMEM; 315 goto out; 316 } 317 ASSERT(rq_bp->b_error == 0); 318 319 (void) scsi_setup_cdb((union scsi_cdb *)rq_pkt-> 320 pkt_cdbp, SCMD_REQUEST_SENSE, 0, SENSE_LENGTH, 0); 321 FILL_SCSI1_LUN(sd, rq_pkt); 322 rq_pkt->pkt_flags = FLAG_NOINTR|FLAG_NOPARITY|FLAG_SENSING; 323 324 /* 325 * The controller type is as yet unknown, so we 326 * have to do a throwaway non-extended request sense, 327 * and hope that that clears the check condition 328 * for that unit until we can find out what kind 329 * of drive it is. A non-extended request sense 330 * is specified by stating that the sense block 331 * has 0 length, which is taken to mean that it 332 * is four bytes in length. 333 */ 334 if (scsi_poll(rq_pkt) < 0) { 335 rval = SCSIPROBE_FAILURE; 336 } 337 338 out: 339 if (rq_pkt) { 340 scsi_destroy_pkt(rq_pkt); 341 } 342 if (rq_bp) { 343 scsi_free_consistent_buf(rq_bp); 344 } 345 346 return (rval); 347 } 348 349 /* 350 * 351 * SCSI slave probe routine - provided as a service to target drivers 352 * 353 * Mostly attempts to allocate and fill sd inquiry data.. 354 */ 355 356 int 357 scsi_slave(struct scsi_device *sd, int (*callback)()) 358 { 359 struct scsi_pkt *pkt; 360 int rval = SCSIPROBE_EXISTS; 361 362 /* 363 * the first test unit ready will tell us whether a target 364 * responded and if there was one, it will clear the unit attention 365 * condition 366 */ 367 pkt = scsi_init_pkt(ROUTE, (struct scsi_pkt *)NULL, NULL, 368 CDB_GROUP0, sizeof (struct scsi_arq_status), 0, 0, callback, NULL); 369 370 if (pkt == NULL) { 371 return (SCSIPROBE_NOMEM_CB); 372 } 373 374 (void) scsi_setup_cdb((union scsi_cdb *)pkt->pkt_cdbp, 375 SCMD_TEST_UNIT_READY, 0, 0, 0); 376 FILL_SCSI1_LUN(sd, pkt); 377 pkt->pkt_flags = FLAG_NOINTR|FLAG_NOPARITY; 378 379 if (scsi_poll(pkt) < 0) { 380 if (pkt->pkt_reason == CMD_INCOMPLETE) 381 rval = SCSIPROBE_NORESP; 382 else 383 rval = SCSIPROBE_FAILURE; 384 385 if ((pkt->pkt_state & STATE_ARQ_DONE) == 0) { 386 if (((struct scsi_status *)pkt->pkt_scbp)->sts_chk) 387 /* 388 * scanner and processor devices can return a 389 * check condition here 390 */ 391 rval = scsi_slave_do_rqsense(sd, callback); 392 } 393 394 if (rval != SCSIPROBE_EXISTS) { 395 scsi_destroy_pkt(pkt); 396 return (rval); 397 } 398 } 399 400 /* 401 * the second test unit ready, allows the host adapter to negotiate 402 * synchronous transfer period and offset 403 */ 404 if (scsi_poll(pkt) < 0) { 405 if (pkt->pkt_reason == CMD_INCOMPLETE) 406 rval = SCSIPROBE_NORESP; 407 else 408 rval = SCSIPROBE_FAILURE; 409 } 410 411 /* 412 * do a rqsense if there was a check condition and ARQ was not done 413 */ 414 if ((pkt->pkt_state & STATE_ARQ_DONE) == 0) { 415 if (((struct scsi_status *)pkt->pkt_scbp)->sts_chk) { 416 rval = scsi_slave_do_rqsense(sd, callback); 417 } 418 } 419 420 /* 421 * call scsi_probe to do the inquiry 422 * 423 * NOTE: there is minor difference with the old scsi_slave 424 * implementation: busy conditions are not handled in scsi_probe. 425 */ 426 scsi_destroy_pkt(pkt); 427 if (rval == SCSIPROBE_EXISTS) { 428 return (scsi_probe(sd, callback)); 429 } else { 430 return (rval); 431 } 432 } 433 434 /* 435 * Undo scsi_slave - older interface, but still supported 436 * 437 * NOTE: The 'sd_inq' inquiry data is now freed by scsi_hba/scsi_vhci code 438 * as part of free of scsi_device(9S). 439 */ 440 /*ARGSUSED*/ 441 void 442 scsi_unslave(struct scsi_device *sd) 443 { 444 } 445 446 /* 447 * Undo scsi_probe 448 * 449 * NOTE: The 'sd_inq' inquiry data is now freed by scsi_hba/scsi_vhci code 450 * as part of free of scsi_device(9S). 451 */ 452 /*ARGSUSED*/ 453 void 454 scsi_unprobe(struct scsi_device *sd) 455 { 456 } 457 458 /* 459 * We log all scsi_test failures (as long as we are SE_HP etc). The 460 * following table controls the "driver-assessment" payload item 461 * in the ereports we raise. If a scsi_test return features in the 462 * retry mask then the calling context will retry; if it features in 463 * the fatal mask then the caller will not retry (although higher-level 464 * software might); if in neither (which shouldn't happen - you either 465 * retry or give up) default to 'retry'. 466 */ 467 static const struct scsi_test_profile { 468 enum scsi_test_ctxt stp_ctxt; /* Calling context */ 469 uint32_t stp_retrymask; /* Returns caller will retry for */ 470 uint32_t stp_fatalmask; /* Returns caller considers fatal */ 471 } scsi_test_profile[] = { 472 /* 473 * This caller will retry on SCSI_TEST_FAILMASK as long as it was 474 * not SCSI_TEST_CMD_INCOMPLETE which is terminal. A return from 475 * SCSI_TEST_PARTCMPLTMASK (command complete but status other than 476 * STATUS_GOOD) is not terminal and we'll move on to the context 477 * of STC_PROBE_PARTIAL_SUCCESS so that's a retry, too. 478 */ 479 { 480 STC_PROBE_FIRST_INQ, 481 SCSI_TEST_FAILMASK & ~SCSI_TEST_CMD_INCOMPLETE | 482 SCSI_TEST_PARTCMPLTMASK, 483 SCSI_TEST_CMD_INCOMPLETE 484 }, 485 486 /* 487 * If the first inquiry fails outright we always retry just once 488 * (except for SCSI_TEST_CMD_INCOMPLETE as above). A return in 489 * SCSI_TEST_FAILMASK is terminal; for SCSI_TEST_PARTCMPLTMASK 490 * we will retry at STC_PROBE_PARTIAL_SUCCESS. 491 */ 492 { 493 STC_PROBE_FIRST_INQ_RETRY, 494 SCSI_TEST_PARTCMPLTMASK, 495 SCSI_TEST_FAILMASK 496 }, 497 498 /* 499 * If we've met with partial success we retry at caller context 500 * STC_PROBE_PARTIAL_SUCCESS. Any SCSI_TEST_FAILMASK return 501 * here is terminal, as too is SCSI_TEST_CMPLT_BUSY. A return in 502 * SCSI_TEST_PARTCMPLTMASK and we will continue with further 503 * inquiry attempts. 504 */ 505 { 506 STC_PROBE_PARTIAL_SUCCESS, 507 SCSI_TEST_PARTCMPLTMASK & ~SCSI_TEST_CMPLT_BUSY, 508 SCSI_TEST_FAILMASK | SCSI_TEST_CMPLT_BUSY 509 }, 510 511 /* 512 * If we get past the above target busy case then we will 513 * perform a sense request if scsi_test indicates STATUS_CHECK 514 * and ARQ was not done. We are not interested in logging telemetry 515 * for transports that do not perform ARQ automatically. 516 */ 517 { 518 STC_PROBE_RQSENSE1, 519 0, 520 0 521 }, 522 523 /* 524 * If "something" responded to the probe but then the next inquiry 525 * sees a change of heart then we fail the probe on any of 526 * SCSI_TEST_FAILMASK or SCSI_TEST_CMPLT_BUSY. For other values 527 * in SCSI_TEST_PARTCMPLTMASK we soldier on. 528 */ 529 { 530 STC_PROBE_CHK_CLEARED, 531 SCSI_TEST_PARTCMPLTMASK & ~SCSI_TEST_CMPLT_BUSY, 532 SCSI_TEST_FAILMASK | SCSI_TEST_CMPLT_BUSY 533 }, 534 535 /* 536 * If after all that there we still have STATUS_CHECK from the 537 * inquiry status then we resend the sense request but the 538 * result is ignored (just clearing the condition). Do not 539 * log. 540 */ 541 { 542 STC_PROBE_RQSENSE2, 543 0, 544 0 545 }, 546 547 /* 548 * After the above sense request we once again send an inquiry. 549 * If it fails outright or STATUS_CHECK persists we give up. 550 * Any partial result is considered success. 551 */ 552 { 553 STC_PROBE_INQ_FINAL, 554 0, 555 SCSI_TEST_FAILMASK | SCSI_TEST_CMPLT_CHECK 556 }, 557 558 /* 559 * check_vpd_page_support8083 called from scsi_device_identity 560 * performs an inquiry with EVPD set (and page necessarily 0) 561 * to see what pages are supported. 562 * 563 * Some devices do not support this command and therefore 564 * check_vpd_page_support8083 only returns an error of kmem_zalloc 565 * fails. If the send_scsi_INQUIRY does not meet with complete 566 * success (SCSI_TEST_CMPLT_GOOD) it returns -1, othewise 0. 567 * So any scsi_test failure here will cause us to assume no page 568 * 80/83 support, and we will proceed without devid support. 569 * So -1 returns from send_scsi_INQUIRY are not terminal. 570 */ 571 { 572 STC_VPD_CHECK, 573 0, 574 0 575 }, 576 577 /* 578 * If the above inquiry claims pg80 support then scsi_device_identity 579 * will perform a send_scsi_INQUIRY to retrieve that page. 580 * Anything other than SCSI_TEST_CMPLT_GOOD is a failure and will 581 * cause scsi_device_identity to return non-zero at which point the 582 * caller goes to SCSIPROBE_FAILURE. 583 */ 584 { 585 STC_IDENTITY_PG80, 586 0, 587 SCSI_TEST_FAILMASK | SCSI_TEST_CMPLTMASK 588 }, 589 590 /* 591 * Similarly for pg83 592 */ 593 { 594 STC_IDENTITY_PG83, 595 0, 596 SCSI_TEST_FAILMASK | SCSI_TEST_CMPLTMASK 597 } 598 }; 599 600 int scsi_test_ereport_disable = 0; 601 602 extern int e_devid_cache_path_to_devid(char *, char *, char *, ddi_devid_t *); 603 604 static void 605 scsi_test_ereport_post(struct scsi_pkt *pkt, enum scsi_test_ctxt ctxt, 606 uint32_t stresult) 607 { 608 char *nodename = NULL, *devidstr_buf = NULL, *devidstr = NULL; 609 const struct scsi_test_profile *tp = &scsi_test_profile[ctxt]; 610 char ua[SCSI_MAXNAMELEN], nodenamebuf[SCSI_MAXNAMELEN]; 611 union scsi_cdb *cdbp = (union scsi_cdb *)pkt->pkt_cdbp; 612 struct scsi_address *ap = &pkt->pkt_address; 613 char *tgt_port, *tpl0 = NULL; 614 ddi_devid_t devid = NULL; 615 dev_info_t *probe, *hba; 616 struct scsi_device *sd; 617 scsi_lun64_t lun64; 618 const char *d_ass; 619 const char *class; 620 char *pathbuf; 621 nvlist_t *pl; 622 uint64_t wwn; 623 int err = 0; 624 int dad = 0; 625 size_t len; 626 int lun; 627 628 if (scsi_test_ereport_disable) 629 return; 630 631 ASSERT(tp->stp_ctxt == ctxt); 632 633 if ((sd = scsi_address_device(ap)) == NULL) 634 return; /* Not SCSI_HBA_ADDR_COMPLEX */ 635 636 probe = sd->sd_dev; 637 hba = ddi_get_parent(probe); 638 639 /* 640 * We only raise telemetry for SE_HP style enumeration 641 */ 642 if (!ndi_dev_is_hotplug_node(hba)) 643 return; 644 645 /* 646 * scsi_fm_ereport_post will use the hba for the fm-enabled devinfo 647 */ 648 if (!DDI_FM_EREPORT_CAP(ddi_fm_capable(hba))) 649 return; 650 651 /* 652 * Retrieve the unit address we were probing and the target 653 * port component thereof. 654 */ 655 if (!scsi_ua_get(sd, ua, sizeof (ua)) || 656 scsi_device_prop_lookup_string(sd, SCSI_DEVICE_PROP_PATH, 657 SCSI_ADDR_PROP_TARGET_PORT, &tgt_port) != DDI_PROP_SUCCESS) 658 return; 659 660 /* 661 * Determine whether unit address is location based or identity (wwn) 662 * based. If we can't convert the target port address to a wwn then 663 * we're location based. 664 */ 665 if (scsi_wwnstr_to_wwn(tgt_port, &wwn) == DDI_FAILURE) 666 return; 667 668 /* 669 * Get lun and lun64 670 */ 671 lun = scsi_device_prop_get_int(sd, SCSI_DEVICE_PROP_PATH, 672 SCSI_ADDR_PROP_LUN, 0); 673 lun64 = scsi_device_prop_get_int64(sd, SCSI_DEVICE_PROP_PATH, 674 SCSI_ADDR_PROP_LUN64, lun); 675 676 /* 677 * We are guaranteed not to be in interrupt or any other 678 * problematic context. So instead of repeated varargs 679 * style calls to scsi_fm_ereport_post for each flavour of 680 * ereport we have the luxury of being able to allocate 681 * and build an nvlist here. 682 * 683 * The ereports we raise here are all under the category 684 * ereport.io.scsi.cmd.disk category, namely 685 * 686 * ereport.io.scsi.cmd.disk. 687 * {dev.rqs.derr,dev.serr,tran}. 688 * 689 * For all ereports we also add the scsi_test specific payload. 690 * If we have it then we always include the devid in the payload 691 * (but only in the detector for device-as-detector ereports). 692 * 693 * Inherited From Member Name 694 * -------------------- ------------------- 695 * .cmd driver-assessment 696 * .cmd op-code 697 * .cmd cdb 698 * .cmd pkt-reason 699 * .cmd pkt-state 700 * .cmd pkt-stats 701 * .cmd.disk stat-code 702 * - scsi-test-return 703 * - scsi-test-context 704 */ 705 706 if (nvlist_alloc(&pl, NV_UNIQUE_NAME, 0) != 0) 707 return; 708 709 err |= nvlist_add_uint8(pl, "op-code", cdbp->scc_cmd); 710 err |= nvlist_add_uint8_array(pl, "cdb", pkt->pkt_cdbp, 711 pkt->pkt_cdblen); 712 err |= nvlist_add_uint8(pl, "pkt-reason", pkt->pkt_reason); 713 err |= nvlist_add_uint32(pl, "pkt-state", pkt->pkt_state); 714 err |= nvlist_add_uint32(pl, "pkt-stats", pkt->pkt_statistics); 715 err |= nvlist_add_uint32(pl, "stat-code", *pkt->pkt_scbp); 716 err |= nvlist_add_uint32(pl, "scsi-test-return", stresult); 717 err |= nvlist_add_int32(pl, "scsi-test-context", ctxt); 718 719 switch (stresult) { 720 case SCSI_TEST_CMPLT_BUSY: 721 dad = 1; 722 class = "cmd.disk.dev.serr"; 723 break; 724 725 case SCSI_TEST_CMPLT_CHECK: 726 dad = 1; 727 728 if ((pkt->pkt_state & STATE_ARQ_DONE)) { 729 struct scsi_arq_status *arqstat; 730 uint8_t key, asc, ascq; 731 uint8_t *sensep; 732 733 class = "cmd.disk.dev.rqs.derr"; 734 arqstat = (struct scsi_arq_status *)pkt->pkt_scbp; 735 sensep = (uint8_t *)&arqstat->sts_sensedata; 736 key = scsi_sense_key(sensep); 737 asc = scsi_sense_asc(sensep); 738 ascq = scsi_sense_ascq(sensep); 739 740 /* 741 * Add to payload. 742 */ 743 err |= nvlist_add_uint8(pl, "key", key); 744 err |= nvlist_add_uint8(pl, "asc", asc); 745 err |= nvlist_add_uint8(pl, "ascq", ascq); 746 err |= nvlist_add_uint8_array(pl, "sense-data", 747 sensep, sizeof (arqstat->sts_sensedata)); 748 } else { 749 class = "cmd.disk.dev.serr"; 750 } 751 752 break; 753 754 case SCSI_TEST_CMPLT_OTHER: 755 dad = 1; 756 class = "cmd.disk.dev.serr"; 757 break; 758 759 case SCSI_TEST_CMD_INCOMPLETE: 760 case SCSI_TEST_NOTCMPLT: 761 case SCSI_TEST_TRAN_BUSY: 762 case SCSI_TEST_TRAN_REJECT: 763 class = "cmd.disk.tran"; 764 break; 765 } 766 767 /* 768 * Determine driver-assessment and add to payload. 769 */ 770 if (dad) { 771 /* 772 * While higher level software can retry the enumeration 773 * the belief is that any device-as-detector style error 774 * will be persistent and will survive retries. So we 775 * can make a local determination of driver assessment. 776 * Some day it may be more elegant to raise an ereport from 777 * scsi_tgtmap_scsi_deactivate to confirm retries failed, 778 * and correlate that ereport during diagnosis. 779 */ 780 if (stresult & tp->stp_fatalmask) 781 d_ass = (const char *)"fatal"; 782 else if (stresult & tp->stp_retrymask) 783 d_ass = (const char *)"retry"; 784 else 785 d_ass = (const char *)"retry"; 786 } else { 787 /* We do not diagnose transport errors (yet) */ 788 d_ass = (const char *)"retry"; 789 } 790 791 err |= nvlist_add_string(pl, "driver-assessment", d_ass); 792 793 /* 794 * If we're hoping for a device-as-detector style ereport then 795 * we're going to need a devid for the detector FMRI. We 796 * don't have the devid because the target won't talk to us. 797 * But we do know which hba iport we were probing out of, and 798 * we know the unit address that was being probed (but not 799 * what type of device is or should be there). So we 800 * search the devid cache for any cached devid matching 801 * path <iport-path>/<nodename>@<unit-address> with nodename 802 * wildcarded. If a match is made we are returned not only the 803 * devid but also the nodename for the path that cached that 804 * entry. 805 * 806 * We also attempt to dig up a devid even for transport errors; 807 * we'll include that in the payload but not in the detector FMRI. 808 */ 809 810 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 811 (void) ddi_pathname(hba, pathbuf); 812 813 if (e_devid_cache_path_to_devid(pathbuf, ua, nodenamebuf, 814 &devid) == DDI_SUCCESS) { 815 nodename = nodenamebuf; 816 devidstr = devidstr_buf = ddi_devid_str_encode(devid, NULL); 817 kmem_free(devid, ddi_devid_sizeof(devid)); 818 err |= nvlist_add_string(pl, "devid", devidstr); 819 } 820 821 /* 822 * If this is lun 0 we will include the target-port-l0id 823 * in the dev scheme detector for device-as-detector. 824 */ 825 if (dad && (lun == 0 || lun64 == 0)) 826 tpl0 = tgt_port; 827 828 /* Construct the devpath to use in the detector */ 829 (void) ddi_pathname(hba, pathbuf); 830 len = strlen(pathbuf); 831 (void) snprintf(pathbuf + len, MAXPATHLEN - len, "/%s@%s", 832 nodename ? nodename : "unknown", ua); 833 834 /* 835 * Let's review. 836 * 837 * Device-as-detector ereports for which the attempted lookup of 838 * devid and nodename succeeded: 839 * 840 * - pathbuf has the full device path including nodename we 841 * dug up from the devid cache 842 * 843 * - class is one of cmd.disk.{dev.rqs.derr,dev.serr} 844 * 845 * - devidstr is non NULL and a valid devid string 846 * 847 * Would-be device-as-detector ereport for which the attempted lookup 848 * of devid failed: 849 * 850 * - pathbuf has a device path with leaf nodename of "unknown" 851 * but still including the unit-address 852 * - class is one of cmd.disk.{dev.rqs.derr,dev.serr} 853 * 854 * Transport errors: 855 * 856 * class is cmd.disk.tran 857 * devidstr is NULL 858 * 859 * - we may have succeeded in looking up a devid and nodename - 860 * the devid we'll have added to the payload but we must not 861 * add to detector FMRI, and if we have have nodename then 862 * we have a full devpath otherwise one with "unknown" for 863 * nodename 864 */ 865 866 if (err) 867 (void) nvlist_add_boolean_value(pl, "payload-incomplete", 868 B_TRUE); 869 870 scsi_fm_ereport_post( 871 sd, 872 0, /* path_instance - always 0 */ 873 pathbuf, /* devpath for detector */ 874 class, /* ereport class suffix */ 875 0, /* ENA - generate for us */ 876 dad ? devidstr : NULL, /* dtcr devid, dev-as-det only */ 877 tpl0, /* target-port-l0id */ 878 DDI_SLEEP, 879 pl, /* preconstructed payload */ 880 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0, 881 NULL); 882 883 nvlist_free(pl); 884 if (devidstr_buf) 885 ddi_devid_str_free(devidstr_buf); 886 kmem_free(pathbuf, MAXPATHLEN); 887 } 888 889 #ifdef DEBUG 890 /* 891 * Testing - fake scsi_test fails 892 */ 893 char scsi_test_fail_ua[SCSI_MAXNAMELEN]; /* unit address to object to */ 894 int scsi_test_fail_rc = TRAN_ACCEPT; /* scsi_transport return */ 895 uchar_t scsi_test_fail_pkt_reason = CMD_CMPLT; /* pkt_reason */ 896 uchar_t scsi_test_fail_status = STATUS_BUSY; /* status */ 897 uint_t scsi_test_fail_repeat = (uint_t)-1; /* number of times to fail ua */ 898 #endif 899 900 /* 901 * This is like scsi_poll, but only does retry for TRAN_BUSY. 902 */ 903 static uint32_t 904 scsi_test(struct scsi_pkt *pkt, enum scsi_test_ctxt ctxt) 905 { 906 uint32_t rval; 907 int wait_usec; 908 int rc; 909 extern int do_polled_io; 910 911 pkt->pkt_flags |= FLAG_NOINTR; 912 pkt->pkt_time = SCSI_POLL_TIMEOUT; /* in seconds */ 913 914 if (scsi_ifgetcap(&pkt->pkt_address, "tagged-qing", 1) == 1) { 915 pkt->pkt_flags |= FLAG_STAG; 916 } 917 918 /* 919 * Each TRAN_BUSY response waits scsi_test_busy_delay usec up to a 920 * maximum of scsi_test_busy_timeout. 921 */ 922 for (wait_usec = 0; (wait_usec / 1000000) <= scsi_test_busy_timeout; 923 wait_usec += scsi_test_busy_delay) { 924 925 /* Initialize pkt status variables */ 926 *pkt->pkt_scbp = pkt->pkt_reason = pkt->pkt_state = 0; 927 928 rc = scsi_transport(pkt); 929 if ((rc != TRAN_BUSY) || (scsi_test_busy_delay == 0) || 930 (scsi_test_busy_timeout == 0)) 931 break; 932 933 /* transport busy, wait */ 934 if ((curthread->t_flag & T_INTR_THREAD) == 0 && !do_polled_io) { 935 delay(drv_usectohz(scsi_test_busy_delay)); 936 } else { 937 /* we busy wait during cpr_dump or interrupt threads */ 938 drv_usecwait(scsi_test_busy_delay); 939 } 940 } 941 942 #ifdef DEBUG 943 if (scsi_test_fail_ua[0] != '\0' && scsi_test_fail_repeat > 0) { 944 struct scsi_address *ap = &pkt->pkt_address; 945 struct scsi_device *sd; 946 dev_info_t *probe; 947 char ua[SCSI_MAXNAMELEN]; 948 949 if ((sd = scsi_address_device(ap)) != NULL) { 950 probe = sd->sd_dev; 951 952 if (probe && scsi_ua_get(sd, ua, sizeof (ua)) && 953 strncmp(ua, scsi_test_fail_ua, sizeof (ua)) == 0) { 954 scsi_test_fail_repeat--; 955 rc = scsi_test_fail_rc; 956 if (rc == TRAN_ACCEPT) 957 pkt->pkt_reason = 958 scsi_test_fail_pkt_reason; 959 *pkt->pkt_scbp = scsi_test_fail_status; 960 if (scsi_test_fail_status == STATUS_CHECK) 961 pkt->pkt_state |= STATE_ARQ_DONE; 962 963 } 964 } 965 } 966 #endif 967 968 switch (rc) { 969 case TRAN_ACCEPT: 970 switch (pkt->pkt_reason) { 971 case CMD_CMPLT: 972 switch ((*pkt->pkt_scbp) & STATUS_MASK) { 973 case STATUS_GOOD: 974 rval = SCSI_TEST_CMPLT_GOOD; 975 break; 976 977 case STATUS_BUSY: 978 rval = SCSI_TEST_CMPLT_BUSY; 979 break; 980 981 case STATUS_CHECK: 982 rval = SCSI_TEST_CMPLT_CHECK; 983 break; 984 985 default: 986 rval = SCSI_TEST_CMPLT_OTHER; 987 break; 988 } 989 break; 990 991 case CMD_INCOMPLETE: 992 rval = SCSI_TEST_CMD_INCOMPLETE; 993 break; 994 995 default: 996 rval = SCSI_TEST_NOTCMPLT; 997 break; 998 } 999 break; 1000 1001 case TRAN_BUSY: 1002 rval = SCSI_TEST_TRAN_BUSY; 1003 break; 1004 1005 default: 1006 rval = SCSI_TEST_TRAN_REJECT; 1007 break; 1008 } 1009 1010 if (rval != SCSI_TEST_CMPLT_GOOD) 1011 scsi_test_ereport_post(pkt, ctxt, rval); 1012 1013 return (rval); 1014 } 1015 1016 /* 1017 * The implementation of scsi_probe now allows a particular 1018 * HBA to intercept the call, for any post- or pre-processing 1019 * it may need. The default, if the HBA does not override it, 1020 * is to call scsi_hba_probe(), which retains the old functionality 1021 * intact. 1022 */ 1023 int 1024 scsi_probe(struct scsi_device *sd, int (*callback)()) 1025 { 1026 int ret, retry = 0; 1027 int lr_cap, sr_ret; 1028 scsi_hba_tran_t *tran = sd->sd_address.a_hba_tran; 1029 1030 if (scsi_check_ss2_LUN_limit(sd) != 0) { 1031 /* 1032 * caller is trying to probe a strictly-SCSI-2 device 1033 * with a LUN that is too large, so do not allow it 1034 */ 1035 return (SCSIPROBE_NORESP); /* skip probing this one */ 1036 } 1037 again: 1038 ret = lr_cap = sr_ret = -1; 1039 if (tran->tran_tgt_probe != NULL) { 1040 ret = (*tran->tran_tgt_probe)(sd, callback); 1041 } else { 1042 ret = scsi_hba_probe(sd, callback); 1043 } 1044 1045 if ((ret != SCSIPROBE_EXISTS) && (retry == 0)) { 1046 lr_cap = (*tran->tran_getcap)(&sd->sd_address, "lun-reset", 1); 1047 sr_ret = scsi_reset(&sd->sd_address, RESET_LUN); 1048 if ((sr_ret != 1) && (lr_cap == 1)) { 1049 cmn_err(CE_WARN, "scsi_probe(%d): scsi_reset failed(%d)" 1050 " lun-reset cap(%d)", ret, sr_ret, lr_cap); 1051 } 1052 retry = 1; 1053 goto again; 1054 } 1055 1056 if (ret == SCSIPROBE_EXISTS) { 1057 create_inquiry_props(sd); 1058 /* is this a strictly-SCSI-2 node ?? */ 1059 scsi_establish_LUN_limit(sd); 1060 } 1061 1062 return (ret); 1063 } 1064 /* 1065 * probe scsi device using any available path 1066 * 1067 */ 1068 int 1069 scsi_hba_probe(struct scsi_device *sd, int (*callback)()) 1070 { 1071 return (scsi_hba_probe_pi(sd, callback, 0)); 1072 } 1073 1074 /* 1075 * probe scsi device using specific path 1076 * 1077 * scsi_hba_probe_pi does not do any test unit ready's which access the medium 1078 * and could cause busy or not ready conditions. 1079 * scsi_hba_probe_pi does 2 inquiries and a rqsense to clear unit attention 1080 * and to allow sync negotiation to take place 1081 * finally, scsi_hba_probe_pi does one more inquiry which should 1082 * reliably tell us what kind of target we have. 1083 * A scsi-2 compliant target should be able to return inquiry with 250ms 1084 * and we actually wait more than a second after reset. 1085 */ 1086 int 1087 scsi_hba_probe_pi(struct scsi_device *sd, int (*callback)(), int pi) 1088 { 1089 struct scsi_pkt *inq_pkt = NULL; 1090 struct scsi_pkt *rq_pkt = NULL; 1091 int rval = SCSIPROBE_NOMEM; 1092 struct buf *inq_bp = NULL; 1093 struct buf *rq_bp = NULL; 1094 int (*cb_flag)(); 1095 int pass = 1; 1096 uint32_t str; 1097 1098 if (sd->sd_inq == NULL) { 1099 sd->sd_inq = (struct scsi_inquiry *) 1100 kmem_alloc(SUN_INQSIZE, ((callback == SLEEP_FUNC) ? 1101 KM_SLEEP : KM_NOSLEEP)); 1102 if (sd->sd_inq == NULL) { 1103 goto out; 1104 } 1105 } 1106 1107 if (callback != SLEEP_FUNC && callback != NULL_FUNC) { 1108 cb_flag = NULL_FUNC; 1109 } else { 1110 cb_flag = callback; 1111 } 1112 inq_bp = scsi_alloc_consistent_buf(ROUTE, 1113 (struct buf *)NULL, SUN_INQSIZE, B_READ, cb_flag, NULL); 1114 if (inq_bp == NULL) { 1115 goto out; 1116 } 1117 1118 inq_pkt = scsi_init_pkt(ROUTE, (struct scsi_pkt *)NULL, 1119 inq_bp, CDB_GROUP0, sizeof (struct scsi_arq_status), 1120 0, PKT_CONSISTENT, callback, NULL); 1121 if (inq_pkt == NULL) { 1122 if (inq_bp->b_error == 0) 1123 rval = SCSIPROBE_NOMEM_CB; 1124 goto out; 1125 } 1126 ASSERT(inq_bp->b_error == 0); 1127 1128 (void) scsi_setup_cdb((union scsi_cdb *)inq_pkt->pkt_cdbp, 1129 SCMD_INQUIRY, 0, SUN_INQSIZE, 0); 1130 inq_pkt->pkt_flags = FLAG_NOINTR|FLAG_NOPARITY; 1131 1132 /* 1133 * set transport path 1134 */ 1135 if (pi && scsi_pkt_allocated_correctly(inq_pkt)) { 1136 inq_pkt->pkt_path_instance = pi; 1137 inq_pkt->pkt_flags |= FLAG_PKT_PATH_INSTANCE; 1138 } 1139 1140 /* 1141 * the first inquiry will tell us whether a target 1142 * responded 1143 * 1144 * The FILL_SCSI1_LUN below will find "ansi_ver != 1" on first pass 1145 * because of bzero initilization. If this assumption turns out to be 1146 * incorrect after we have real sd_inq data (for lun0) we will do a 1147 * second pass during which FILL_SCSI1_LUN will place lun in CDB. 1148 */ 1149 bzero((caddr_t)sd->sd_inq, SUN_INQSIZE); 1150 again: FILL_SCSI1_LUN(sd, inq_pkt); 1151 1152 str = scsi_test(inq_pkt, STC_PROBE_FIRST_INQ); 1153 if (SCSI_TEST_FAILURE(str)) { 1154 if (str == SCSI_TEST_CMD_INCOMPLETE) { 1155 rval = SCSIPROBE_NORESP; 1156 goto out; 1157 } 1158 1159 /* 1160 * Retry one more time for anything other than CMD_INCOMPLETE. 1161 */ 1162 str = scsi_test(inq_pkt, STC_PROBE_FIRST_INQ_RETRY); 1163 if (SCSI_TEST_FAILURE(str)) { 1164 rval = SCSIPROBE_FAILURE; 1165 goto out; 1166 } 1167 } 1168 1169 /* 1170 * Did the inquiry complete and transfer inquiry information, 1171 * perhaps after retry? 1172 */ 1173 if (str == SCSI_TEST_CMPLT_GOOD) 1174 goto done; 1175 1176 /* 1177 * We get here for SCSI_TEST_CMPLT_{BUSY,CHECK,OTHER}. We term 1178 * this "partial success" in that at least something is talking 1179 * to us. 1180 * 1181 * A second inquiry allows the host adapter to negotiate 1182 * synchronous transfer period and offset 1183 */ 1184 str = scsi_test(inq_pkt, STC_PROBE_PARTIAL_SUCCESS); 1185 if (SCSI_TEST_FAILURE(str)) { 1186 if (str == SCSI_TEST_CMD_INCOMPLETE) 1187 rval = SCSIPROBE_NORESP; 1188 else 1189 rval = SCSIPROBE_FAILURE; 1190 goto out; 1191 } 1192 1193 /* 1194 * If target is still busy, give up now. 1195 * XXX There's no interval between retries - scsi_test should 1196 * probably have a builtin retry on target busy. 1197 */ 1198 if (str == SCSI_TEST_CMPLT_BUSY) { 1199 rval = SCSIPROBE_BUSY; 1200 goto out; 1201 } 1202 1203 /* 1204 * At this point we are SCSI_TEST_CMPLT_GOOD, SCSI_TEST_CMPLT_CHECK 1205 * or SCSI_TEST_CMPLT_OTHER. 1206 * 1207 * Do a rqsense if there was a check condition and ARQ was not done 1208 */ 1209 if (str == SCSI_TEST_CMPLT_CHECK && 1210 (inq_pkt->pkt_state & STATE_ARQ_DONE) == 0) { 1211 /* 1212 * prepare rqsense packet 1213 * there is no real need for this because the 1214 * check condition should have been cleared by now. 1215 */ 1216 rq_bp = scsi_alloc_consistent_buf(ROUTE, (struct buf *)NULL, 1217 (uint_t)SENSE_LENGTH, B_READ, cb_flag, NULL); 1218 if (rq_bp == NULL) { 1219 goto out; 1220 } 1221 1222 rq_pkt = scsi_init_pkt(ROUTE, (struct scsi_pkt *)NULL, 1223 rq_bp, CDB_GROUP0, 1, 0, PKT_CONSISTENT, callback, NULL); 1224 1225 if (rq_pkt == NULL) { 1226 if (rq_bp->b_error == 0) 1227 rval = SCSIPROBE_NOMEM_CB; 1228 goto out; 1229 } 1230 ASSERT(rq_bp->b_error == 0); 1231 1232 (void) scsi_setup_cdb((union scsi_cdb *)rq_pkt-> 1233 pkt_cdbp, SCMD_REQUEST_SENSE, 0, SENSE_LENGTH, 0); 1234 FILL_SCSI1_LUN(sd, rq_pkt); 1235 rq_pkt->pkt_flags = FLAG_NOINTR|FLAG_NOPARITY; 1236 1237 /* 1238 * set transport path 1239 */ 1240 if (pi && scsi_pkt_allocated_correctly(rq_pkt)) { 1241 rq_pkt->pkt_path_instance = pi; 1242 rq_pkt->pkt_flags |= FLAG_PKT_PATH_INSTANCE; 1243 } 1244 1245 /* 1246 * The FILL_SCSI1_LUN above will find "inq_ansi != 1" 1247 * on first pass, see "again" comment above. 1248 * 1249 * The controller type is as yet unknown, so we 1250 * have to do a throwaway non-extended request sense, 1251 * and hope that that clears the check condition for 1252 * that unit until we can find out what kind of drive 1253 * it is. A non-extended request sense is specified 1254 * by stating that the sense block has 0 length, 1255 * which is taken to mean that it is four bytes in 1256 * length. 1257 */ 1258 if (SCSI_TEST_FAILURE(scsi_test(rq_pkt, STC_PROBE_RQSENSE1))) { 1259 rval = SCSIPROBE_FAILURE; 1260 goto out; 1261 } 1262 } 1263 1264 /* 1265 * At this point, we are guaranteed that something responded 1266 * to this scsi bus target id. We don't know yet what 1267 * kind of device it is, or even whether there really is 1268 * a logical unit attached (as some SCSI target controllers 1269 * lie about a unit being ready, e.g., the Emulex MD21). 1270 */ 1271 1272 str = scsi_test(inq_pkt, STC_PROBE_CHK_CLEARED); 1273 if (SCSI_TEST_FAILURE(str)) { 1274 rval = SCSIPROBE_FAILURE; 1275 goto out; 1276 } 1277 1278 if (str == SCSI_TEST_CMPLT_BUSY) { 1279 rval = SCSIPROBE_BUSY; 1280 goto out; 1281 } 1282 1283 /* 1284 * Okay we sent the INQUIRY command. 1285 * 1286 * If enough data was transferred, we count that the 1287 * Inquiry command succeeded, else we have to assume 1288 * that this is a non-CCS scsi target (or a nonexistent 1289 * target/lun). 1290 */ 1291 1292 if (str == SCSI_TEST_CMPLT_CHECK) { 1293 /* 1294 * try a request sense if we have a pkt, otherwise 1295 * just retry the inquiry one more time 1296 */ 1297 if (rq_pkt) 1298 (void) scsi_test(rq_pkt, STC_PROBE_RQSENSE2); 1299 1300 /* 1301 * retry inquiry 1302 */ 1303 str = scsi_test(inq_pkt, STC_PROBE_INQ_FINAL); 1304 if (SCSI_TEST_FAILURE(str)) { 1305 rval = SCSIPROBE_FAILURE; 1306 goto out; 1307 } else if (str == SCSI_TEST_CMPLT_CHECK) { 1308 rval = SCSIPROBE_FAILURE; 1309 goto out; 1310 } 1311 } 1312 1313 done: 1314 /* 1315 * If we got a parity error on receive of inquiry data, 1316 * we're just plain out of luck because we told the host 1317 * adapter to not watch for parity errors. 1318 */ 1319 if ((inq_pkt->pkt_state & STATE_XFERRED_DATA) == 0 || 1320 ((SUN_INQSIZE - inq_pkt->pkt_resid) < SUN_MIN_INQLEN)) { 1321 rval = SCSIPROBE_NONCCS; 1322 } else { 1323 ASSERT(inq_pkt->pkt_resid >= 0); 1324 bcopy((caddr_t)inq_bp->b_un.b_addr, 1325 (caddr_t)sd->sd_inq, (SUN_INQSIZE - inq_pkt->pkt_resid)); 1326 rval = SCSIPROBE_EXISTS; 1327 } 1328 1329 out: 1330 /* 1331 * If lun > 0 we need to figure out if this is a scsi-1 device where 1332 * the "real" lun needs to be embedded into the cdb. 1333 */ 1334 if ((rval == SCSIPROBE_EXISTS) && (pass == 1) && 1335 (sd->sd_address.a_lun > 0) && (sd->sd_inq->inq_ansi == 0x1)) { 1336 pass++; 1337 if (sd->sd_address.a_lun <= 7) 1338 goto again; 1339 1340 /* 1341 * invalid lun for scsi-1, 1342 * return probe failure. 1343 */ 1344 rval = SCSIPROBE_FAILURE; 1345 } 1346 1347 if (rq_pkt) { 1348 scsi_destroy_pkt(rq_pkt); 1349 } 1350 if (inq_pkt) { 1351 scsi_destroy_pkt(inq_pkt); 1352 } 1353 if (rq_bp) { 1354 scsi_free_consistent_buf(rq_bp); 1355 } 1356 if (inq_bp) { 1357 scsi_free_consistent_buf(inq_bp); 1358 } 1359 return (rval); 1360 } 1361 1362 /* 1363 * Convert from a scsi_device structure pointer to a scsi_hba_tran structure 1364 * pointer. The correct way to do this is 1365 * 1366 * #define DEVP_TO_TRAN(sd) ((sd)->sd_address.a_hba_tran) 1367 * 1368 * however we have some consumers that place their own vector in a_hba_tran. To 1369 * avoid problems, we implement this using the sd_tran_safe. See 1370 * scsi_hba_initchild for more details. 1371 */ 1372 #define DEVP_TO_TRAN(sd) ((sd)->sd_tran_safe) 1373 1374 /* 1375 * Function, callable from SCSA framework, to get 'human' readable REPORTDEV 1376 * addressing information from scsi_device properties. 1377 */ 1378 int 1379 scsi_ua_get_reportdev(struct scsi_device *sd, char *ra, int len) 1380 { 1381 /* use deprecated tran_get_bus_addr interface if it is defined */ 1382 /* NOTE: tran_get_bus_addr is a poor name choice for interface */ 1383 if (DEVP_TO_TRAN(sd)->tran_get_bus_addr) 1384 return ((*DEVP_TO_TRAN(sd)->tran_get_bus_addr)(sd, ra, len)); 1385 return (scsi_hba_ua_get_reportdev(sd, ra, len)); 1386 } 1387 1388 /* 1389 * Function, callable from HBA driver's tran_get_bus_addr(9E) implementation, 1390 * to get standard form of human readable REPORTDEV addressing information 1391 * from scsi_device properties. 1392 */ 1393 int 1394 scsi_hba_ua_get_reportdev(struct scsi_device *sd, char *ra, int len) 1395 { 1396 int tgt, lun, sfunc; 1397 char *tgt_port; 1398 scsi_lun64_t lun64; 1399 1400 /* get device unit-address properties */ 1401 tgt = scsi_device_prop_get_int(sd, SCSI_DEVICE_PROP_PATH, 1402 SCSI_ADDR_PROP_TARGET, -1); 1403 if (scsi_device_prop_lookup_string(sd, SCSI_DEVICE_PROP_PATH, 1404 SCSI_ADDR_PROP_TARGET_PORT, &tgt_port) != DDI_PROP_SUCCESS) 1405 tgt_port = NULL; 1406 if ((tgt == -1) && (tgt_port == NULL)) 1407 return (0); /* no target */ 1408 1409 lun = scsi_device_prop_get_int(sd, SCSI_DEVICE_PROP_PATH, 1410 SCSI_ADDR_PROP_LUN, 0); 1411 lun64 = scsi_device_prop_get_int64(sd, SCSI_DEVICE_PROP_PATH, 1412 SCSI_ADDR_PROP_LUN64, lun); 1413 sfunc = scsi_device_prop_get_int(sd, SCSI_DEVICE_PROP_PATH, 1414 SCSI_ADDR_PROP_SFUNC, -1); 1415 1416 /* 1417 * XXX should the default be to print this in decimal for 1418 * "human readable" form, so it matches conf files? 1419 */ 1420 if (tgt_port) { 1421 if (sfunc == -1) 1422 (void) snprintf(ra, len, 1423 "%s %s lun %" PRIx64, 1424 SCSI_ADDR_PROP_TARGET_PORT, tgt_port, lun64); 1425 else 1426 (void) snprintf(ra, len, 1427 "%s %s lun %" PRIx64 " sfunc %x", 1428 SCSI_ADDR_PROP_TARGET_PORT, tgt_port, lun64, sfunc); 1429 scsi_device_prop_free(sd, SCSI_DEVICE_PROP_PATH, tgt_port); 1430 } else { 1431 if (sfunc == -1) 1432 (void) snprintf(ra, len, 1433 "%s %x lun %" PRIx64, 1434 SCSI_ADDR_PROP_TARGET, tgt, lun64); 1435 else 1436 (void) snprintf(ra, len, 1437 "%s %x lun %" PRIx64 " sfunc %x", 1438 SCSI_ADDR_PROP_TARGET, tgt, lun64, sfunc); 1439 } 1440 1441 return (1); 1442 } 1443 1444 /* 1445 * scsi_ua_get: using properties, return "unit-address" string. 1446 * Called by SCSA framework, may call HBAs tran function. 1447 */ 1448 int 1449 scsi_ua_get(struct scsi_device *sd, char *ua, int len) 1450 { 1451 char *eua; 1452 1453 /* See if we already have established the unit-address. */ 1454 if ((eua = scsi_device_unit_address(sd)) != NULL) { 1455 (void) strlcpy(ua, eua, len); 1456 return (1); 1457 } 1458 1459 /* Use deprecated tran_get_name interface if it is defined. */ 1460 /* NOTE: tran_get_name is a poor name choice for interface */ 1461 if (DEVP_TO_TRAN(sd)->tran_get_name) 1462 return ((*DEVP_TO_TRAN(sd)->tran_get_name)(sd, ua, len)); 1463 1464 /* Use generic property implementation */ 1465 return (scsi_hba_ua_get(sd, ua, len)); 1466 } 1467 1468 /* 1469 * scsi_hba_ua_get: using properties, return "unit-address" string. 1470 * This function may be called from an HBAs tran function. 1471 * 1472 * Function to get "unit-address" in "name@unit-address" /devices path 1473 * component form from the scsi_device unit-address properties on a node. 1474 * 1475 * NOTE: This function works in conjunction with scsi_hba_ua_set(). 1476 */ 1477 int 1478 scsi_hba_ua_get(struct scsi_device *sd, char *ua, int len) 1479 { 1480 int tgt, lun, sfunc; 1481 char *tgt_port; 1482 scsi_lun64_t lun64; 1483 1484 /* get device unit-address properties */ 1485 tgt = scsi_device_prop_get_int(sd, SCSI_DEVICE_PROP_PATH, 1486 SCSI_ADDR_PROP_TARGET, -1); 1487 if (scsi_device_prop_lookup_string(sd, SCSI_DEVICE_PROP_PATH, 1488 SCSI_ADDR_PROP_TARGET_PORT, &tgt_port) != DDI_PROP_SUCCESS) 1489 tgt_port = NULL; 1490 if ((tgt == -1) && (tgt_port == NULL)) 1491 return (0); /* no target */ 1492 1493 lun = scsi_device_prop_get_int(sd, SCSI_DEVICE_PROP_PATH, 1494 SCSI_ADDR_PROP_LUN, 0); 1495 lun64 = scsi_device_prop_get_int64(sd, SCSI_DEVICE_PROP_PATH, 1496 SCSI_ADDR_PROP_LUN64, lun); 1497 sfunc = scsi_device_prop_get_int(sd, SCSI_DEVICE_PROP_PATH, 1498 SCSI_ADDR_PROP_SFUNC, -1); 1499 if (tgt_port) { 1500 if (sfunc == -1) 1501 (void) snprintf(ua, len, "%s,%" PRIx64, 1502 tgt_port, lun64); 1503 else 1504 (void) snprintf(ua, len, "%s,%" PRIx64 ",%x", 1505 tgt_port, lun64, sfunc); 1506 scsi_device_prop_free(sd, SCSI_DEVICE_PROP_PATH, tgt_port); 1507 } else { 1508 if (sfunc == -1) 1509 (void) snprintf(ua, len, "%x,%" PRIx64, tgt, lun64); 1510 else 1511 (void) snprintf(ua, len, "%x,%" PRIx64 ",%x", 1512 tgt, lun64, sfunc); 1513 } 1514 return (1); 1515 } 1516 1517 static void 1518 create_inquiry_props(struct scsi_device *sd) 1519 { 1520 struct scsi_inquiry *inq = sd->sd_inq; 1521 1522 (void) ndi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 1523 INQUIRY_DEVICE_TYPE, (int)inq->inq_dtype); 1524 1525 /* 1526 * Create the following properties: 1527 * 1528 * inquiry-vendor-id Vendor id (INQUIRY data bytes 8-15) 1529 * inquiry-product-id Product id (INQUIRY data bytes 16-31) 1530 * inquiry-revision-id Product Rev level (INQUIRY data bytes 32-35) 1531 * 1532 * NOTE: We don't support creation of these properties for scsi-1 1533 * devices (as the vid, pid and revision were not defined) and we 1534 * don't create the property if they are of zero length when 1535 * stripped of Nulls and spaces. 1536 * 1537 * NOTE: The first definition of these properties sticks. This gives 1538 * a transport the ability to provide a higher-quality definition 1539 * than the standard SCSI INQUIRY data. 1540 */ 1541 if (inq->inq_ansi != 1) { 1542 if (ddi_prop_exists(DDI_DEV_T_NONE, sd->sd_dev, 1543 DDI_PROP_TYPE_STRING, INQUIRY_VENDOR_ID) == 0) 1544 (void) scsi_device_prop_update_inqstring(sd, 1545 INQUIRY_VENDOR_ID, 1546 inq->inq_vid, sizeof (inq->inq_vid)); 1547 1548 if (ddi_prop_exists(DDI_DEV_T_NONE, sd->sd_dev, 1549 DDI_PROP_TYPE_STRING, INQUIRY_PRODUCT_ID) == 0) 1550 (void) scsi_device_prop_update_inqstring(sd, 1551 INQUIRY_PRODUCT_ID, 1552 inq->inq_pid, sizeof (inq->inq_pid)); 1553 1554 if (ddi_prop_exists(DDI_DEV_T_NONE, sd->sd_dev, 1555 DDI_PROP_TYPE_STRING, INQUIRY_REVISION_ID) == 0) 1556 (void) scsi_device_prop_update_inqstring(sd, 1557 INQUIRY_REVISION_ID, 1558 inq->inq_revision, sizeof (inq->inq_revision)); 1559 } 1560 } 1561 1562 /* 1563 * Create 'inquiry' string properties. An 'inquiry' string gets special 1564 * treatment to trim trailing blanks (etc) and ensure null termination. 1565 */ 1566 int 1567 scsi_device_prop_update_inqstring(struct scsi_device *sd, 1568 char *name, char *data, size_t len) 1569 { 1570 int ilen; 1571 char *data_string; 1572 int rv; 1573 1574 ilen = scsi_ascii_inquiry_len(data, len); 1575 ASSERT(ilen <= (int)len); 1576 if (ilen <= 0) 1577 return (DDI_PROP_INVAL_ARG); 1578 1579 /* ensure null termination */ 1580 data_string = kmem_zalloc(ilen + 1, KM_SLEEP); 1581 bcopy(data, data_string, ilen); 1582 rv = ndi_prop_update_string(DDI_DEV_T_NONE, 1583 sd->sd_dev, name, data_string); 1584 kmem_free(data_string, ilen + 1); 1585 return (rv); 1586 } 1587 1588 /* 1589 * Interfaces associated with SCSI_HBA_ADDR_COMPLEX 1590 * per-scsi_device HBA private data support. 1591 * 1592 * scsi_address_device returns NULL if we're not SCSI_HBA_ADDR_COMPLEX, 1593 * thereby allowing use of scsi_address_device as a test for 1594 * SCSI_HBA_ADDR_COMPLEX. 1595 */ 1596 struct scsi_device * 1597 scsi_address_device(struct scsi_address *sa) 1598 { 1599 return ((sa->a_hba_tran->tran_hba_flags & SCSI_HBA_ADDR_COMPLEX) ? 1600 sa->a.a_sd : NULL); 1601 } 1602 1603 void 1604 scsi_device_hba_private_set(struct scsi_device *sd, void *data) 1605 { 1606 ASSERT(sd->sd_address.a_hba_tran->tran_hba_flags & 1607 SCSI_HBA_ADDR_COMPLEX); 1608 sd->sd_hba_private = data; 1609 } 1610 1611 void * 1612 scsi_device_hba_private_get(struct scsi_device *sd) 1613 { 1614 ASSERT(sd->sd_address.a_hba_tran->tran_hba_flags & 1615 SCSI_HBA_ADDR_COMPLEX); 1616 return (sd->sd_hba_private); 1617 } 1618 1619 /* 1620 * This routine is called from the start of scsi_probe() if a tgt/LUN to be 1621 * probed *may* be a request to probe a strictly SCSI-2 target (with respect 1622 * to LUNs) -- and this probe may be for a LUN number greater than 7, 1623 * which can cause a hardware hang 1624 * 1625 * return 0 if the probe can proceed, 1626 * else return 1, meaning do *NOT* probe this target/LUN 1627 */ 1628 static int 1629 scsi_check_ss2_LUN_limit(struct scsi_device *sd) 1630 { 1631 struct scsi_address *ap = &(sd->sd_address); 1632 dev_info_t *pdevi = 1633 (dev_info_t *)DEVI(sd->sd_dev)->devi_parent; 1634 int ret_val = 0; /* default return value */ 1635 uchar_t *tgt_list; 1636 uint_t tgt_nelements; 1637 int i; 1638 1639 1640 /* 1641 * check for what *might* be a problem probe, only we don't 1642 * know yet what's really at the destination target/LUN 1643 */ 1644 if ((ap->a_target >= NTARGETS_WIDE) || 1645 (ap->a_lun < NLUNS_PER_TARGET)) { 1646 return (0); /* okay to probe this target */ 1647 } 1648 1649 /* 1650 * this *might* be a problematic probe, so look to see 1651 * if the inquiry data matches 1652 */ 1653 SCSI_PROBE_DEBUG2(1, "SCSA pre-probe: checking tgt.LUN=%d.%d\n", 1654 ap->a_target, ap->a_lun); 1655 SCSI_PROBE_DEBUG1(2, 1656 "SCSA pre-probe: scanning parent node name: %s ...\n", 1657 ddi_node_name(pdevi)); 1658 1659 /* 1660 * look for a special property of our parent node that lists 1661 * the targets under it for which we do *NOT* want to probe 1662 * if LUN>7 -- if the property is found, look to see if our 1663 * target ID is on that list 1664 */ 1665 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, pdevi, 1666 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, SS2_LUN0_TGT_LIST_PROP, 1667 &tgt_list, &tgt_nelements) != DDI_PROP_SUCCESS) { 1668 /* 1669 * no list, so it must be okay to probe this target.LUN 1670 */ 1671 SCSI_PROBE_DEBUG0(3, 1672 "SCSA pre-probe: NO parent prop found\n"); 1673 } else { 1674 for (i = 0; i < tgt_nelements; i++) { 1675 if (tgt_list[i] == ap->a_target) { 1676 /* 1677 * we found a match, which means we do *NOT* 1678 * want to probe the specified target.LUN 1679 */ 1680 ret_val = 1; 1681 break; 1682 } 1683 } 1684 ddi_prop_free(tgt_list); 1685 #ifdef DEBUG 1686 if (ret_val == 1) { 1687 SCSI_PROBE_DEBUG2(1, 1688 "SCSA pre-probe: marker node FOUND for " 1689 "tgt.LUN=%d.%d, so SKIPPING it\n", 1690 ap->a_target, ap->a_lun); 1691 } else { 1692 SCSI_PROBE_DEBUG0(2, 1693 "SCSA pre-probe: NO marker node found" 1694 " -- OK to probe\n"); 1695 } 1696 #endif 1697 } 1698 return (ret_val); 1699 } 1700 1701 1702 /* 1703 * this routine is called from near the end of scsi_probe(), 1704 * to see if the just-probed node is on our list of strictly-SCSI-2 nodes, 1705 * and if it is we mark our parent node with this information 1706 */ 1707 static void 1708 scsi_establish_LUN_limit(struct scsi_device *sd) 1709 { 1710 struct scsi_address *ap = &(sd->sd_address); 1711 struct scsi_inquiry *inq = sd->sd_inq; 1712 dev_info_t *devi = sd->sd_dev; 1713 char *vid = NULL; 1714 char *pid = NULL; 1715 char *rev = NULL; 1716 int i; 1717 const ss2_lun0_info_t *p; 1718 int bad_target_found = 0; 1719 1720 1721 /* 1722 * if this inquiry data shows that we have a strictly-SCSI-2 device 1723 * at LUN 0, then add it to our list of strictly-SCSI-2 devices, 1724 * so that we can avoid probes where LUN>7 on this device later 1725 */ 1726 if ((ap->a_lun != 0) || 1727 (ap->a_target >= NTARGETS_WIDE) || 1728 (inq->inq_dtype != DTYPE_PROCESSOR) || 1729 (inq->inq_ansi != 2)) { 1730 /* 1731 * this can't possibly be a node we want to look at, since 1732 * either LUN is greater than 0, target is greater than or 1733 * equal to 16, device type 1734 * is not processor, or SCSI level is not SCSI-2, 1735 * so don't bother checking for a strictly SCSI-2 1736 * (only 8 LUN) target 1737 */ 1738 return; /* don't care */ 1739 } 1740 1741 SCSI_PROBE_DEBUG2(1, "SCSA post-probe: LUN limit on tgt.LUN=%d.%d, " 1742 "SCSI-2 PROCESSOR?\n", ap->a_target, ap->a_lun); 1743 1744 ASSERT(devi != NULL); 1745 1746 /* 1747 * we have a node that has been probed that is: LUN=0, target<16, 1748 * PROCESSOR-type SCSI target, and at the SCSI-2 level, so 1749 * check INQ properties to see if it's in our list of strictly 1750 * SCSI-2 targets 1751 * 1752 * first we have to get the VID/PID/REV INQUIRY properties for 1753 * comparison 1754 */ 1755 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 1756 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1757 INQUIRY_VENDOR_ID, &vid) != DDI_PROP_SUCCESS) { 1758 SCSI_PROBE_DEBUG1(2, "SCSA post-probe: prop \"%s\" missing\n", 1759 INQUIRY_VENDOR_ID); 1760 goto dun; 1761 } 1762 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 1763 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1764 INQUIRY_PRODUCT_ID, &pid) != DDI_PROP_SUCCESS) { 1765 SCSI_PROBE_DEBUG1(2, "SCSA post-probe: prop \"%s\" missing\n", 1766 INQUIRY_PRODUCT_ID); 1767 goto dun; 1768 } 1769 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 1770 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1771 INQUIRY_REVISION_ID, &rev) != DDI_PROP_SUCCESS) { 1772 SCSI_PROBE_DEBUG1(2, "SCSA post-probe: prop \"%s\" missing\n", 1773 INQUIRY_REVISION_ID); 1774 goto dun; 1775 } 1776 1777 SCSI_PROBE_DEBUG3(3, "SCSA post-probe: looking for vid/pid/rev = " 1778 "\"%s\"/\"%s\"/\"%s\"\n", vid, pid, rev); 1779 1780 /* 1781 * now that we have the INQUIRY properties from the device node, 1782 * compare them with our known offenders 1783 * 1784 * Note: comparison is *CASE* *SENSITIVE* 1785 */ 1786 for (i = 0; i < scsi_probe_strict_s2_size; i++) { 1787 p = &scsi_probe_strict_s2_list[i]; 1788 1789 if ((strcmp(p->sli_vid, vid) == 0) && 1790 (strcmp(p->sli_pid, pid) == 0) && 1791 (strcmp(p->sli_rev, rev) == 0)) { 1792 /* 1793 * we found a match -- do NOT want to probe this one 1794 */ 1795 SCSI_PROBE_DEBUG3(1, 1796 "SCSA post-probe: recording strict SCSI-2 node " 1797 "vid/pid/rev = \"%s\"/\"%s\"/\"%s\"\n", 1798 vid, pid, rev); 1799 1800 /* 1801 * set/update private parent-node property, 1802 * so we can find out about this node later 1803 */ 1804 bad_target_found = 1; 1805 break; 1806 } 1807 } 1808 1809 /* 1810 * either add remove target number from parent property 1811 */ 1812 scsi_update_parent_ss2_prop(devi, ap->a_target, bad_target_found); 1813 1814 dun: 1815 if (vid != NULL) { 1816 ddi_prop_free(vid); 1817 } 1818 if (pid != NULL) { 1819 ddi_prop_free(pid); 1820 } 1821 if (rev != NULL) { 1822 ddi_prop_free(rev); 1823 } 1824 } 1825 1826 1827 /* 1828 * update the parent node to add in the supplied tgt number to the target 1829 * list property already present (if any) 1830 * 1831 * since the target list can never be longer than 16, and each target 1832 * number is also small, we can save having to alloc memory by putting 1833 * a 16-byte array on the stack and using it for property memory 1834 * 1835 * if "add_tgt" is set then add the target to the parent's property, else 1836 * remove it (if present) 1837 */ 1838 static void 1839 scsi_update_parent_ss2_prop(dev_info_t *devi, int tgt, int add_tgt) 1840 { 1841 dev_info_t *pdevi = (dev_info_t *)DEVI(devi)->devi_parent; 1842 uchar_t *tgt_list; 1843 uint_t nelements; 1844 uint_t new_nelements; 1845 int i; 1846 int update_result; 1847 uchar_t new_tgt_list[NTARGETS_WIDE]; 1848 1849 1850 ASSERT(pdevi != NULL); 1851 1852 SCSI_PROBE_DEBUG3(3, 1853 "SCSA post-probe: updating parent=%s property to %s tgt=%d\n", 1854 ddi_node_name(pdevi), add_tgt ? "add" : "remove", tgt); 1855 1856 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, pdevi, 1857 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1858 SS2_LUN0_TGT_LIST_PROP, &tgt_list, &nelements) == 1859 DDI_PROP_SUCCESS) { 1860 1861 if (add_tgt) { 1862 /* 1863 * we found an existing property -- we might need 1864 * to add to it 1865 */ 1866 for (i = 0; i < nelements; i++) { 1867 if (tgt_list[i] == tgt) { 1868 /* target already in list */ 1869 SCSI_PROBE_DEBUG1(2, "SCSA post-probe:" 1870 " tgt %d already listed\n", tgt); 1871 ddi_prop_free(tgt_list); 1872 return; 1873 } 1874 } 1875 1876 /* 1877 * need to append our target number to end of list 1878 * (no need sorting list, as it's so short) 1879 */ 1880 1881 /* 1882 * will this new entry fit ?? -- it should, since 1883 * the array is 16-wide and only keep track of 1884 * 16 targets, but check just in case 1885 */ 1886 new_nelements = nelements + 1; 1887 if (new_nelements >= NTARGETS_WIDE) { 1888 SCSI_PROBE_DEBUG0(1, "SCSA post-probe: " 1889 "internal error: no room " 1890 "for more targets?\n"); 1891 ddi_prop_free(tgt_list); 1892 return; 1893 } 1894 1895 /* copy existing list then add our tgt number to end */ 1896 bcopy((void *)tgt_list, (void *)new_tgt_list, 1897 sizeof (uchar_t) * nelements); 1898 new_tgt_list[new_nelements - 1] = (uchar_t)tgt; 1899 } else { 1900 /* 1901 * we need to remove our target number from the list, 1902 * so copy all of the other target numbers, 1903 * skipping ours 1904 */ 1905 int tgt_removed = 0; 1906 1907 new_nelements = 0; 1908 for (i = 0; i < nelements; i++) { 1909 if (tgt_list[i] != tgt) { 1910 new_tgt_list[new_nelements++] = 1911 tgt_list[i]; 1912 } else { 1913 /* skip this target */ 1914 tgt_removed++; 1915 } 1916 } 1917 1918 if (!tgt_removed) { 1919 SCSI_PROBE_DEBUG1(2, "SCSA post-probe:" 1920 " no need to remove tgt %d\n", tgt); 1921 ddi_prop_free(tgt_list); 1922 return; 1923 } 1924 } 1925 1926 update_result = ddi_prop_update_byte_array(DDI_DEV_T_NONE, 1927 pdevi, SS2_LUN0_TGT_LIST_PROP, new_tgt_list, 1928 new_nelements); 1929 1930 ddi_prop_free(tgt_list); 1931 } else { 1932 /* 1933 * no property yet 1934 */ 1935 if (add_tgt) { 1936 /* 1937 * create a property with just our tgt 1938 */ 1939 new_tgt_list[0] = (uchar_t)tgt; 1940 new_nelements = 1; /* just one element */ 1941 1942 update_result = ddi_prop_update_byte_array( 1943 DDI_DEV_T_NONE, pdevi, SS2_LUN0_TGT_LIST_PROP, 1944 new_tgt_list, new_nelements); 1945 } else { 1946 /* 1947 * no list so no need to remove tgt from that list 1948 */ 1949 return; 1950 } 1951 } 1952 1953 #ifdef DEBUG 1954 /* 1955 * if we get here we have tried to add/update properties 1956 */ 1957 if (update_result != DDI_PROP_SUCCESS) { 1958 SCSI_PROBE_DEBUG2(1, "SCSA post-probe: can't update parent " 1959 "property with tgt=%d (%d)\n", tgt, update_result); 1960 } else { 1961 if (add_tgt) { 1962 SCSI_PROBE_DEBUG3(2, 1963 "SCSA post-probe: added tgt=%d to parent " 1964 "prop=\"%s\" (now %d entries)\n", 1965 tgt, SS2_LUN0_TGT_LIST_PROP, new_nelements); 1966 } else { 1967 SCSI_PROBE_DEBUG3(2, 1968 "SCSA post-probe: removed tgt=%d from parent " 1969 "prop=\"%s\" (now %d entries)\n", 1970 tgt, SS2_LUN0_TGT_LIST_PROP, new_nelements); 1971 } 1972 } 1973 #endif 1974 } 1975 1976 1977 /* XXX BEGIN: find a better place for this: inquiry.h? */ 1978 /* 1979 * Definitions used by device id registration routines 1980 */ 1981 #define VPD_HEAD_OFFSET 3 /* size of head for vpd page */ 1982 #define VPD_PAGE_LENGTH 3 /* offset for pge length data */ 1983 #define VPD_MODE_PAGE 1 /* offset into vpd pg for "page code" */ 1984 1985 /* size for devid inquiries */ 1986 #define MAX_INQUIRY_SIZE 0xF0 1987 #define MAX_INQUIRY_SIZE_EVPD 0xFF /* XXX why is this longer */ 1988 /* XXX END: find a better place for these */ 1989 1990 1991 /* 1992 * Decorate devinfo node with identity properties using information obtained 1993 * from device. These properties are used by device enumeration code to derive 1994 * the devid, and guid for the device. These properties are also used to 1995 * determine if a device should be enumerated under the physical HBA (PHCI) or 1996 * the virtual HBA (VHCI, for mpxio support). 1997 * 1998 * Return zero on success. If commands that should succeed fail or allocations 1999 * fail then return failure (non-zero). It is possible for this function to 2000 * return success and not have decorated the node with any additional identity 2001 * information if the device correctly responds indicating that they are not 2002 * supported. When failure occurs the caller should consider not making the 2003 * device accessible. 2004 */ 2005 int 2006 scsi_device_identity(struct scsi_device *sd, int (*callback)()) 2007 { 2008 dev_info_t *devi = sd->sd_dev; 2009 uchar_t *inq80 = NULL; 2010 uchar_t *inq83 = NULL; 2011 int rval; 2012 size_t len; 2013 int pg80, pg83; 2014 2015 /* find out what pages are supported by device */ 2016 if (check_vpd_page_support8083(sd, callback, &pg80, &pg83) == -1) 2017 return (-1); 2018 2019 /* if available, collect page 80 data and add as property */ 2020 if (pg80) { 2021 inq80 = kmem_zalloc(MAX_INQUIRY_SIZE, 2022 ((callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP)); 2023 if (inq80 == NULL) { 2024 rval = -1; 2025 goto out; 2026 } 2027 2028 rval = send_scsi_INQUIRY(sd, callback, inq80, 2029 MAX_INQUIRY_SIZE, 0x01, 0x80, &len, STC_IDENTITY_PG80); 2030 if (rval) 2031 goto out; /* should have worked */ 2032 2033 if (len && (ndi_prop_update_byte_array(DDI_DEV_T_NONE, devi, 2034 "inquiry-page-80", inq80, len) != DDI_PROP_SUCCESS)) { 2035 cmn_err(CE_WARN, "scsi_device_identity: " 2036 "failed to add page80 prop"); 2037 rval = -1; 2038 goto out; 2039 } 2040 } 2041 2042 /* if available, collect page 83 data and add as property */ 2043 if (pg83) { 2044 inq83 = kmem_zalloc(MAX_INQUIRY_SIZE, 2045 ((callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP)); 2046 if (inq83 == NULL) { 2047 rval = -1; 2048 goto out; 2049 } 2050 2051 rval = send_scsi_INQUIRY(sd, callback, inq83, 2052 MAX_INQUIRY_SIZE, 0x01, 0x83, &len, STC_IDENTITY_PG83); 2053 if (rval) 2054 goto out; /* should have worked */ 2055 2056 if (len && (ndi_prop_update_byte_array(DDI_DEV_T_NONE, devi, 2057 "inquiry-page-83", inq83, len) != DDI_PROP_SUCCESS)) { 2058 cmn_err(CE_WARN, "scsi_device_identity: " 2059 "failed to add page83 prop"); 2060 rval = -1; 2061 goto out; 2062 } 2063 } 2064 2065 /* Commands worked, identity information that exists has been added. */ 2066 rval = 0; 2067 2068 /* clean up resources */ 2069 out: if (inq80 != NULL) 2070 kmem_free(inq80, MAX_INQUIRY_SIZE); 2071 if (inq83 != NULL) 2072 kmem_free(inq83, MAX_INQUIRY_SIZE); 2073 2074 return (rval); 2075 } 2076 2077 /* 2078 * Send an INQUIRY command with the EVPD bit set and a page code of 0x00 to 2079 * the device, returning zero on success. Returned INQUIRY data is used to 2080 * determine which vital product pages are supported. The device idenity 2081 * information we are looking for is in pages 0x83 and/or 0x80. If the device 2082 * fails the EVPD inquiry then no pages are supported but the call succeeds. 2083 * Return -1 (failure) if there were memory allocation failures or if a 2084 * command faild that should have worked. 2085 */ 2086 static int 2087 check_vpd_page_support8083(struct scsi_device *sd, int (*callback)(), 2088 int *ppg80, int *ppg83) 2089 { 2090 uchar_t *page_list; 2091 int counter; 2092 int rval; 2093 2094 /* pages are not supported */ 2095 *ppg80 = 0; 2096 *ppg83 = 0; 2097 2098 /* 2099 * We'll set the page length to the maximum to save figuring it out 2100 * with an additional call. 2101 */ 2102 page_list = kmem_zalloc(MAX_INQUIRY_SIZE_EVPD, 2103 ((callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP)); 2104 if (page_list == NULL) 2105 return (-1); /* memory allocation problem */ 2106 2107 /* issue page 0 (Supported VPD Pages) INQUIRY with evpd set */ 2108 rval = send_scsi_INQUIRY(sd, callback, 2109 page_list, MAX_INQUIRY_SIZE_EVPD, 1, 0, NULL, STC_VPD_CHECK); 2110 2111 /* 2112 * Now we must validate that the device accepted the command (some 2113 * devices do not support it) and if the idenity pages we are 2114 * interested in are supported. 2115 */ 2116 if ((rval == 0) && 2117 (page_list[VPD_MODE_PAGE] == 0x00)) { 2118 /* Loop to find one of the 2 pages we need */ 2119 counter = 4; /* Supported pages start at byte 4, with 0x00 */ 2120 2121 /* 2122 * Pages are returned in ascending order, and 0x83 is the 2123 * last page we are hoping to find. 2124 */ 2125 while ((page_list[counter] <= 0x83) && 2126 (counter <= (page_list[VPD_PAGE_LENGTH] + 2127 VPD_HEAD_OFFSET))) { 2128 /* 2129 * Add 3 because page_list[3] is the number of 2130 * pages minus 3 2131 */ 2132 2133 switch (page_list[counter]) { 2134 case 0x80: 2135 *ppg80 = 1; 2136 break; 2137 case 0x83: 2138 *ppg83 = 1; 2139 break; 2140 } 2141 counter++; 2142 } 2143 } 2144 2145 kmem_free(page_list, MAX_INQUIRY_SIZE_EVPD); 2146 return (0); 2147 } 2148 2149 /* 2150 * Send INQUIRY command with specified EVPD and page code. Return 2151 * zero on success. On success, the amount of data transferred 2152 * is returned in *lenp. 2153 */ 2154 static int 2155 send_scsi_INQUIRY(struct scsi_device *sd, int (*callback)(), 2156 uchar_t *bufaddr, size_t buflen, 2157 uchar_t evpd, uchar_t page_code, size_t *lenp, 2158 enum scsi_test_ctxt ctxt) 2159 { 2160 int (*cb_flag)(); 2161 struct buf *inq_bp; 2162 struct scsi_pkt *inq_pkt = NULL; 2163 int rval = -1; 2164 2165 if (lenp) 2166 *lenp = 0; 2167 if (callback != SLEEP_FUNC && callback != NULL_FUNC) 2168 cb_flag = NULL_FUNC; 2169 else 2170 cb_flag = callback; 2171 inq_bp = scsi_alloc_consistent_buf(ROUTE, 2172 (struct buf *)NULL, buflen, B_READ, cb_flag, NULL); 2173 if (inq_bp == NULL) 2174 goto out; /* memory allocation problem */ 2175 2176 inq_pkt = scsi_init_pkt(ROUTE, (struct scsi_pkt *)NULL, 2177 inq_bp, CDB_GROUP0, sizeof (struct scsi_arq_status), 2178 0, PKT_CONSISTENT, callback, NULL); 2179 if (inq_pkt == NULL) 2180 goto out; /* memory allocation problem */ 2181 2182 ASSERT(inq_bp->b_error == 0); 2183 2184 /* form INQUIRY cdb with specified EVPD and page code */ 2185 (void) scsi_setup_cdb((union scsi_cdb *)inq_pkt->pkt_cdbp, 2186 SCMD_INQUIRY, 0, buflen, 0); 2187 inq_pkt->pkt_cdbp[1] = evpd; 2188 inq_pkt->pkt_cdbp[2] = page_code; 2189 2190 inq_pkt->pkt_time = SCSI_POLL_TIMEOUT; /* in seconds */ 2191 inq_pkt->pkt_flags = FLAG_NOINTR|FLAG_NOPARITY; 2192 2193 /* 2194 * Issue inquiry command thru scsi_test 2195 * 2196 * NOTE: This is important data about device identity, not sure why 2197 * NOPARITY is used. Also seems like we should check pkt_stat for 2198 * STATE_XFERRED_DATA. 2199 */ 2200 if (scsi_test(inq_pkt, ctxt) == SCSI_TEST_CMPLT_GOOD) { 2201 ASSERT(inq_pkt->pkt_resid >= 0); 2202 ASSERT(inq_pkt->pkt_resid <= buflen); 2203 2204 bcopy(inq_bp->b_un.b_addr, 2205 bufaddr, buflen - inq_pkt->pkt_resid); 2206 if (lenp) 2207 *lenp = (buflen - inq_pkt->pkt_resid); 2208 rval = 0; 2209 } 2210 2211 /* 2212 * XXX We should retry on target busy 2213 */ 2214 2215 out: if (inq_pkt) 2216 scsi_destroy_pkt(inq_pkt); 2217 if (inq_bp) 2218 scsi_free_consistent_buf(inq_bp); 2219 return (rval); 2220 } 2221