1 /*- 2 * Copyright (c) 2008, 2009 Silicon Graphics International Corp. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions, and the following disclaimer, 10 * without modification. 11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12 * substantially similar to the "NO WARRANTY" disclaimer below 13 * ("Disclaimer") and any redistribution must be conditioned upon 14 * including a substantially similar Disclaimer requirement for further 15 * binary redistribution. 16 * 17 * NO WARRANTY 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 26 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 27 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGES. 29 * 30 * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/scsi_ctl.c#4 $ 31 */ 32 /* 33 * Peripheral driver interface between CAM and CTL (CAM Target Layer). 34 * 35 * Author: Ken Merry <ken@FreeBSD.org> 36 */ 37 38 #include <sys/cdefs.h> 39 __FBSDID("$FreeBSD$"); 40 41 #include <sys/param.h> 42 #include <sys/queue.h> 43 #include <sys/systm.h> 44 #include <sys/kernel.h> 45 #include <sys/lock.h> 46 #include <sys/mutex.h> 47 #include <sys/condvar.h> 48 #include <sys/malloc.h> 49 #include <sys/bus.h> 50 #include <sys/endian.h> 51 #include <sys/sbuf.h> 52 #include <sys/sysctl.h> 53 #include <sys/types.h> 54 #include <sys/systm.h> 55 #include <machine/bus.h> 56 57 #include <cam/cam.h> 58 #include <cam/cam_ccb.h> 59 #include <cam/cam_periph.h> 60 #include <cam/cam_queue.h> 61 #include <cam/cam_xpt_periph.h> 62 #include <cam/cam_debug.h> 63 #include <cam/cam_sim.h> 64 #include <cam/cam_xpt.h> 65 66 #include <cam/scsi/scsi_all.h> 67 #include <cam/scsi/scsi_message.h> 68 69 #include <cam/ctl/ctl_io.h> 70 #include <cam/ctl/ctl.h> 71 #include <cam/ctl/ctl_frontend.h> 72 #include <cam/ctl/ctl_util.h> 73 #include <cam/ctl/ctl_error.h> 74 75 typedef enum { 76 CTLFE_CCB_WAITING = 0x01 77 } ctlfe_ccb_types; 78 79 struct ctlfe_softc { 80 struct ctl_frontend fe; 81 path_id_t path_id; 82 struct cam_sim *sim; 83 char port_name[DEV_IDLEN]; 84 STAILQ_HEAD(, ctlfe_lun_softc) lun_softc_list; 85 STAILQ_ENTRY(ctlfe_softc) links; 86 }; 87 88 STAILQ_HEAD(, ctlfe_softc) ctlfe_softc_list; 89 struct mtx ctlfe_list_mtx; 90 static char ctlfe_mtx_desc[] = "ctlfelist"; 91 static int ctlfe_dma_enabled = 1; 92 #ifdef CTLFE_INIT_ENABLE 93 static int ctlfe_max_targets = 1; 94 static int ctlfe_num_targets = 0; 95 #endif 96 97 typedef enum { 98 CTLFE_LUN_NONE = 0x00, 99 CTLFE_LUN_WILDCARD = 0x01 100 } ctlfe_lun_flags; 101 102 struct ctlfe_lun_softc { 103 struct ctlfe_softc *parent_softc; 104 struct cam_periph *periph; 105 ctlfe_lun_flags flags; 106 struct callout dma_callout; 107 uint64_t ccbs_alloced; 108 uint64_t ccbs_freed; 109 uint64_t ctios_sent; 110 uint64_t ctios_returned; 111 uint64_t atios_sent; 112 uint64_t atios_returned; 113 uint64_t inots_sent; 114 uint64_t inots_returned; 115 /* bus_dma_tag_t dma_tag; */ 116 TAILQ_HEAD(, ccb_hdr) work_queue; 117 STAILQ_ENTRY(ctlfe_lun_softc) links; 118 }; 119 120 typedef enum { 121 CTLFE_CMD_NONE = 0x00, 122 CTLFE_CMD_PIECEWISE = 0x01 123 } ctlfe_cmd_flags; 124 125 /* 126 * The size limit of this structure is CTL_PORT_PRIV_SIZE, from ctl_io.h. 127 * Currently that is 600 bytes. 128 */ 129 struct ctlfe_lun_cmd_info { 130 int cur_transfer_index; 131 ctlfe_cmd_flags flags; 132 /* 133 * XXX KDM struct bus_dma_segment is 8 bytes on i386, and 16 134 * bytes on amd64. So with 32 elements, this is 256 bytes on 135 * i386 and 512 bytes on amd64. 136 */ 137 bus_dma_segment_t cam_sglist[32]; 138 }; 139 140 /* 141 * When we register the adapter/bus, request that this many ctl_ios be 142 * allocated. This should be the maximum supported by the adapter, but we 143 * currently don't have a way to get that back from the path inquiry. 144 * XXX KDM add that to the path inquiry. 145 */ 146 #define CTLFE_REQ_CTL_IO 4096 147 /* 148 * Number of Accept Target I/O CCBs to allocate and queue down to the 149 * adapter per LUN. 150 * XXX KDM should this be controlled by CTL? 151 */ 152 #define CTLFE_ATIO_PER_LUN 1024 153 /* 154 * Number of Immediate Notify CCBs (used for aborts, resets, etc.) to 155 * allocate and queue down to the adapter per LUN. 156 * XXX KDM should this be controlled by CTL? 157 */ 158 #define CTLFE_IN_PER_LUN 1024 159 160 /* 161 * Timeout (in seconds) on CTIO CCB allocation for doing a DMA or sending 162 * status to the initiator. The SIM is expected to have its own timeouts, 163 * so we're not putting this timeout around the CCB execution time. The 164 * SIM should timeout and let us know if it has an issue. 165 */ 166 #define CTLFE_DMA_TIMEOUT 60 167 168 /* 169 * Turn this on to enable extra debugging prints. 170 */ 171 #if 0 172 #define CTLFE_DEBUG 173 #endif 174 175 /* 176 * Use randomly assigned WWNN/WWPN values. This is to work around an issue 177 * in the FreeBSD initiator that makes it unable to rescan the target if 178 * the target gets rebooted and the WWNN/WWPN stay the same. 179 */ 180 #if 0 181 #define RANDOM_WWNN 182 #endif 183 184 SYSCTL_INT(_kern_cam_ctl, OID_AUTO, dma_enabled, CTLFLAG_RW, 185 &ctlfe_dma_enabled, 0, "DMA enabled"); 186 MALLOC_DEFINE(M_CTLFE, "CAM CTL FE", "CAM CTL FE interface"); 187 188 #define ccb_type ppriv_field0 189 /* This is only used in the ATIO */ 190 #define io_ptr ppriv_ptr1 191 192 /* This is only used in the CTIO */ 193 #define ccb_atio ppriv_ptr1 194 195 int ctlfeinitialize(void); 196 void ctlfeshutdown(void); 197 static periph_init_t ctlfeinit; 198 static void ctlfeasync(void *callback_arg, uint32_t code, 199 struct cam_path *path, void *arg); 200 static periph_ctor_t ctlferegister; 201 static periph_oninv_t ctlfeoninvalidate; 202 static periph_dtor_t ctlfecleanup; 203 static periph_start_t ctlfestart; 204 static void ctlfedone(struct cam_periph *periph, 205 union ccb *done_ccb); 206 207 static void ctlfe_onoffline(void *arg, int online); 208 static void ctlfe_online(void *arg); 209 static void ctlfe_offline(void *arg); 210 static int ctlfe_targ_enable(void *arg, struct ctl_id targ_id); 211 static int ctlfe_targ_disable(void *arg, struct ctl_id targ_id); 212 static int ctlfe_lun_enable(void *arg, struct ctl_id targ_id, 213 int lun_id); 214 static int ctlfe_lun_disable(void *arg, struct ctl_id targ_id, 215 int lun_id); 216 static void ctlfe_dump_sim(struct cam_sim *sim); 217 static void ctlfe_dump_queue(struct ctlfe_lun_softc *softc); 218 static void ctlfe_dma_timeout(void *arg); 219 static void ctlfe_datamove_done(union ctl_io *io); 220 static void ctlfe_dump(void); 221 222 static struct periph_driver ctlfe_driver = 223 { 224 ctlfeinit, "ctl", 225 TAILQ_HEAD_INITIALIZER(ctlfe_driver.units), /*generation*/ 0 226 }; 227 PERIPHDRIVER_DECLARE(ctl, ctlfe_driver); 228 229 extern struct ctl_softc *control_softc; 230 231 int 232 ctlfeinitialize(void) 233 { 234 cam_status status; 235 236 STAILQ_INIT(&ctlfe_softc_list); 237 238 mtx_init(&ctlfe_list_mtx, ctlfe_mtx_desc, NULL, MTX_DEF); 239 240 xpt_lock_buses(); 241 periphdriver_register(&ctlfe_driver); 242 xpt_unlock_buses(); 243 244 status = xpt_register_async(AC_PATH_REGISTERED | AC_PATH_DEREGISTERED | 245 AC_CONTRACT, ctlfeasync, NULL, NULL); 246 247 if (status != CAM_REQ_CMP) { 248 printf("ctl: Failed to attach async callback due to CAM " 249 "status 0x%x!\n", status); 250 } 251 252 return (0); 253 } 254 255 void 256 ctlfeshutdown(void) 257 { 258 return; 259 } 260 261 void 262 ctlfeinit(void) 263 { 264 cam_status status; 265 266 STAILQ_INIT(&ctlfe_softc_list); 267 268 mtx_init(&ctlfe_list_mtx, ctlfe_mtx_desc, NULL, MTX_DEF); 269 270 KASSERT(control_softc != NULL, ("CTL is not initialized!")); 271 272 status = xpt_register_async(AC_PATH_REGISTERED | AC_PATH_DEREGISTERED | 273 AC_CONTRACT, ctlfeasync, NULL, NULL); 274 275 if (status != CAM_REQ_CMP) { 276 printf("ctl: Failed to attach async callback due to CAM " 277 "status 0x%x!\n", status); 278 } 279 } 280 281 static void 282 ctlfeasync(void *callback_arg, uint32_t code, struct cam_path *path, void *arg) 283 { 284 285 #ifdef CTLFEDEBUG 286 printf("%s: entered\n", __func__); 287 #endif 288 289 /* 290 * When a new path gets registered, and it is capable of target 291 * mode, go ahead and attach. Later on, we may need to be more 292 * selective, but for now this will be sufficient. 293 */ 294 switch (code) { 295 case AC_PATH_REGISTERED: { 296 struct ctl_frontend *fe; 297 struct ctlfe_softc *bus_softc; 298 struct ctlfe_lun_softc *lun_softc; 299 struct cam_path *path; 300 struct ccb_pathinq *cpi; 301 cam_status status; 302 int retval; 303 304 cpi = (struct ccb_pathinq *)arg; 305 306 /* Don't attach if it doesn't support target mode */ 307 if ((cpi->target_sprt & PIT_PROCESSOR) == 0) { 308 #ifdef CTLFEDEBUG 309 printf("%s: SIM %s%d doesn't support target mode\n", 310 __func__, cpi->dev_name, cpi->unit_number); 311 #endif 312 break; 313 } 314 315 #ifdef CTLFE_INIT_ENABLE 316 if (ctlfe_num_targets >= ctlfe_max_targets) { 317 union ccb *ccb; 318 struct cam_sim *sim; 319 320 ccb = (union ccb *)malloc(sizeof(*ccb), M_TEMP, 321 M_NOWAIT | M_ZERO); 322 if (ccb == NULL) { 323 printf("%s: unable to malloc CCB!\n", __func__); 324 xpt_free_path(path); 325 return; 326 } 327 xpt_setup_ccb(&ccb->ccb_h, cpi->ccb_h.path, 328 /*priority*/ 1); 329 330 sim = xpt_path_sim(cpi->ccb_h.path); 331 332 ccb->ccb_h.func_code = XPT_SET_SIM_KNOB; 333 ccb->knob.xport_specific.valid = KNOB_VALID_ROLE; 334 ccb->knob.xport_specific.fc.role = KNOB_ROLE_INITIATOR; 335 336 /* We should hold the SIM lock here */ 337 mtx_assert(sim->mtx, MA_OWNED); 338 339 xpt_action(ccb); 340 341 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != 342 CAM_REQ_CMP) { 343 printf("%s: SIM %s%d (path id %d) initiator " 344 "enable failed with status %#x\n", 345 __func__, cpi->dev_name, 346 cpi->unit_number, cpi->ccb_h.path_id, 347 ccb->ccb_h.status); 348 } else { 349 printf("%s: SIM %s%d (path id %d) initiator " 350 "enable succeeded\n", 351 __func__, cpi->dev_name, 352 cpi->unit_number, cpi->ccb_h.path_id); 353 } 354 355 free(ccb, M_TEMP); 356 357 break; 358 } else { 359 ctlfe_num_targets++; 360 } 361 362 printf("%s: ctlfe_num_targets = %d\n", __func__, 363 ctlfe_num_targets); 364 #endif /* CTLFE_INIT_ENABLE */ 365 366 /* 367 * We're in an interrupt context here, so we have to 368 * use M_NOWAIT. Of course this means trouble if we 369 * can't allocate memory. 370 */ 371 bus_softc = malloc(sizeof(*bus_softc), M_CTLFE, 372 M_NOWAIT | M_ZERO); 373 if (bus_softc == NULL) { 374 printf("%s: unable to malloc %zd bytes for softc\n", 375 __func__, sizeof(*bus_softc)); 376 return; 377 } 378 379 bus_softc->path_id = cpi->ccb_h.path_id; 380 bus_softc->sim = xpt_path_sim(cpi->ccb_h.path); 381 STAILQ_INIT(&bus_softc->lun_softc_list); 382 383 fe = &bus_softc->fe; 384 385 /* 386 * XXX KDM should we be more accurate here ? 387 */ 388 if (cpi->transport == XPORT_FC) 389 fe->port_type = CTL_PORT_FC; 390 else 391 fe->port_type = CTL_PORT_SCSI; 392 393 /* XXX KDM what should the real number be here? */ 394 fe->num_requested_ctl_io = 4096; 395 snprintf(bus_softc->port_name, sizeof(bus_softc->port_name), 396 "%s%d", cpi->dev_name, cpi->unit_number); 397 /* 398 * XXX KDM it would be nice to allocate storage in the 399 * frontend structure itself. 400 */ 401 fe->port_name = bus_softc->port_name; 402 fe->physical_port = cpi->unit_number; 403 fe->virtual_port = cpi->bus_id; 404 fe->port_online = ctlfe_online; 405 fe->port_offline = ctlfe_offline; 406 fe->onoff_arg = bus_softc; 407 fe->targ_enable = ctlfe_targ_enable; 408 fe->targ_disable = ctlfe_targ_disable; 409 fe->lun_enable = ctlfe_lun_enable; 410 fe->lun_disable = ctlfe_lun_disable; 411 fe->targ_lun_arg = bus_softc; 412 fe->fe_datamove = ctlfe_datamove_done; 413 fe->fe_done = ctlfe_datamove_done; 414 fe->fe_dump = ctlfe_dump; 415 /* 416 * XXX KDM the path inquiry doesn't give us the maximum 417 * number of targets supported. 418 */ 419 fe->max_targets = cpi->max_target; 420 fe->max_target_id = cpi->max_target; 421 422 /* 423 * XXX KDM need to figure out whether we're the master or 424 * slave. 425 */ 426 #ifdef CTLFEDEBUG 427 printf("%s: calling ctl_frontend_register() for %s%d\n", 428 __func__, cpi->dev_name, cpi->unit_number); 429 #endif 430 retval = ctl_frontend_register(fe, /*master_SC*/ 1); 431 if (retval != 0) { 432 printf("%s: ctl_frontend_register() failed with " 433 "error %d!\n", __func__, retval); 434 free(bus_softc, M_CTLFE); 435 break; 436 } else { 437 mtx_lock(&ctlfe_list_mtx); 438 STAILQ_INSERT_TAIL(&ctlfe_softc_list, bus_softc, links); 439 mtx_unlock(&ctlfe_list_mtx); 440 } 441 442 status = xpt_create_path(&path, /*periph*/ NULL, 443 bus_softc->path_id,CAM_TARGET_WILDCARD, 444 CAM_LUN_WILDCARD); 445 if (status != CAM_REQ_CMP) { 446 printf("%s: unable to create path for wildcard " 447 "periph\n", __func__); 448 break; 449 } 450 lun_softc = malloc(sizeof(*lun_softc), M_CTLFE, 451 M_NOWAIT | M_ZERO); 452 if (lun_softc == NULL) { 453 xpt_print(path, "%s: unable to allocate softc for " 454 "wildcard periph\n", __func__); 455 xpt_free_path(path); 456 break; 457 } 458 459 lun_softc->parent_softc = bus_softc; 460 lun_softc->flags |= CTLFE_LUN_WILDCARD; 461 462 status = cam_periph_alloc(ctlferegister, 463 ctlfeoninvalidate, 464 ctlfecleanup, 465 ctlfestart, 466 "ctl", 467 CAM_PERIPH_BIO, 468 path, 469 ctlfeasync, 470 0, 471 lun_softc); 472 473 xpt_free_path(path); 474 475 break; 476 } 477 case AC_PATH_DEREGISTERED: 478 /* ctl_frontend_deregister() */ 479 break; 480 case AC_CONTRACT: { 481 struct ac_contract *ac; 482 483 ac = (struct ac_contract *)arg; 484 485 switch (ac->contract_number) { 486 case AC_CONTRACT_DEV_CHG: { 487 struct ac_device_changed *dev_chg; 488 struct ctlfe_softc *softc; 489 int retval, found; 490 491 dev_chg = (struct ac_device_changed *)ac->contract_data; 492 493 printf("%s: WWPN %#jx port %u path %u target %u %s\n", 494 __func__, dev_chg->wwpn, dev_chg->port, 495 xpt_path_path_id(path), dev_chg->target, 496 (dev_chg->arrived == 0) ? "left" : "arrived"); 497 498 found = 0; 499 500 mtx_lock(&ctlfe_list_mtx); 501 STAILQ_FOREACH(softc, &ctlfe_softc_list, links) { 502 if (softc->path_id == xpt_path_path_id(path)) { 503 found = 1; 504 break; 505 } 506 } 507 mtx_unlock(&ctlfe_list_mtx); 508 509 if (found == 0) { 510 printf("%s: CTL port for CAM path %u not " 511 "found!\n", __func__, 512 xpt_path_path_id(path)); 513 break; 514 } 515 if (dev_chg->arrived != 0) { 516 retval = ctl_add_initiator(dev_chg->wwpn, 517 softc->fe.targ_port, dev_chg->target); 518 } else { 519 retval = ctl_remove_initiator( 520 softc->fe.targ_port, dev_chg->target); 521 } 522 523 if (retval != 0) { 524 printf("%s: could not %s port %d iid %u " 525 "WWPN %#jx!\n", __func__, 526 (dev_chg->arrived != 0) ? "add" : 527 "remove", softc->fe.targ_port, 528 dev_chg->target, 529 (uintmax_t)dev_chg->wwpn); 530 } 531 break; 532 } 533 default: 534 printf("%s: unsupported contract number %ju\n", 535 __func__, (uintmax_t)ac->contract_number); 536 break; 537 } 538 break; 539 } 540 default: 541 break; 542 } 543 } 544 545 static cam_status 546 ctlferegister(struct cam_periph *periph, void *arg) 547 { 548 struct ctlfe_softc *bus_softc; 549 struct ctlfe_lun_softc *softc; 550 struct cam_sim *sim; 551 union ccb en_lun_ccb; 552 cam_status status; 553 int i; 554 555 softc = (struct ctlfe_lun_softc *)arg; 556 bus_softc = softc->parent_softc; 557 sim = xpt_path_sim(periph->path); 558 559 TAILQ_INIT(&softc->work_queue); 560 softc->periph = periph; 561 softc->parent_softc = bus_softc; 562 563 callout_init_mtx(&softc->dma_callout, sim->mtx, /*flags*/ 0); 564 periph->softc = softc; 565 566 xpt_setup_ccb(&en_lun_ccb.ccb_h, periph->path, /*priority*/ 1); 567 en_lun_ccb.ccb_h.func_code = XPT_EN_LUN; 568 en_lun_ccb.cel.grp6_len = 0; 569 en_lun_ccb.cel.grp7_len = 0; 570 en_lun_ccb.cel.enable = 1; 571 xpt_action(&en_lun_ccb); 572 status = (en_lun_ccb.ccb_h.status & CAM_STATUS_MASK); 573 if (status != CAM_REQ_CMP) { 574 xpt_print(periph->path, "%s: Enable LUN failed, status 0x%x\n", 575 __func__, en_lun_ccb.ccb_h.status); 576 return (status); 577 } 578 579 status = CAM_REQ_CMP; 580 581 for (i = 0; i < CTLFE_ATIO_PER_LUN; i++) { 582 union ccb *new_ccb; 583 584 new_ccb = (union ccb *)malloc(sizeof(*new_ccb), M_CTLFE, 585 M_NOWAIT); 586 if (new_ccb == NULL) { 587 status = CAM_RESRC_UNAVAIL; 588 break; 589 } 590 xpt_setup_ccb(&new_ccb->ccb_h, periph->path, /*priority*/ 1); 591 new_ccb->ccb_h.func_code = XPT_ACCEPT_TARGET_IO; 592 new_ccb->ccb_h.cbfcnp = ctlfedone; 593 xpt_action(new_ccb); 594 softc->atios_sent++; 595 status = new_ccb->ccb_h.status; 596 if ((status & CAM_STATUS_MASK) != CAM_REQ_INPROG) { 597 free(new_ccb, M_CTLFE); 598 break; 599 } 600 } 601 602 status = cam_periph_acquire(periph); 603 if ((status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 604 xpt_print(periph->path, "%s: could not acquire reference " 605 "count, status = %#x\n", __func__, status); 606 return (status); 607 } 608 609 if (i == 0) { 610 xpt_print(periph->path, "%s: could not allocate ATIO CCBs, " 611 "status 0x%x\n", __func__, status); 612 return (CAM_REQ_CMP_ERR); 613 } 614 615 for (i = 0; i < CTLFE_IN_PER_LUN; i++) { 616 union ccb *new_ccb; 617 618 new_ccb = (union ccb *)malloc(sizeof(*new_ccb), M_CTLFE, 619 M_NOWAIT); 620 if (new_ccb == NULL) { 621 status = CAM_RESRC_UNAVAIL; 622 break; 623 } 624 625 xpt_setup_ccb(&new_ccb->ccb_h, periph->path, /*priority*/ 1); 626 new_ccb->ccb_h.func_code = XPT_IMMEDIATE_NOTIFY; 627 new_ccb->ccb_h.cbfcnp = ctlfedone; 628 xpt_action(new_ccb); 629 softc->inots_sent++; 630 status = new_ccb->ccb_h.status; 631 if (status != CAM_REQ_INPROG) { 632 free(new_ccb, M_CTLFE); 633 break; 634 } 635 } 636 if (i == 0) { 637 xpt_print(periph->path, "%s: could not allocate immediate " 638 "notify CCBs, status 0x%x\n", __func__, status); 639 return (CAM_REQ_CMP_ERR); 640 } 641 return (CAM_REQ_CMP); 642 } 643 644 static void 645 ctlfeoninvalidate(struct cam_periph *periph) 646 { 647 union ccb en_lun_ccb; 648 cam_status status; 649 struct ctlfe_lun_softc *softc; 650 651 softc = (struct ctlfe_lun_softc *)periph->softc; 652 653 xpt_setup_ccb(&en_lun_ccb.ccb_h, periph->path, /*priority*/ 1); 654 en_lun_ccb.ccb_h.func_code = XPT_EN_LUN; 655 en_lun_ccb.cel.grp6_len = 0; 656 en_lun_ccb.cel.grp7_len = 0; 657 en_lun_ccb.cel.enable = 0; 658 xpt_action(&en_lun_ccb); 659 status = (en_lun_ccb.ccb_h.status & CAM_STATUS_MASK); 660 if (status != CAM_REQ_CMP) { 661 xpt_print(periph->path, "%s: Disable LUN failed, status 0x%x\n", 662 __func__, en_lun_ccb.ccb_h.status); 663 /* 664 * XXX KDM what do we do now? 665 */ 666 } 667 xpt_print(periph->path, "LUN removed, %ju ATIOs outstanding, %ju " 668 "INOTs outstanding, %d refs\n", softc->atios_sent - 669 softc->atios_returned, softc->inots_sent - 670 softc->inots_returned, periph->refcount); 671 } 672 673 static void 674 ctlfecleanup(struct cam_periph *periph) 675 { 676 struct ctlfe_lun_softc *softc; 677 struct ctlfe_softc *bus_softc; 678 679 xpt_print(periph->path, "%s: Called\n", __func__); 680 681 softc = (struct ctlfe_lun_softc *)periph->softc; 682 bus_softc = softc->parent_softc; 683 684 STAILQ_REMOVE(&bus_softc->lun_softc_list, softc, ctlfe_lun_softc,links); 685 686 /* 687 * XXX KDM is there anything else that needs to be done here? 688 */ 689 free(softc, M_CTLFE); 690 } 691 692 static void 693 ctlfestart(struct cam_periph *periph, union ccb *start_ccb) 694 { 695 struct ctlfe_lun_softc *softc; 696 struct ccb_hdr *ccb_h; 697 698 softc = (struct ctlfe_lun_softc *)periph->softc; 699 700 softc->ccbs_alloced++; 701 702 ccb_h = TAILQ_FIRST(&softc->work_queue); 703 if (periph->immediate_priority <= periph->pinfo.priority) { 704 panic("shouldn't get to the CCB waiting case!"); 705 start_ccb->ccb_h.ccb_type = CTLFE_CCB_WAITING; 706 SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h, 707 periph_links.sle); 708 periph->immediate_priority = CAM_PRIORITY_NONE; 709 wakeup(&periph->ccb_list); 710 } else if (ccb_h == NULL) { 711 softc->ccbs_freed++; 712 xpt_release_ccb(start_ccb); 713 } else { 714 struct ccb_accept_tio *atio; 715 struct ccb_scsiio *csio; 716 uint8_t *data_ptr; 717 uint32_t dxfer_len; 718 ccb_flags flags; 719 union ctl_io *io; 720 uint8_t scsi_status; 721 722 /* Take the ATIO off the work queue */ 723 TAILQ_REMOVE(&softc->work_queue, ccb_h, periph_links.tqe); 724 atio = (struct ccb_accept_tio *)ccb_h; 725 io = (union ctl_io *)ccb_h->io_ptr; 726 csio = &start_ccb->csio; 727 728 flags = atio->ccb_h.flags & 729 (CAM_DIS_DISCONNECT|CAM_TAG_ACTION_VALID|CAM_DIR_MASK); 730 731 if ((io == NULL) 732 || (io->io_hdr.status & CTL_STATUS_MASK) != CTL_STATUS_NONE) { 733 /* 734 * We're done, send status back. 735 */ 736 flags |= CAM_SEND_STATUS; 737 if (io == NULL) { 738 scsi_status = SCSI_STATUS_BUSY; 739 csio->sense_len = 0; 740 } else if ((io->io_hdr.status & CTL_STATUS_MASK) == 741 CTL_CMD_ABORTED) { 742 io->io_hdr.flags &= ~CTL_FLAG_STATUS_QUEUED; 743 744 /* 745 * If this command was aborted, we don't 746 * need to send status back to the SIM. 747 * Just free the CTIO and ctl_io, and 748 * recycle the ATIO back to the SIM. 749 */ 750 xpt_print(periph->path, "%s: aborted " 751 "command 0x%04x discarded\n", 752 __func__, io->scsiio.tag_num); 753 ctl_free_io(io); 754 /* 755 * For a wildcard attachment, commands can 756 * come in with a specific target/lun. Reset 757 * the target and LUN fields back to the 758 * wildcard values before we send them back 759 * down to the SIM. The SIM has a wildcard 760 * LUN enabled, not whatever target/lun 761 * these happened to be. 762 */ 763 if (softc->flags & CTLFE_LUN_WILDCARD) { 764 atio->ccb_h.target_id = 765 CAM_TARGET_WILDCARD; 766 atio->ccb_h.target_lun = 767 CAM_LUN_WILDCARD; 768 } 769 770 if ((atio->ccb_h.status & CAM_DEV_QFRZN) != 0) { 771 cam_release_devq(periph->path, 772 /*relsim_flags*/0, 773 /*reduction*/0, 774 /*timeout*/0, 775 /*getcount_only*/0); 776 atio->ccb_h.status &= ~CAM_DEV_QFRZN; 777 } 778 779 ccb_h = TAILQ_FIRST(&softc->work_queue); 780 781 if (atio->ccb_h.func_code != 782 XPT_ACCEPT_TARGET_IO) { 783 xpt_print(periph->path, "%s: func_code " 784 "is %#x\n", __func__, 785 atio->ccb_h.func_code); 786 } 787 start_ccb->ccb_h.func_code = XPT_ABORT; 788 start_ccb->cab.abort_ccb = (union ccb *)atio; 789 start_ccb->ccb_h.cbfcnp = ctlfedone; 790 791 /* Tell the SIM that we've aborted this ATIO */ 792 xpt_action(start_ccb); 793 softc->ccbs_freed++; 794 xpt_release_ccb(start_ccb); 795 796 /* 797 * Send the ATIO back down to the SIM. 798 */ 799 xpt_action((union ccb *)atio); 800 softc->atios_sent++; 801 802 /* 803 * If we still have work to do, ask for 804 * another CCB. Otherwise, deactivate our 805 * callout. 806 */ 807 if (ccb_h != NULL) 808 xpt_schedule(periph, /*priority*/ 1); 809 else 810 callout_stop(&softc->dma_callout); 811 812 return; 813 } else { 814 io->io_hdr.flags &= ~CTL_FLAG_STATUS_QUEUED; 815 scsi_status = io->scsiio.scsi_status; 816 csio->sense_len = io->scsiio.sense_len; 817 } 818 data_ptr = NULL; 819 dxfer_len = 0; 820 if (io == NULL) { 821 printf("%s: tag %04x io is NULL\n", __func__, 822 atio->tag_id); 823 } else { 824 #ifdef CTLFEDEBUG 825 printf("%s: tag %04x status %x\n", __func__, 826 atio->tag_id, io->io_hdr.status); 827 #endif 828 } 829 csio->sglist_cnt = 0; 830 if (csio->sense_len != 0) { 831 csio->sense_data = io->scsiio.sense_data; 832 flags |= CAM_SEND_SENSE; 833 } else if (scsi_status == SCSI_STATUS_CHECK_COND) { 834 xpt_print(periph->path, "%s: check condition " 835 "with no sense\n", __func__); 836 } 837 } else { 838 struct ctlfe_lun_cmd_info *cmd_info; 839 840 /* 841 * Datamove call, we need to setup the S/G list. 842 * If we pass in a S/G list, the isp(4) driver at 843 * least expects physical/bus addresses. 844 */ 845 846 cmd_info = (struct ctlfe_lun_cmd_info *) 847 io->io_hdr.port_priv; 848 849 KASSERT(sizeof(*cmd_info) < CTL_PORT_PRIV_SIZE, 850 ("%s: sizeof(struct ctlfe_lun_cmd_info) %zd < " 851 "CTL_PORT_PRIV_SIZE %d", __func__, 852 sizeof(*cmd_info), CTL_PORT_PRIV_SIZE)); 853 io->io_hdr.flags &= ~CTL_FLAG_DMA_QUEUED; 854 855 /* 856 * Need to zero this, in case it has been used for 857 * a previous datamove for this particular I/O. 858 */ 859 bzero(cmd_info, sizeof(*cmd_info)); 860 scsi_status = 0; 861 862 /* 863 * Set the direction, relative to the initiator. 864 */ 865 flags &= ~CAM_DIR_MASK; 866 if ((io->io_hdr.flags & CTL_FLAG_DATA_MASK) == 867 CTL_FLAG_DATA_IN) 868 flags |= CAM_DIR_IN; 869 else 870 flags |= CAM_DIR_OUT; 871 872 csio->cdb_len = atio->cdb_len; 873 874 if (io->scsiio.kern_sg_entries == 0) { 875 /* No S/G list */ 876 data_ptr = io->scsiio.kern_data_ptr; 877 dxfer_len = io->scsiio.kern_data_len; 878 csio->sglist_cnt = 0; 879 880 if (io->io_hdr.flags & CTL_FLAG_BUS_ADDR) 881 flags |= CAM_DATA_PHYS; 882 } else if (io->scsiio.kern_sg_entries <= 883 (sizeof(cmd_info->cam_sglist)/ 884 sizeof(cmd_info->cam_sglist[0]))) { 885 /* 886 * S/G list with physical or virtual pointers. 887 * Just populate the CAM S/G list with the 888 * pointers. 889 */ 890 int i; 891 struct ctl_sg_entry *ctl_sglist; 892 bus_dma_segment_t *cam_sglist; 893 894 ctl_sglist = (struct ctl_sg_entry *) 895 io->scsiio.kern_data_ptr; 896 cam_sglist = cmd_info->cam_sglist; 897 898 for (i = 0; i < io->scsiio.kern_sg_entries;i++){ 899 cam_sglist[i].ds_addr = 900 (bus_addr_t)ctl_sglist[i].addr; 901 cam_sglist[i].ds_len = 902 ctl_sglist[i].len; 903 } 904 csio->sglist_cnt = io->scsiio.kern_sg_entries; 905 flags |= CAM_SCATTER_VALID; 906 if (io->io_hdr.flags & CTL_FLAG_BUS_ADDR) 907 flags |= CAM_SG_LIST_PHYS; 908 else 909 flags &= ~CAM_SG_LIST_PHYS; 910 data_ptr = (uint8_t *)cam_sglist; 911 dxfer_len = io->scsiio.kern_data_len; 912 } else { 913 /* S/G list with virtual pointers */ 914 struct ctl_sg_entry *sglist; 915 int *ti; 916 917 /* 918 * XXX KDM this is a temporary hack. The 919 * isp(4) driver can't deal with S/G lists 920 * with virtual pointers, so we need to 921 * go through and send down one virtual 922 * pointer at a time. 923 */ 924 sglist = (struct ctl_sg_entry *) 925 io->scsiio.kern_data_ptr; 926 ti = &cmd_info->cur_transfer_index; 927 data_ptr = sglist[*ti].addr; 928 dxfer_len = sglist[*ti].len; 929 csio->sglist_cnt = 0; 930 cmd_info->flags |= CTLFE_CMD_PIECEWISE; 931 (*ti)++; 932 } 933 934 io->scsiio.ext_data_filled += dxfer_len; 935 936 if (io->scsiio.ext_data_filled > 937 io->scsiio.kern_total_len) { 938 xpt_print(periph->path, "%s: tag 0x%04x " 939 "fill len %u > total %u\n", 940 __func__, io->scsiio.tag_num, 941 io->scsiio.ext_data_filled, 942 io->scsiio.kern_total_len); 943 } 944 } 945 946 #ifdef CTLFEDEBUG 947 printf("%s: %s: tag %04x flags %x ptr %p len %u\n", __func__, 948 (flags & CAM_SEND_STATUS) ? "done" : "datamove", 949 atio->tag_id, flags, data_ptr, dxfer_len); 950 #endif 951 952 /* 953 * Valid combinations: 954 * - CAM_SEND_STATUS, SCATTER_VALID = 0, dxfer_len = 0, 955 * sglist_cnt = 0 956 * - CAM_SEND_STATUS = 0, SCATTER_VALID = 0, dxfer_len != 0, 957 * sglist_cnt = 0 958 * - CAM_SEND_STATUS = 0, SCATTER_VALID, dxfer_len != 0, 959 * sglist_cnt != 0 960 */ 961 #ifdef CTLFEDEBUG 962 if (((flags & CAM_SEND_STATUS) 963 && (((flags & CAM_SCATTER_VALID) != 0) 964 || (dxfer_len != 0) 965 || (csio->sglist_cnt != 0))) 966 || (((flags & CAM_SEND_STATUS) == 0) 967 && (dxfer_len == 0)) 968 || ((flags & CAM_SCATTER_VALID) 969 && (csio->sglist_cnt == 0)) 970 || (((flags & CAM_SCATTER_VALID) == 0) 971 && (csio->sglist_cnt != 0))) { 972 printf("%s: tag %04x cdb %02x flags %#x dxfer_len " 973 "%d sg %u\n", __func__, atio->tag_id, 974 atio->cdb_io.cdb_bytes[0], flags, dxfer_len, 975 csio->sglist_cnt); 976 if (io != NULL) { 977 printf("%s: tag %04x io status %#x\n", __func__, 978 atio->tag_id, io->io_hdr.status); 979 } else { 980 printf("%s: tag %04x no associated io\n", 981 __func__, atio->tag_id); 982 } 983 } 984 #endif 985 cam_fill_ctio(csio, 986 /*retries*/ 2, 987 ctlfedone, 988 flags, 989 (flags & CAM_TAG_ACTION_VALID) ? 990 MSG_SIMPLE_Q_TAG : 0, 991 atio->tag_id, 992 atio->init_id, 993 scsi_status, 994 /*data_ptr*/ data_ptr, 995 /*dxfer_len*/ dxfer_len, 996 /*timeout*/ 5 * 1000); 997 start_ccb->ccb_h.ccb_atio = atio; 998 if (((flags & CAM_SEND_STATUS) == 0) 999 && (io != NULL)) 1000 io->io_hdr.flags |= CTL_FLAG_DMA_INPROG; 1001 1002 softc->ctios_sent++; 1003 1004 xpt_action(start_ccb); 1005 1006 if ((atio->ccb_h.status & CAM_DEV_QFRZN) != 0) { 1007 cam_release_devq(periph->path, 1008 /*relsim_flags*/0, 1009 /*reduction*/0, 1010 /*timeout*/0, 1011 /*getcount_only*/0); 1012 atio->ccb_h.status &= ~CAM_DEV_QFRZN; 1013 } 1014 1015 ccb_h = TAILQ_FIRST(&softc->work_queue); 1016 } 1017 /* 1018 * If we still have work to do, ask for another CCB. Otherwise, 1019 * deactivate our callout. 1020 */ 1021 if (ccb_h != NULL) 1022 xpt_schedule(periph, /*priority*/ 1); 1023 else 1024 callout_stop(&softc->dma_callout); 1025 } 1026 1027 static void 1028 ctlfe_free_ccb(struct cam_periph *periph, union ccb *ccb) 1029 { 1030 struct ctlfe_lun_softc *softc; 1031 1032 softc = (struct ctlfe_lun_softc *)periph->softc; 1033 1034 switch (ccb->ccb_h.func_code) { 1035 case XPT_ACCEPT_TARGET_IO: 1036 softc->atios_returned++; 1037 break; 1038 case XPT_IMMEDIATE_NOTIFY: 1039 case XPT_NOTIFY_ACKNOWLEDGE: 1040 softc->inots_returned++; 1041 break; 1042 default: 1043 break; 1044 } 1045 1046 free(ccb, M_CTLFE); 1047 1048 KASSERT(softc->atios_returned <= softc->atios_sent, ("%s: " 1049 "atios_returned %ju > atios_sent %ju", __func__, 1050 softc->atios_returned, softc->atios_sent)); 1051 KASSERT(softc->inots_returned <= softc->inots_sent, ("%s: " 1052 "inots_returned %ju > inots_sent %ju", __func__, 1053 softc->inots_returned, softc->inots_sent)); 1054 1055 /* 1056 * If we have received all of our CCBs, we can release our 1057 * reference on the peripheral driver. It will probably go away 1058 * now. 1059 */ 1060 if ((softc->atios_returned == softc->atios_sent) 1061 && (softc->inots_returned == softc->inots_sent)) { 1062 cam_periph_release_locked(periph); 1063 } 1064 } 1065 1066 static void 1067 ctlfedone(struct cam_periph *periph, union ccb *done_ccb) 1068 { 1069 struct ctlfe_lun_softc *softc; 1070 struct ctlfe_softc *bus_softc; 1071 1072 #ifdef CTLFE_DEBUG 1073 printf("%s: entered, func_code = %#x, type = %#lx\n", __func__, 1074 done_ccb->ccb_h.func_code, done_ccb->ccb_h.ccb_type); 1075 #endif 1076 1077 softc = (struct ctlfe_lun_softc *)periph->softc; 1078 bus_softc = softc->parent_softc; 1079 1080 if (done_ccb->ccb_h.ccb_type == CTLFE_CCB_WAITING) { 1081 panic("shouldn't get to the CCB waiting case!"); 1082 wakeup(&done_ccb->ccb_h.cbfcnp); 1083 return; 1084 } 1085 1086 /* 1087 * If the peripheral is invalid, ATIOs and immediate notify CCBs 1088 * need to be freed. Most of the ATIOs and INOTs that come back 1089 * will be CCBs that are being returned from the SIM as a result of 1090 * our disabling the LUN. 1091 * 1092 * Other CCB types are handled in their respective cases below. 1093 */ 1094 if (periph->flags & CAM_PERIPH_INVALID) { 1095 switch (done_ccb->ccb_h.func_code) { 1096 case XPT_ACCEPT_TARGET_IO: 1097 case XPT_IMMEDIATE_NOTIFY: 1098 case XPT_NOTIFY_ACKNOWLEDGE: 1099 ctlfe_free_ccb(periph, done_ccb); 1100 return; 1101 default: 1102 break; 1103 } 1104 1105 } 1106 switch (done_ccb->ccb_h.func_code) { 1107 case XPT_ACCEPT_TARGET_IO: { 1108 union ctl_io *io; 1109 struct ccb_accept_tio *atio; 1110 1111 atio = &done_ccb->atio; 1112 1113 softc->atios_returned++; 1114 1115 /* 1116 * Allocate a ctl_io, pass it to CTL, and wait for the 1117 * datamove or done. 1118 */ 1119 io = ctl_alloc_io(bus_softc->fe.ctl_pool_ref); 1120 if (io == NULL) { 1121 atio->ccb_h.flags &= ~CAM_DIR_MASK; 1122 atio->ccb_h.flags |= CAM_DIR_NONE; 1123 1124 printf("%s: ctl_alloc_io failed!\n", __func__); 1125 1126 /* 1127 * XXX KDM need to set SCSI_STATUS_BUSY, but there 1128 * is no field in the ATIO structure to do that, 1129 * and we aren't able to allocate a ctl_io here. 1130 * What to do? 1131 */ 1132 atio->sense_len = 0; 1133 done_ccb->ccb_h.io_ptr = NULL; 1134 TAILQ_INSERT_TAIL(&softc->work_queue, &atio->ccb_h, 1135 periph_links.tqe); 1136 xpt_schedule(periph, /*priority*/ 1); 1137 break; 1138 } 1139 ctl_zero_io(io); 1140 1141 /* Save pointers on both sides */ 1142 io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = done_ccb; 1143 done_ccb->ccb_h.io_ptr = io; 1144 1145 /* 1146 * Only SCSI I/O comes down this path, resets, etc. come 1147 * down the immediate notify path below. 1148 */ 1149 io->io_hdr.io_type = CTL_IO_SCSI; 1150 io->io_hdr.nexus.initid.id = atio->init_id; 1151 io->io_hdr.nexus.targ_port = bus_softc->fe.targ_port; 1152 io->io_hdr.nexus.targ_target.id = atio->ccb_h.target_id; 1153 io->io_hdr.nexus.targ_lun = atio->ccb_h.target_lun; 1154 io->scsiio.tag_num = atio->tag_id; 1155 switch (atio->tag_action) { 1156 case CAM_TAG_ACTION_NONE: 1157 io->scsiio.tag_type = CTL_TAG_UNTAGGED; 1158 break; 1159 case MSG_SIMPLE_TASK: 1160 io->scsiio.tag_type = CTL_TAG_SIMPLE; 1161 break; 1162 case MSG_HEAD_OF_QUEUE_TASK: 1163 io->scsiio.tag_type = CTL_TAG_HEAD_OF_QUEUE; 1164 break; 1165 case MSG_ORDERED_TASK: 1166 io->scsiio.tag_type = CTL_TAG_ORDERED; 1167 break; 1168 case MSG_ACA_TASK: 1169 io->scsiio.tag_type = CTL_TAG_ACA; 1170 break; 1171 default: 1172 io->scsiio.tag_type = CTL_TAG_UNTAGGED; 1173 printf("%s: unhandled tag type %#x!!\n", __func__, 1174 atio->tag_action); 1175 break; 1176 } 1177 if (atio->cdb_len > sizeof(io->scsiio.cdb)) { 1178 printf("%s: WARNING: CDB len %d > ctl_io space %zd\n", 1179 __func__, atio->cdb_len, sizeof(io->scsiio.cdb)); 1180 } 1181 io->scsiio.cdb_len = min(atio->cdb_len, sizeof(io->scsiio.cdb)); 1182 bcopy(atio->cdb_io.cdb_bytes, io->scsiio.cdb, 1183 io->scsiio.cdb_len); 1184 1185 #ifdef CTLFEDEBUG 1186 printf("%s: %ju:%d:%ju:%d: tag %04x CDB %02x\n", __func__, 1187 (uintmax_t)io->io_hdr.nexus.initid.id, 1188 io->io_hdr.nexus.targ_port, 1189 (uintmax_t)io->io_hdr.nexus.targ_target.id, 1190 io->io_hdr.nexus.targ_lun, 1191 io->scsiio.tag_num, io->scsiio.cdb[0]); 1192 #endif 1193 1194 ctl_queue(io); 1195 break; 1196 } 1197 case XPT_CONT_TARGET_IO: { 1198 struct ccb_accept_tio *atio; 1199 union ctl_io *io; 1200 1201 atio = (struct ccb_accept_tio *)done_ccb->ccb_h.ccb_atio; 1202 io = (union ctl_io *)atio->ccb_h.io_ptr; 1203 1204 softc->ctios_returned++; 1205 #ifdef CTLFEDEBUG 1206 printf("%s: got XPT_CONT_TARGET_IO tag %#x flags %#x\n", 1207 __func__, atio->tag_id, done_ccb->ccb_h.flags); 1208 #endif 1209 /* 1210 * If we were sending status back to the initiator, free up 1211 * resources. If we were doing a datamove, call the 1212 * datamove done routine. 1213 */ 1214 if (done_ccb->ccb_h.flags & CAM_SEND_STATUS) { 1215 softc->ccbs_freed++; 1216 xpt_release_ccb(done_ccb); 1217 ctl_free_io(io); 1218 /* 1219 * For a wildcard attachment, commands can come in 1220 * with a specific target/lun. Reset the target 1221 * and LUN fields back to the wildcard values before 1222 * we send them back down to the SIM. The SIM has 1223 * a wildcard LUN enabled, not whatever target/lun 1224 * these happened to be. 1225 */ 1226 if (softc->flags & CTLFE_LUN_WILDCARD) { 1227 atio->ccb_h.target_id = CAM_TARGET_WILDCARD; 1228 atio->ccb_h.target_lun = CAM_LUN_WILDCARD; 1229 } 1230 if (periph->flags & CAM_PERIPH_INVALID) { 1231 ctlfe_free_ccb(periph, (union ccb *)atio); 1232 return; 1233 } else { 1234 xpt_action((union ccb *)atio); 1235 softc->atios_sent++; 1236 } 1237 } else { 1238 struct ctlfe_lun_cmd_info *cmd_info; 1239 struct ccb_scsiio *csio; 1240 1241 csio = &done_ccb->csio; 1242 cmd_info = (struct ctlfe_lun_cmd_info *) 1243 io->io_hdr.port_priv; 1244 1245 io->io_hdr.flags &= ~CTL_FLAG_DMA_INPROG; 1246 1247 io->scsiio.ext_data_len += csio->dxfer_len; 1248 if (io->scsiio.ext_data_len > 1249 io->scsiio.kern_total_len) { 1250 xpt_print(periph->path, "%s: tag 0x%04x " 1251 "done len %u > total %u sent %u\n", 1252 __func__, io->scsiio.tag_num, 1253 io->scsiio.ext_data_len, 1254 io->scsiio.kern_total_len, 1255 io->scsiio.ext_data_filled); 1256 } 1257 /* 1258 * Translate CAM status to CTL status. Success 1259 * does not change the overall, ctl_io status. In 1260 * that case we just set port_status to 0. If we 1261 * have a failure, though, set a data phase error 1262 * for the overall ctl_io. 1263 */ 1264 switch (done_ccb->ccb_h.status & CAM_STATUS_MASK) { 1265 case CAM_REQ_CMP: 1266 io->io_hdr.port_status = 0; 1267 break; 1268 default: 1269 /* 1270 * XXX KDM the isp(4) driver doesn't really 1271 * seem to send errors back for data 1272 * transfers that I can tell. There is one 1273 * case where it'll send CAM_REQ_CMP_ERR, 1274 * but probably not that many more cases. 1275 * So set a generic data phase error here, 1276 * like the SXP driver sets. 1277 */ 1278 io->io_hdr.port_status = 0xbad1; 1279 ctl_set_data_phase_error(&io->scsiio); 1280 /* 1281 * XXX KDM figure out residual. 1282 */ 1283 break; 1284 } 1285 /* 1286 * If we had to break this S/G list into multiple 1287 * pieces, figure out where we are in the list, and 1288 * continue sending pieces if necessary. 1289 */ 1290 if ((cmd_info->flags & CTLFE_CMD_PIECEWISE) 1291 && (io->io_hdr.port_status == 0) 1292 && (cmd_info->cur_transfer_index < 1293 io->scsiio.kern_sg_entries)) { 1294 struct ctl_sg_entry *sglist; 1295 ccb_flags flags; 1296 uint8_t scsi_status; 1297 uint8_t *data_ptr; 1298 uint32_t dxfer_len; 1299 int *ti; 1300 1301 sglist = (struct ctl_sg_entry *) 1302 io->scsiio.kern_data_ptr; 1303 ti = &cmd_info->cur_transfer_index; 1304 flags = atio->ccb_h.flags & 1305 (CAM_DIS_DISCONNECT| 1306 CAM_TAG_ACTION_VALID| 1307 CAM_DIR_MASK); 1308 1309 /* 1310 * Set the direction, relative to the initiator. 1311 */ 1312 flags &= ~CAM_DIR_MASK; 1313 if ((io->io_hdr.flags & CTL_FLAG_DATA_MASK) == 1314 CTL_FLAG_DATA_IN) 1315 flags |= CAM_DIR_IN; 1316 else 1317 flags |= CAM_DIR_OUT; 1318 1319 data_ptr = sglist[*ti].addr; 1320 dxfer_len = sglist[*ti].len; 1321 (*ti)++; 1322 1323 scsi_status = 0; 1324 1325 if (((flags & CAM_SEND_STATUS) == 0) 1326 && (dxfer_len == 0)) { 1327 printf("%s: tag %04x no status or " 1328 "len cdb = %02x\n", __func__, 1329 atio->tag_id, 1330 atio->cdb_io.cdb_bytes[0]); 1331 printf("%s: tag %04x io status %#x\n", 1332 __func__, atio->tag_id, 1333 io->io_hdr.status); 1334 } 1335 1336 cam_fill_ctio(csio, 1337 /*retries*/ 2, 1338 ctlfedone, 1339 flags, 1340 (flags & CAM_TAG_ACTION_VALID) ? 1341 MSG_SIMPLE_Q_TAG : 0, 1342 atio->tag_id, 1343 atio->init_id, 1344 scsi_status, 1345 /*data_ptr*/ data_ptr, 1346 /*dxfer_len*/ dxfer_len, 1347 /*timeout*/ 5 * 1000); 1348 1349 csio->resid = 0; 1350 csio->ccb_h.ccb_atio = atio; 1351 io->io_hdr.flags |= CTL_FLAG_DMA_INPROG; 1352 softc->ctios_sent++; 1353 xpt_action((union ccb *)csio); 1354 } else { 1355 /* 1356 * Release the CTIO. The ATIO will be sent back 1357 * down to the SIM once we send status. 1358 */ 1359 softc->ccbs_freed++; 1360 xpt_release_ccb(done_ccb); 1361 1362 /* Call the backend move done callback */ 1363 io->scsiio.be_move_done(io); 1364 } 1365 } 1366 break; 1367 } 1368 case XPT_IMMEDIATE_NOTIFY: { 1369 union ctl_io *io; 1370 struct ccb_immediate_notify *inot; 1371 cam_status status; 1372 int frozen; 1373 1374 inot = &done_ccb->cin1; 1375 1376 softc->inots_returned++; 1377 1378 frozen = (done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0; 1379 1380 printf("%s: got XPT_IMMEDIATE_NOTIFY status %#x tag %#x " 1381 "seq %#x\n", __func__, inot->ccb_h.status, 1382 inot->tag_id, inot->seq_id); 1383 1384 io = ctl_alloc_io(bus_softc->fe.ctl_pool_ref); 1385 if (io != NULL) { 1386 int send_ctl_io; 1387 1388 send_ctl_io = 1; 1389 1390 ctl_zero_io(io); 1391 io->io_hdr.io_type = CTL_IO_TASK; 1392 io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr =done_ccb; 1393 inot->ccb_h.io_ptr = io; 1394 io->io_hdr.nexus.initid.id = inot->initiator_id; 1395 io->io_hdr.nexus.targ_port = bus_softc->fe.targ_port; 1396 io->io_hdr.nexus.targ_target.id = inot->ccb_h.target_id; 1397 io->io_hdr.nexus.targ_lun = inot->ccb_h.target_lun; 1398 /* XXX KDM should this be the tag_id? */ 1399 io->taskio.tag_num = inot->seq_id; 1400 1401 status = inot->ccb_h.status & CAM_STATUS_MASK; 1402 switch (status) { 1403 case CAM_SCSI_BUS_RESET: 1404 io->taskio.task_action = CTL_TASK_BUS_RESET; 1405 break; 1406 case CAM_BDR_SENT: 1407 io->taskio.task_action = CTL_TASK_TARGET_RESET; 1408 break; 1409 case CAM_MESSAGE_RECV: 1410 switch (inot->arg) { 1411 case MSG_ABORT_TASK_SET: 1412 /* 1413 * XXX KDM this isn't currently 1414 * supported by CTL. It ends up 1415 * being a no-op. 1416 */ 1417 io->taskio.task_action = 1418 CTL_TASK_ABORT_TASK_SET; 1419 break; 1420 case MSG_TARGET_RESET: 1421 io->taskio.task_action = 1422 CTL_TASK_TARGET_RESET; 1423 break; 1424 case MSG_ABORT_TASK: 1425 io->taskio.task_action = 1426 CTL_TASK_ABORT_TASK; 1427 break; 1428 case MSG_LOGICAL_UNIT_RESET: 1429 io->taskio.task_action = 1430 CTL_TASK_LUN_RESET; 1431 break; 1432 case MSG_CLEAR_TASK_SET: 1433 /* 1434 * XXX KDM this isn't currently 1435 * supported by CTL. It ends up 1436 * being a no-op. 1437 */ 1438 io->taskio.task_action = 1439 CTL_TASK_CLEAR_TASK_SET; 1440 break; 1441 case MSG_CLEAR_ACA: 1442 io->taskio.task_action = 1443 CTL_TASK_CLEAR_ACA; 1444 break; 1445 case MSG_NOOP: 1446 send_ctl_io = 0; 1447 break; 1448 default: 1449 xpt_print(periph->path, "%s: " 1450 "unsupported message 0x%x\n", 1451 __func__, inot->arg); 1452 send_ctl_io = 0; 1453 break; 1454 } 1455 break; 1456 case CAM_REQ_ABORTED: 1457 /* 1458 * This request was sent back by the driver. 1459 * XXX KDM what do we do here? 1460 */ 1461 send_ctl_io = 0; 1462 break; 1463 default: 1464 xpt_print(periph->path, "%s: " 1465 "unsupported CAM status 0x%x\n", 1466 __func__, status); 1467 send_ctl_io = 0; 1468 break; 1469 } 1470 if (send_ctl_io != 0) { 1471 ctl_queue(io); 1472 } else { 1473 ctl_free_io(io); 1474 done_ccb->ccb_h.status = CAM_REQ_INPROG; 1475 done_ccb->ccb_h.func_code = 1476 XPT_NOTIFY_ACKNOWLEDGE; 1477 xpt_action(done_ccb); 1478 } 1479 } else { 1480 xpt_print(periph->path, "%s: could not allocate " 1481 "ctl_io for immediate notify!\n", __func__); 1482 /* requeue this to the adapter */ 1483 done_ccb->ccb_h.status = CAM_REQ_INPROG; 1484 done_ccb->ccb_h.func_code = XPT_NOTIFY_ACKNOWLEDGE; 1485 xpt_action(done_ccb); 1486 } 1487 1488 if (frozen != 0) { 1489 cam_release_devq(periph->path, 1490 /*relsim_flags*/ 0, 1491 /*opening reduction*/ 0, 1492 /*timeout*/ 0, 1493 /*getcount_only*/ 0); 1494 } 1495 break; 1496 } 1497 case XPT_NOTIFY_ACKNOWLEDGE: 1498 /* 1499 * Queue this back down to the SIM as an immediate notify. 1500 */ 1501 done_ccb->ccb_h.func_code = XPT_IMMEDIATE_NOTIFY; 1502 xpt_action(done_ccb); 1503 softc->inots_sent++; 1504 break; 1505 case XPT_ABORT: 1506 /* 1507 * XPT_ABORT is an immediate CCB, we shouldn't get here. 1508 */ 1509 panic("%s: XPT_ABORT CCB returned!", __func__); 1510 break; 1511 case XPT_SET_SIM_KNOB: 1512 case XPT_GET_SIM_KNOB: 1513 break; 1514 default: 1515 panic("%s: unexpected CCB type %#x", __func__, 1516 done_ccb->ccb_h.func_code); 1517 break; 1518 } 1519 } 1520 1521 static void 1522 ctlfe_onoffline(void *arg, int online) 1523 { 1524 struct ctlfe_softc *bus_softc; 1525 union ccb *ccb; 1526 cam_status status; 1527 struct cam_path *path; 1528 struct cam_sim *sim; 1529 int set_wwnn; 1530 1531 bus_softc = (struct ctlfe_softc *)arg; 1532 1533 set_wwnn = 0; 1534 1535 status = xpt_create_path(&path, /*periph*/ NULL, bus_softc->path_id, 1536 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 1537 if (status != CAM_REQ_CMP) { 1538 printf("%s: unable to create path!\n", __func__); 1539 return; 1540 } 1541 ccb = (union ccb *)malloc(sizeof(*ccb), M_TEMP, M_WAITOK | M_ZERO); 1542 if (ccb == NULL) { 1543 printf("%s: unable to malloc CCB!\n", __func__); 1544 xpt_free_path(path); 1545 return; 1546 } 1547 xpt_setup_ccb(&ccb->ccb_h, path, /*priority*/ 1); 1548 1549 sim = xpt_path_sim(path); 1550 1551 /* 1552 * Copan WWN format: 1553 * 1554 * Bits 63-60: 0x5 NAA, IEEE registered name 1555 * Bits 59-36: 0x000ED5 IEEE Company name assigned to Copan 1556 * Bits 35-12: Copan SSN (Sequential Serial Number) 1557 * Bits 11-8: Type of port: 1558 * 1 == N-Port 1559 * 2 == F-Port 1560 * 3 == NL-Port 1561 * Bits 7-0: 0 == Node Name, >0 == Port Number 1562 */ 1563 1564 if (online != 0) { 1565 1566 ccb->ccb_h.func_code = XPT_GET_SIM_KNOB; 1567 1568 CAM_SIM_LOCK(sim); 1569 1570 xpt_action(ccb); 1571 1572 CAM_SIM_UNLOCK(sim); 1573 1574 if ((ccb->knob.xport_specific.valid & KNOB_VALID_ADDRESS) != 0){ 1575 #ifdef RANDOM_WWNN 1576 uint64_t random_bits; 1577 #endif 1578 1579 printf("%s: %s current WWNN %#jx\n", __func__, 1580 bus_softc->port_name, 1581 ccb->knob.xport_specific.fc.wwnn); 1582 printf("%s: %s current WWPN %#jx\n", __func__, 1583 bus_softc->port_name, 1584 ccb->knob.xport_specific.fc.wwpn); 1585 1586 #ifdef RANDOM_WWNN 1587 arc4rand(&random_bits, sizeof(random_bits), 0); 1588 #endif 1589 1590 /* 1591 * XXX KDM this is a bit of a kludge for now. We 1592 * take the current WWNN/WWPN from the card, and 1593 * replace the company identifier and the NL-Port 1594 * indicator and the port number (for the WWPN). 1595 * This should be replaced later with ddb_GetWWNN, 1596 * or possibly a more centralized scheme. (It 1597 * would be nice to have the WWNN/WWPN for each 1598 * port stored in the ctl_frontend structure.) 1599 */ 1600 #ifdef RANDOM_WWNN 1601 ccb->knob.xport_specific.fc.wwnn = 1602 (random_bits & 1603 0x0000000fffffff00ULL) | 1604 /* Company ID */ 0x5000ED5000000000ULL | 1605 /* NL-Port */ 0x0300; 1606 ccb->knob.xport_specific.fc.wwpn = 1607 (random_bits & 1608 0x0000000fffffff00ULL) | 1609 /* Company ID */ 0x5000ED5000000000ULL | 1610 /* NL-Port */ 0x3000 | 1611 /* Port Num */ (bus_softc->fe.targ_port & 0xff); 1612 1613 /* 1614 * This is a bit of an API break/reversal, but if 1615 * we're doing the random WWNN that's a little 1616 * different anyway. So record what we're actually 1617 * using with the frontend code so it's reported 1618 * accurately. 1619 */ 1620 bus_softc->fe.wwnn = 1621 ccb->knob.xport_specific.fc.wwnn; 1622 bus_softc->fe.wwpn = 1623 ccb->knob.xport_specific.fc.wwpn; 1624 set_wwnn = 1; 1625 #else /* RANDOM_WWNN */ 1626 /* 1627 * If the user has specified a WWNN/WWPN, send them 1628 * down to the SIM. Otherwise, record what the SIM 1629 * has reported. 1630 */ 1631 if ((bus_softc->fe.wwnn != 0) 1632 && (bus_softc->fe.wwpn != 0)) { 1633 ccb->knob.xport_specific.fc.wwnn = 1634 bus_softc->fe.wwnn; 1635 ccb->knob.xport_specific.fc.wwpn = 1636 bus_softc->fe.wwpn; 1637 set_wwnn = 1; 1638 } else { 1639 bus_softc->fe.wwnn = 1640 ccb->knob.xport_specific.fc.wwnn; 1641 bus_softc->fe.wwpn = 1642 ccb->knob.xport_specific.fc.wwpn; 1643 } 1644 #endif /* RANDOM_WWNN */ 1645 1646 1647 if (set_wwnn != 0) { 1648 printf("%s: %s new WWNN %#jx\n", __func__, 1649 bus_softc->port_name, 1650 ccb->knob.xport_specific.fc.wwnn); 1651 printf("%s: %s new WWPN %#jx\n", __func__, 1652 bus_softc->port_name, 1653 ccb->knob.xport_specific.fc.wwpn); 1654 } 1655 } else { 1656 printf("%s: %s has no valid WWNN/WWPN\n", __func__, 1657 bus_softc->port_name); 1658 } 1659 } 1660 ccb->ccb_h.func_code = XPT_SET_SIM_KNOB; 1661 ccb->knob.xport_specific.valid = KNOB_VALID_ROLE; 1662 if (set_wwnn != 0) 1663 ccb->knob.xport_specific.valid |= KNOB_VALID_ADDRESS; 1664 1665 if (online != 0) 1666 ccb->knob.xport_specific.fc.role = KNOB_ROLE_TARGET; 1667 else 1668 ccb->knob.xport_specific.fc.role = KNOB_ROLE_NONE; 1669 1670 1671 CAM_SIM_LOCK(sim); 1672 1673 xpt_action(ccb); 1674 1675 CAM_SIM_UNLOCK(sim); 1676 1677 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 1678 printf("%s: SIM %s (path id %d) target %s failed with " 1679 "status %#x\n", 1680 __func__, bus_softc->port_name, bus_softc->path_id, 1681 (online != 0) ? "enable" : "disable", 1682 ccb->ccb_h.status); 1683 } else { 1684 printf("%s: SIM %s (path id %d) target %s succeeded\n", 1685 __func__, bus_softc->port_name, bus_softc->path_id, 1686 (online != 0) ? "enable" : "disable"); 1687 } 1688 1689 free(ccb, M_TEMP); 1690 xpt_free_path(path); 1691 1692 return; 1693 } 1694 1695 static void 1696 ctlfe_online(void *arg) 1697 { 1698 ctlfe_onoffline(arg, /*online*/ 1); 1699 } 1700 1701 static void 1702 ctlfe_offline(void *arg) 1703 { 1704 ctlfe_onoffline(arg, /*online*/ 0); 1705 } 1706 1707 static int 1708 ctlfe_targ_enable(void *arg, struct ctl_id targ_id) 1709 { 1710 return (0); 1711 } 1712 1713 static int 1714 ctlfe_targ_disable(void *arg, struct ctl_id targ_id) 1715 { 1716 return (0); 1717 } 1718 1719 /* 1720 * This will get called to enable a LUN on every bus that is attached to 1721 * CTL. So we only need to create a path/periph for this particular bus. 1722 */ 1723 static int 1724 ctlfe_lun_enable(void *arg, struct ctl_id targ_id, int lun_id) 1725 { 1726 struct ctlfe_softc *bus_softc; 1727 struct ctlfe_lun_softc *softc; 1728 struct cam_path *path; 1729 struct cam_periph *periph; 1730 struct cam_sim *sim; 1731 cam_status status; 1732 1733 1734 bus_softc = (struct ctlfe_softc *)arg; 1735 1736 status = xpt_create_path_unlocked(&path, /*periph*/ NULL, 1737 bus_softc->path_id, 1738 targ_id.id, 1739 lun_id); 1740 /* XXX KDM need some way to return status to CTL here? */ 1741 if (status != CAM_REQ_CMP) { 1742 printf("%s: could not create path, status %#x\n", __func__, 1743 status); 1744 return (1); 1745 } 1746 1747 softc = malloc(sizeof(*softc), M_CTLFE, M_WAITOK | M_ZERO); 1748 if (softc == NULL) { 1749 printf("%s: could not allocate %zd bytes for softc\n", 1750 __func__, sizeof(*softc)); 1751 xpt_free_path(path); 1752 return (1); 1753 } 1754 sim = xpt_path_sim(path); 1755 mtx_lock(sim->mtx); 1756 periph = cam_periph_find(path, "ctl"); 1757 if (periph != NULL) { 1758 /* We've already got a periph, no need to alloc a new one. */ 1759 xpt_free_path(path); 1760 free(softc, M_CTLFE); 1761 mtx_unlock(sim->mtx); 1762 return (0); 1763 } 1764 1765 softc->parent_softc = bus_softc; 1766 STAILQ_INSERT_TAIL(&bus_softc->lun_softc_list, softc, links); 1767 1768 status = cam_periph_alloc(ctlferegister, 1769 ctlfeoninvalidate, 1770 ctlfecleanup, 1771 ctlfestart, 1772 "ctl", 1773 CAM_PERIPH_BIO, 1774 path, 1775 ctlfeasync, 1776 0, 1777 softc); 1778 1779 mtx_unlock(sim->mtx); 1780 1781 xpt_free_path(path); 1782 1783 return (0); 1784 } 1785 1786 /* 1787 * XXX KDM we disable LUN removal here. The problem is that the isp(4) 1788 * driver doesn't currently handle LUN removal properly. We need to keep 1789 * enough state here at the peripheral level even after LUNs have been 1790 * removed inside CTL. 1791 * 1792 * Once the isp(4) driver is fixed, this can be re-enabled. 1793 */ 1794 static int 1795 ctlfe_lun_disable(void *arg, struct ctl_id targ_id, int lun_id) 1796 { 1797 #ifdef NOTYET 1798 struct ctlfe_softc *softc; 1799 struct ctlfe_lun_softc *lun_softc; 1800 1801 softc = (struct ctlfe_softc *)arg; 1802 1803 mtx_lock(softc->sim->mtx); 1804 STAILQ_FOREACH(lun_softc, &softc->lun_softc_list, links) { 1805 struct cam_path *path; 1806 1807 path = lun_softc->periph->path; 1808 1809 if ((xpt_path_target_id(path) == targ_id.id) 1810 && (xpt_path_lun_id(path) == lun_id)) { 1811 break; 1812 } 1813 } 1814 if (lun_softc == NULL) { 1815 mtx_unlock(softc->sim->mtx); 1816 printf("%s: can't find target %d lun %d\n", __func__, 1817 targ_id.id, lun_id); 1818 return (1); 1819 } 1820 1821 cam_periph_invalidate(lun_softc->periph); 1822 1823 mtx_unlock(softc->sim->mtx); 1824 #endif 1825 1826 return (0); 1827 } 1828 1829 static void 1830 ctlfe_dump_sim(struct cam_sim *sim) 1831 { 1832 int i; 1833 1834 printf("%s%d: max tagged openings: %d, max dev openings: %d\n", 1835 sim->sim_name, sim->unit_number, 1836 sim->max_tagged_dev_openings, sim->max_dev_openings); 1837 printf("%s%d: max_ccbs: %u, ccb_count: %u\n", 1838 sim->sim_name, sim->unit_number, 1839 sim->max_ccbs, sim->ccb_count); 1840 printf("%s%d: ccb_freeq is %sempty\n", 1841 sim->sim_name, sim->unit_number, 1842 (SLIST_FIRST(&sim->ccb_freeq) == NULL) ? "" : "NOT "); 1843 printf("%s%d: alloc_queue.entries %d, alloc_openings %d\n", 1844 sim->sim_name, sim->unit_number, 1845 sim->devq->alloc_queue.entries, sim->devq->alloc_openings); 1846 printf("%s%d: qfrozen_cnt:", sim->sim_name, sim->unit_number); 1847 for (i = 0; i < CAM_RL_VALUES; i++) { 1848 printf("%s%u", (i != 0) ? ":" : "", 1849 sim->devq->alloc_queue.qfrozen_cnt[i]); 1850 } 1851 printf("\n"); 1852 } 1853 1854 /* 1855 * Assumes that the SIM lock is held. 1856 */ 1857 static void 1858 ctlfe_dump_queue(struct ctlfe_lun_softc *softc) 1859 { 1860 struct ccb_hdr *hdr; 1861 struct cam_periph *periph; 1862 int num_items; 1863 1864 periph = softc->periph; 1865 num_items = 0; 1866 1867 TAILQ_FOREACH(hdr, &softc->work_queue, periph_links.tqe) { 1868 union ctl_io *io; 1869 1870 io = hdr->io_ptr; 1871 1872 num_items++; 1873 1874 /* 1875 * This can happen when we get an ATIO but can't allocate 1876 * a ctl_io. See the XPT_ACCEPT_TARGET_IO case in ctlfedone(). 1877 */ 1878 if (io == NULL) { 1879 struct ccb_scsiio *csio; 1880 1881 csio = (struct ccb_scsiio *)hdr; 1882 1883 xpt_print(periph->path, "CCB %#x ctl_io allocation " 1884 "failed\n", csio->tag_id); 1885 continue; 1886 } 1887 1888 /* 1889 * Only regular SCSI I/O is put on the work 1890 * queue, so we can print sense here. There may be no 1891 * sense if it's no the queue for a DMA, but this serves to 1892 * print out the CCB as well. 1893 * 1894 * XXX KDM switch this over to scsi_sense_print() when 1895 * CTL is merged in with CAM. 1896 */ 1897 ctl_io_error_print(io, NULL); 1898 1899 /* 1900 * We're sending status back to the 1901 * initiator, so we're on the queue waiting 1902 * for a CTIO to do that. 1903 */ 1904 if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_STATUS_NONE) 1905 continue; 1906 1907 /* 1908 * Otherwise, we're on the queue waiting to 1909 * do a data transfer. 1910 */ 1911 xpt_print(periph->path, "Total %u, Current %u, Resid %u\n", 1912 io->scsiio.kern_total_len, io->scsiio.kern_data_len, 1913 io->scsiio.kern_data_resid); 1914 } 1915 1916 xpt_print(periph->path, "%d requests total waiting for CCBs\n", 1917 num_items); 1918 xpt_print(periph->path, "%ju CCBs oustanding (%ju allocated, %ju " 1919 "freed)\n", (uintmax_t)(softc->ccbs_alloced - 1920 softc->ccbs_freed), (uintmax_t)softc->ccbs_alloced, 1921 (uintmax_t)softc->ccbs_freed); 1922 xpt_print(periph->path, "%ju CTIOs outstanding (%ju sent, %ju " 1923 "returned\n", (uintmax_t)(softc->ctios_sent - 1924 softc->ctios_returned), softc->ctios_sent, 1925 softc->ctios_returned); 1926 } 1927 1928 /* 1929 * This function is called when we fail to get a CCB for a DMA or status return 1930 * to the initiator within the specified time period. 1931 * 1932 * The callout code should insure that we hold the sim mutex here. 1933 */ 1934 static void 1935 ctlfe_dma_timeout(void *arg) 1936 { 1937 struct ctlfe_lun_softc *softc; 1938 struct cam_periph *periph; 1939 struct cam_sim *sim; 1940 int num_queued; 1941 1942 softc = (struct ctlfe_lun_softc *)arg; 1943 periph = softc->periph; 1944 sim = xpt_path_sim(periph->path); 1945 num_queued = 0; 1946 1947 /* 1948 * Nothing to do... 1949 */ 1950 if (TAILQ_FIRST(&softc->work_queue) == NULL) { 1951 xpt_print(periph->path, "TIMEOUT triggered after %d " 1952 "seconds, but nothing on work queue??\n", 1953 CTLFE_DMA_TIMEOUT); 1954 return; 1955 } 1956 1957 xpt_print(periph->path, "TIMEOUT (%d seconds) waiting for DMA to " 1958 "start\n", CTLFE_DMA_TIMEOUT); 1959 1960 ctlfe_dump_queue(softc); 1961 1962 ctlfe_dump_sim(sim); 1963 1964 xpt_print(periph->path, "calling xpt_schedule() to attempt to " 1965 "unstick our queue\n"); 1966 1967 xpt_schedule(periph, /*priority*/ 1); 1968 1969 xpt_print(periph->path, "xpt_schedule() call complete\n"); 1970 } 1971 1972 /* 1973 * Datamove/done routine called by CTL. Put ourselves on the queue to 1974 * receive a CCB from CAM so we can queue the continue I/O request down 1975 * to the adapter. 1976 */ 1977 static void 1978 ctlfe_datamove_done(union ctl_io *io) 1979 { 1980 union ccb *ccb; 1981 struct cam_sim *sim; 1982 struct cam_periph *periph; 1983 struct ctlfe_lun_softc *softc; 1984 1985 ccb = io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr; 1986 1987 sim = xpt_path_sim(ccb->ccb_h.path); 1988 1989 mtx_lock(sim->mtx); 1990 1991 periph = xpt_path_periph(ccb->ccb_h.path); 1992 1993 softc = (struct ctlfe_lun_softc *)periph->softc; 1994 1995 if (io->io_hdr.io_type == CTL_IO_TASK) { 1996 /* 1997 * Task management commands don't require any further 1998 * communication back to the adapter. Requeue the CCB 1999 * to the adapter, and free the CTL I/O. 2000 */ 2001 xpt_print(ccb->ccb_h.path, "%s: returning task I/O " 2002 "tag %#x seq %#x\n", __func__, 2003 ccb->cin1.tag_id, ccb->cin1.seq_id); 2004 /* 2005 * Send the notify acknowledge down to the SIM, to let it 2006 * know we processed the task management command. 2007 */ 2008 ccb->ccb_h.status = CAM_REQ_INPROG; 2009 ccb->ccb_h.func_code = XPT_NOTIFY_ACKNOWLEDGE; 2010 xpt_action(ccb); 2011 ctl_free_io(io); 2012 } else { 2013 if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_STATUS_NONE) 2014 io->io_hdr.flags |= CTL_FLAG_STATUS_QUEUED; 2015 else 2016 io->io_hdr.flags |= CTL_FLAG_DMA_QUEUED; 2017 2018 TAILQ_INSERT_TAIL(&softc->work_queue, &ccb->ccb_h, 2019 periph_links.tqe); 2020 2021 /* 2022 * Reset the timeout for our latest active DMA. 2023 */ 2024 callout_reset(&softc->dma_callout, 2025 CTLFE_DMA_TIMEOUT * hz, 2026 ctlfe_dma_timeout, softc); 2027 /* 2028 * Ask for the CAM transport layer to send us a CCB to do 2029 * the DMA or send status, unless ctlfe_dma_enabled is set 2030 * to 0. 2031 */ 2032 if (ctlfe_dma_enabled != 0) 2033 xpt_schedule(periph, /*priority*/ 1); 2034 } 2035 2036 mtx_unlock(sim->mtx); 2037 } 2038 2039 static void 2040 ctlfe_dump(void) 2041 { 2042 struct ctlfe_softc *bus_softc; 2043 2044 STAILQ_FOREACH(bus_softc, &ctlfe_softc_list, links) { 2045 struct ctlfe_lun_softc *lun_softc; 2046 2047 ctlfe_dump_sim(bus_softc->sim); 2048 2049 STAILQ_FOREACH(lun_softc, &bus_softc->lun_softc_list, links) { 2050 ctlfe_dump_queue(lun_softc); 2051 } 2052 } 2053 } 2054