ocs_cam.c revision 367469
1/*- 2 * Copyright (c) 2017 Broadcom. All rights reserved. 3 * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright notice, 12 * this list of conditions and the following disclaimer in the documentation 13 * and/or other materials provided with the distribution. 14 * 15 * 3. Neither the name of the copyright holder nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 * 31 * $FreeBSD: stable/11/sys/dev/ocs_fc/ocs_cam.c 367469 2020-11-08 00:31:49Z mav $ 32 */ 33 34/** 35 * @defgroup scsi_api_target SCSI Target API 36 * @defgroup scsi_api_initiator SCSI Initiator API 37 * @defgroup cam_api Common Access Method (CAM) API 38 * @defgroup cam_io CAM IO 39 */ 40 41/** 42 * @file 43 * Provides CAM functionality. 44 */ 45 46#include "ocs.h" 47#include "ocs_scsi.h" 48#include "ocs_device.h" 49 50/* Default IO timeout value for initiators is 30 seconds */ 51#define OCS_CAM_IO_TIMEOUT 30 52 53typedef struct { 54 ocs_scsi_sgl_t *sgl; 55 uint32_t sgl_max; 56 uint32_t sgl_count; 57 int32_t rc; 58} ocs_dmamap_load_arg_t; 59 60static void ocs_action(struct cam_sim *, union ccb *); 61static void ocs_poll(struct cam_sim *); 62 63static ocs_tgt_resource_t *ocs_tgt_resource_get(ocs_fcport *, 64 struct ccb_hdr *, uint32_t *); 65static int32_t ocs_tgt_resource_abort(struct ocs_softc *, ocs_tgt_resource_t *); 66static uint32_t ocs_abort_initiator_io(struct ocs_softc *ocs, union ccb *accb); 67static void ocs_abort_inot(struct ocs_softc *ocs, union ccb *ccb); 68static void ocs_abort_atio(struct ocs_softc *ocs, union ccb *ccb); 69static int32_t ocs_target_tmf_cb(ocs_io_t *, ocs_scsi_io_status_e, uint32_t, void *); 70static int32_t ocs_io_abort_cb(ocs_io_t *, ocs_scsi_io_status_e, uint32_t, void *); 71static int32_t ocs_task_set_full_or_busy(ocs_io_t *io); 72static int32_t ocs_initiator_tmf_cb(ocs_io_t *, ocs_scsi_io_status_e, 73 ocs_scsi_cmd_resp_t *, uint32_t, void *); 74static uint32_t 75ocs_fcp_change_role(struct ocs_softc *ocs, ocs_fcport *fcp, uint32_t new_role); 76 77static void ocs_ldt(void *arg); 78static void ocs_ldt_task(void *arg, int pending); 79static void ocs_delete_target(ocs_t *ocs, ocs_fcport *fcp, int tgt); 80uint32_t ocs_add_new_tgt(ocs_node_t *node, ocs_fcport *fcp); 81uint32_t ocs_update_tgt(ocs_node_t *node, ocs_fcport *fcp, uint32_t tgt_id); 82 83int32_t ocs_tgt_find(ocs_fcport *fcp, ocs_node_t *node); 84 85static inline ocs_io_t *ocs_scsi_find_io(struct ocs_softc *ocs, uint32_t tag) 86{ 87 88 return ocs_io_get_instance(ocs, tag); 89} 90 91static inline void ocs_target_io_free(ocs_io_t *io) 92{ 93 io->tgt_io.state = OCS_CAM_IO_FREE; 94 io->tgt_io.flags = 0; 95 io->tgt_io.app = NULL; 96 ocs_scsi_io_complete(io); 97 if(io->ocs->io_in_use != 0) 98 atomic_subtract_acq_32(&io->ocs->io_in_use, 1); 99} 100 101static int32_t 102ocs_attach_port(ocs_t *ocs, int chan) 103{ 104 105 struct cam_sim *sim = NULL; 106 struct cam_path *path = NULL; 107 uint32_t max_io = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS); 108 ocs_fcport *fcp = FCPORT(ocs, chan); 109 110 if (NULL == (sim = cam_sim_alloc(ocs_action, ocs_poll, 111 device_get_name(ocs->dev), ocs, 112 device_get_unit(ocs->dev), &ocs->sim_lock, 113 max_io, max_io, ocs->devq))) { 114 device_printf(ocs->dev, "Can't allocate SIM\n"); 115 return 1; 116 } 117 118 mtx_lock(&ocs->sim_lock); 119 if (CAM_SUCCESS != xpt_bus_register(sim, ocs->dev, chan)) { 120 device_printf(ocs->dev, "Can't register bus %d\n", 0); 121 mtx_unlock(&ocs->sim_lock); 122 cam_sim_free(sim, FALSE); 123 return 1; 124 } 125 mtx_unlock(&ocs->sim_lock); 126 127 if (CAM_REQ_CMP != xpt_create_path(&path, NULL, cam_sim_path(sim), 128 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)) { 129 device_printf(ocs->dev, "Can't create path\n"); 130 xpt_bus_deregister(cam_sim_path(sim)); 131 mtx_unlock(&ocs->sim_lock); 132 cam_sim_free(sim, FALSE); 133 return 1; 134 } 135 136 fcp->ocs = ocs; 137 fcp->sim = sim; 138 fcp->path = path; 139 140 callout_init_mtx(&fcp->ldt, &ocs->sim_lock, 0); 141 TASK_INIT(&fcp->ltask, 1, ocs_ldt_task, fcp); 142 143 return 0; 144} 145 146static int32_t 147ocs_detach_port(ocs_t *ocs, int32_t chan) 148{ 149 ocs_fcport *fcp = NULL; 150 struct cam_sim *sim = NULL; 151 struct cam_path *path = NULL; 152 fcp = FCPORT(ocs, chan); 153 154 sim = fcp->sim; 155 path = fcp->path; 156 157 callout_drain(&fcp->ldt); 158 ocs_ldt_task(fcp, 0); 159 160 if (fcp->sim) { 161 mtx_lock(&ocs->sim_lock); 162 ocs_tgt_resource_abort(ocs, &fcp->targ_rsrc_wildcard); 163 if (path) { 164 xpt_async(AC_LOST_DEVICE, path, NULL); 165 xpt_free_path(path); 166 fcp->path = NULL; 167 } 168 xpt_bus_deregister(cam_sim_path(sim)); 169 170 cam_sim_free(sim, FALSE); 171 fcp->sim = NULL; 172 mtx_unlock(&ocs->sim_lock); 173 } 174 175 return 0; 176} 177 178int32_t 179ocs_cam_attach(ocs_t *ocs) 180{ 181 struct cam_devq *devq = NULL; 182 int i = 0; 183 uint32_t max_io = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS); 184 185 if (NULL == (devq = cam_simq_alloc(max_io))) { 186 device_printf(ocs->dev, "Can't allocate SIMQ\n"); 187 return -1; 188 } 189 190 ocs->devq = devq; 191 192 if (mtx_initialized(&ocs->sim_lock) == 0) { 193 mtx_init(&ocs->sim_lock, "ocs_sim_lock", NULL, MTX_DEF); 194 } 195 196 for (i = 0; i < (ocs->num_vports + 1); i++) { 197 if (ocs_attach_port(ocs, i)) { 198 ocs_log_err(ocs, "Attach port failed for chan: %d\n", i); 199 goto detach_port; 200 } 201 } 202 203 ocs->io_high_watermark = max_io; 204 ocs->io_in_use = 0; 205 return 0; 206 207detach_port: 208 while (--i >= 0) { 209 ocs_detach_port(ocs, i); 210 } 211 212 cam_simq_free(ocs->devq); 213 214 if (mtx_initialized(&ocs->sim_lock)) 215 mtx_destroy(&ocs->sim_lock); 216 217 return 1; 218} 219 220int32_t 221ocs_cam_detach(ocs_t *ocs) 222{ 223 int i = 0; 224 225 for (i = (ocs->num_vports); i >= 0; i--) { 226 ocs_detach_port(ocs, i); 227 } 228 229 cam_simq_free(ocs->devq); 230 231 if (mtx_initialized(&ocs->sim_lock)) 232 mtx_destroy(&ocs->sim_lock); 233 234 return 0; 235} 236 237/*************************************************************************** 238 * Functions required by SCSI base driver API 239 */ 240 241/** 242 * @ingroup scsi_api_target 243 * @brief Attach driver to the BSD SCSI layer (a.k.a CAM) 244 * 245 * Allocates + initializes CAM related resources and attaches to the CAM 246 * 247 * @param ocs the driver instance's software context 248 * 249 * @return 0 on success, non-zero otherwise 250 */ 251int32_t 252ocs_scsi_tgt_new_device(ocs_t *ocs) 253{ 254 ocs->enable_task_set_full = ocs_scsi_get_property(ocs, 255 OCS_SCSI_ENABLE_TASK_SET_FULL); 256 ocs_log_debug(ocs, "task set full processing is %s\n", 257 ocs->enable_task_set_full ? "enabled" : "disabled"); 258 259 return 0; 260} 261 262/** 263 * @ingroup scsi_api_target 264 * @brief Tears down target members of ocs structure. 265 * 266 * Called by OS code when device is removed. 267 * 268 * @param ocs pointer to ocs 269 * 270 * @return returns 0 for success, a negative error code value for failure. 271 */ 272int32_t 273ocs_scsi_tgt_del_device(ocs_t *ocs) 274{ 275 276 return 0; 277} 278 279/** 280 * @ingroup scsi_api_target 281 * @brief accept new domain notification 282 * 283 * Called by base drive when new domain is discovered. A target-server 284 * will use this call to prepare for new remote node notifications 285 * arising from ocs_scsi_new_initiator(). 286 * 287 * The domain context has an element <b>ocs_scsi_tgt_domain_t tgt_domain</b> 288 * which is declared by the target-server code and is used for target-server 289 * private data. 290 * 291 * This function will only be called if the base-driver has been enabled for 292 * target capability. 293 * 294 * Note that this call is made to target-server backends, 295 * the ocs_scsi_ini_new_domain() function is called to initiator-client backends. 296 * 297 * @param domain pointer to domain 298 * 299 * @return returns 0 for success, a negative error code value for failure. 300 */ 301int32_t 302ocs_scsi_tgt_new_domain(ocs_domain_t *domain) 303{ 304 return 0; 305} 306 307/** 308 * @ingroup scsi_api_target 309 * @brief accept domain lost notification 310 * 311 * Called by base-driver when a domain goes away. A target-server will 312 * use this call to clean up all domain scoped resources. 313 * 314 * Note that this call is made to target-server backends, 315 * the ocs_scsi_ini_del_domain() function is called to initiator-client backends. 316 * 317 * @param domain pointer to domain 318 * 319 * @return returns 0 for success, a negative error code value for failure. 320 */ 321void 322ocs_scsi_tgt_del_domain(ocs_domain_t *domain) 323{ 324} 325 326 327/** 328 * @ingroup scsi_api_target 329 * @brief accept new sli port (sport) notification 330 * 331 * Called by base drive when new sport is discovered. A target-server 332 * will use this call to prepare for new remote node notifications 333 * arising from ocs_scsi_new_initiator(). 334 * 335 * The domain context has an element <b>ocs_scsi_tgt_sport_t tgt_sport</b> 336 * which is declared by the target-server code and is used for 337 * target-server private data. 338 * 339 * This function will only be called if the base-driver has been enabled for 340 * target capability. 341 * 342 * Note that this call is made to target-server backends, 343 * the ocs_scsi_tgt_new_domain() is called to initiator-client backends. 344 * 345 * @param sport pointer to SLI port 346 * 347 * @return returns 0 for success, a negative error code value for failure. 348 */ 349int32_t 350ocs_scsi_tgt_new_sport(ocs_sport_t *sport) 351{ 352 ocs_t *ocs = sport->ocs; 353 354 if(!sport->is_vport) { 355 sport->tgt_data = FCPORT(ocs, 0); 356 } 357 358 return 0; 359} 360 361/** 362 * @ingroup scsi_api_target 363 * @brief accept SLI port gone notification 364 * 365 * Called by base-driver when a sport goes away. A target-server will 366 * use this call to clean up all sport scoped resources. 367 * 368 * Note that this call is made to target-server backends, 369 * the ocs_scsi_ini_del_sport() is called to initiator-client backends. 370 * 371 * @param sport pointer to SLI port 372 * 373 * @return returns 0 for success, a negative error code value for failure. 374 */ 375void 376ocs_scsi_tgt_del_sport(ocs_sport_t *sport) 377{ 378 return; 379} 380 381/** 382 * @ingroup scsi_api_target 383 * @brief receive notification of a new SCSI initiator node 384 * 385 * Sent by base driver to notify a target-server of the presense of a new 386 * remote initiator. The target-server may use this call to prepare for 387 * inbound IO from this node. 388 * 389 * The ocs_node_t structure has and elment of type ocs_scsi_tgt_node_t named 390 * tgt_node that is declared and used by a target-server for private 391 * information. 392 * 393 * This function is only called if the target capability is enabled in driver. 394 * 395 * @param node pointer to new remote initiator node 396 * 397 * @return returns 0 for success, a negative error code value for failure. 398 * 399 * @note 400 */ 401int32_t 402ocs_scsi_new_initiator(ocs_node_t *node) 403{ 404 ocs_t *ocs = node->ocs; 405 struct ac_contract ac; 406 struct ac_device_changed *adc; 407 408 ocs_fcport *fcp = NULL; 409 410 fcp = node->sport->tgt_data; 411 if (fcp == NULL) { 412 ocs_log_err(ocs, "FCP is NULL \n"); 413 return 1; 414 } 415 416 /* 417 * Update the IO watermark by decrementing it by the 418 * number of IOs reserved for each initiator. 419 */ 420 atomic_subtract_acq_32(&ocs->io_high_watermark, OCS_RSVD_INI_IO); 421 422 ac.contract_number = AC_CONTRACT_DEV_CHG; 423 adc = (struct ac_device_changed *) ac.contract_data; 424 adc->wwpn = ocs_node_get_wwpn(node); 425 adc->port = node->rnode.fc_id; 426 adc->target = node->instance_index; 427 adc->arrived = 1; 428 xpt_async(AC_CONTRACT, fcp->path, &ac); 429 430 return 0; 431} 432 433/** 434 * @ingroup scsi_api_target 435 * @brief validate new initiator 436 * 437 * Sent by base driver to validate a remote initiatiator. The target-server 438 * returns TRUE if this initiator should be accepted. 439 * 440 * This function is only called if the target capability is enabled in driver. 441 * 442 * @param node pointer to remote initiator node to validate 443 * 444 * @return TRUE if initiator should be accepted, FALSE if it should be rejected 445 * 446 * @note 447 */ 448 449int32_t 450ocs_scsi_validate_initiator(ocs_node_t *node) 451{ 452 return 1; 453} 454 455/** 456 * @ingroup scsi_api_target 457 * @brief Delete a SCSI initiator node 458 * 459 * Sent by base driver to notify a target-server that a remote initiator 460 * is now gone. The base driver will have terminated all outstanding IOs 461 * and the target-server will receive appropriate completions. 462 * 463 * This function is only called if the base driver is enabled for 464 * target capability. 465 * 466 * @param node pointer node being deleted 467 * @param reason Reason why initiator is gone. 468 * 469 * @return OCS_SCSI_CALL_COMPLETE to indicate that all work was completed 470 * 471 * @note 472 */ 473int32_t 474ocs_scsi_del_initiator(ocs_node_t *node, ocs_scsi_del_initiator_reason_e reason) 475{ 476 ocs_t *ocs = node->ocs; 477 478 struct ac_contract ac; 479 struct ac_device_changed *adc; 480 ocs_fcport *fcp = NULL; 481 482 fcp = node->sport->tgt_data; 483 if (fcp == NULL) { 484 ocs_log_err(ocs, "FCP is NULL \n"); 485 return 1; 486 } 487 488 ac.contract_number = AC_CONTRACT_DEV_CHG; 489 adc = (struct ac_device_changed *) ac.contract_data; 490 adc->wwpn = ocs_node_get_wwpn(node); 491 adc->port = node->rnode.fc_id; 492 adc->target = node->instance_index; 493 adc->arrived = 0; 494 xpt_async(AC_CONTRACT, fcp->path, &ac); 495 496 497 if (reason == OCS_SCSI_INITIATOR_MISSING) { 498 return OCS_SCSI_CALL_COMPLETE; 499 } 500 501 /* 502 * Update the IO watermark by incrementing it by the 503 * number of IOs reserved for each initiator. 504 */ 505 atomic_add_acq_32(&ocs->io_high_watermark, OCS_RSVD_INI_IO); 506 507 return OCS_SCSI_CALL_COMPLETE; 508} 509 510/** 511 * @ingroup scsi_api_target 512 * @brief receive FCP SCSI Command 513 * 514 * Called by the base driver when a new SCSI command has been received. The 515 * target-server will process the command, and issue data and/or response phase 516 * requests to the base driver. 517 * 518 * The IO context (ocs_io_t) structure has and element of type 519 * ocs_scsi_tgt_io_t named tgt_io that is declared and used by 520 * a target-server for private information. 521 * 522 * @param io pointer to IO context 523 * @param lun LUN for this IO 524 * @param cdb pointer to SCSI CDB 525 * @param cdb_len length of CDB in bytes 526 * @param flags command flags 527 * 528 * @return returns 0 for success, a negative error code value for failure. 529 */ 530int32_t ocs_scsi_recv_cmd(ocs_io_t *io, uint64_t lun, uint8_t *cdb, 531 uint32_t cdb_len, uint32_t flags) 532{ 533 ocs_t *ocs = io->ocs; 534 struct ccb_accept_tio *atio = NULL; 535 ocs_node_t *node = io->node; 536 ocs_tgt_resource_t *trsrc = NULL; 537 int32_t rc = -1; 538 ocs_fcport *fcp = NULL; 539 540 fcp = node->sport->tgt_data; 541 if (fcp == NULL) { 542 ocs_log_err(ocs, "FCP is NULL \n"); 543 return 1; 544 } 545 546 atomic_add_acq_32(&ocs->io_in_use, 1); 547 548 /* set target io timeout */ 549 io->timeout = ocs->target_io_timer_sec; 550 551 if (ocs->enable_task_set_full && 552 (ocs->io_in_use >= ocs->io_high_watermark)) { 553 return ocs_task_set_full_or_busy(io); 554 } else { 555 atomic_store_rel_32(&io->node->tgt_node.busy_sent, FALSE); 556 } 557 558 if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) { 559 trsrc = &fcp->targ_rsrc[lun]; 560 } else if (fcp->targ_rsrc_wildcard.enabled) { 561 trsrc = &fcp->targ_rsrc_wildcard; 562 } 563 564 if (trsrc) { 565 atio = (struct ccb_accept_tio *)STAILQ_FIRST(&trsrc->atio); 566 } 567 568 if (atio) { 569 570 STAILQ_REMOVE_HEAD(&trsrc->atio, sim_links.stqe); 571 572 atio->ccb_h.status = CAM_CDB_RECVD; 573 atio->ccb_h.target_lun = lun; 574 atio->sense_len = 0; 575 576 atio->init_id = node->instance_index; 577 atio->tag_id = io->tag; 578 atio->ccb_h.ccb_io_ptr = io; 579 580 if (flags & OCS_SCSI_CMD_SIMPLE) 581 atio->tag_action = MSG_SIMPLE_Q_TAG; 582 else if (flags & OCS_SCSI_CMD_HEAD_OF_QUEUE) 583 atio->tag_action = MSG_HEAD_OF_Q_TAG; 584 else if (flags & OCS_SCSI_CMD_ORDERED) 585 atio->tag_action = MSG_ORDERED_Q_TAG; 586 else 587 atio->tag_action = 0; 588 589 atio->cdb_len = cdb_len; 590 ocs_memcpy(atio->cdb_io.cdb_bytes, cdb, cdb_len); 591 592 io->tgt_io.flags = 0; 593 io->tgt_io.state = OCS_CAM_IO_COMMAND; 594 io->tgt_io.lun = lun; 595 596 xpt_done((union ccb *)atio); 597 598 rc = 0; 599 } else { 600 device_printf( 601 ocs->dev, "%s: no ATIO for LUN %lx (en=%s) OX_ID %#x\n", 602 __func__, (unsigned long)lun, 603 trsrc ? (trsrc->enabled ? "T" : "F") : "X", 604 be16toh(io->init_task_tag)); 605 606 io->tgt_io.state = OCS_CAM_IO_MAX; 607 ocs_target_io_free(io); 608 } 609 610 return rc; 611} 612 613/** 614 * @ingroup scsi_api_target 615 * @brief receive FCP SCSI Command with first burst data. 616 * 617 * Receive a new FCP SCSI command from the base driver with first burst data. 618 * 619 * @param io pointer to IO context 620 * @param lun LUN for this IO 621 * @param cdb pointer to SCSI CDB 622 * @param cdb_len length of CDB in bytes 623 * @param flags command flags 624 * @param first_burst_buffers first burst buffers 625 * @param first_burst_buffer_count The number of bytes received in the first burst 626 * 627 * @return returns 0 for success, a negative error code value for failure. 628 */ 629int32_t ocs_scsi_recv_cmd_first_burst(ocs_io_t *io, uint64_t lun, uint8_t *cdb, 630 uint32_t cdb_len, uint32_t flags, 631 ocs_dma_t first_burst_buffers[], 632 uint32_t first_burst_buffer_count) 633{ 634 return -1; 635} 636 637/** 638 * @ingroup scsi_api_target 639 * @brief receive a TMF command IO 640 * 641 * Called by the base driver when a SCSI TMF command has been received. The 642 * target-server will process the command, aborting commands as needed, and post 643 * a response using ocs_scsi_send_resp() 644 * 645 * The IO context (ocs_io_t) structure has and element of type ocs_scsi_tgt_io_t named 646 * tgt_io that is declared and used by a target-server for private information. 647 * 648 * If the target-server walks the nodes active_ios linked list, and starts IO 649 * abort processing, the code <b>must</b> be sure not to abort the IO passed into the 650 * ocs_scsi_recv_tmf() command. 651 * 652 * @param tmfio pointer to IO context 653 * @param lun logical unit value 654 * @param cmd command request 655 * @param abortio pointer to IO object to abort for TASK_ABORT (NULL for all other TMF) 656 * @param flags flags 657 * 658 * @return returns 0 for success, a negative error code value for failure. 659 */ 660int32_t ocs_scsi_recv_tmf(ocs_io_t *tmfio, uint64_t lun, ocs_scsi_tmf_cmd_e cmd, 661 ocs_io_t *abortio, uint32_t flags) 662{ 663 ocs_t *ocs = tmfio->ocs; 664 ocs_node_t *node = tmfio->node; 665 ocs_tgt_resource_t *trsrc = NULL; 666 struct ccb_immediate_notify *inot = NULL; 667 int32_t rc = -1; 668 ocs_fcport *fcp = NULL; 669 670 fcp = node->sport->tgt_data; 671 if (fcp == NULL) { 672 ocs_log_err(ocs, "FCP is NULL \n"); 673 return 1; 674 } 675 676 if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) { 677 trsrc = &fcp->targ_rsrc[lun]; 678 } else if (fcp->targ_rsrc_wildcard.enabled) { 679 trsrc = &fcp->targ_rsrc_wildcard; 680 } 681 682 device_printf(tmfio->ocs->dev, "%s: io=%p cmd=%#x LU=%lx en=%s\n", 683 __func__, tmfio, cmd, (unsigned long)lun, 684 trsrc ? (trsrc->enabled ? "T" : "F") : "X"); 685 if (trsrc) { 686 inot = (struct ccb_immediate_notify *)STAILQ_FIRST(&trsrc->inot); 687 } 688 689 if (!inot) { 690 device_printf( 691 ocs->dev, "%s: no INOT for LUN %llx (en=%s) OX_ID %#x\n", 692 __func__, (unsigned long long)lun, trsrc ? (trsrc->enabled ? "T" : "F") : "X", 693 be16toh(tmfio->init_task_tag)); 694 695 if (abortio) { 696 ocs_scsi_io_complete(abortio); 697 } 698 ocs_scsi_io_complete(tmfio); 699 goto ocs_scsi_recv_tmf_out; 700 } 701 702 703 tmfio->tgt_io.app = abortio; 704 705 STAILQ_REMOVE_HEAD(&trsrc->inot, sim_links.stqe); 706 707 inot->tag_id = tmfio->tag; 708 inot->seq_id = tmfio->tag; 709 710 if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) { 711 inot->initiator_id = node->instance_index; 712 } else { 713 inot->initiator_id = CAM_TARGET_WILDCARD; 714 } 715 716 inot->ccb_h.status = CAM_MESSAGE_RECV; 717 inot->ccb_h.target_lun = lun; 718 719 switch (cmd) { 720 case OCS_SCSI_TMF_ABORT_TASK: 721 inot->arg = MSG_ABORT_TASK; 722 inot->seq_id = abortio->tag; 723 device_printf(ocs->dev, "%s: ABTS IO.%#x st=%#x\n", 724 __func__, abortio->tag, abortio->tgt_io.state); 725 abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_RECV; 726 abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_NOTIFY; 727 break; 728 case OCS_SCSI_TMF_QUERY_TASK_SET: 729 device_printf(ocs->dev, 730 "%s: OCS_SCSI_TMF_QUERY_TASK_SET not supported\n", 731 __func__); 732 STAILQ_INSERT_TAIL(&trsrc->inot, &inot->ccb_h, sim_links.stqe); 733 ocs_scsi_io_complete(tmfio); 734 goto ocs_scsi_recv_tmf_out; 735 break; 736 case OCS_SCSI_TMF_ABORT_TASK_SET: 737 inot->arg = MSG_ABORT_TASK_SET; 738 break; 739 case OCS_SCSI_TMF_CLEAR_TASK_SET: 740 inot->arg = MSG_CLEAR_TASK_SET; 741 break; 742 case OCS_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT: 743 inot->arg = MSG_QUERY_ASYNC_EVENT; 744 break; 745 case OCS_SCSI_TMF_LOGICAL_UNIT_RESET: 746 inot->arg = MSG_LOGICAL_UNIT_RESET; 747 break; 748 case OCS_SCSI_TMF_CLEAR_ACA: 749 inot->arg = MSG_CLEAR_ACA; 750 break; 751 case OCS_SCSI_TMF_TARGET_RESET: 752 inot->arg = MSG_TARGET_RESET; 753 break; 754 default: 755 device_printf(ocs->dev, "%s: unsupported TMF %#x\n", 756 __func__, cmd); 757 STAILQ_INSERT_TAIL(&trsrc->inot, &inot->ccb_h, sim_links.stqe); 758 goto ocs_scsi_recv_tmf_out; 759 } 760 761 rc = 0; 762 763 xpt_print(inot->ccb_h.path, "%s: func=%#x stat=%#x id=%#x lun=%#x" 764 " flags=%#x tag=%#x seq=%#x ini=%#x arg=%#x\n", 765 __func__, inot->ccb_h.func_code, inot->ccb_h.status, 766 inot->ccb_h.target_id, 767 (unsigned int)inot->ccb_h.target_lun, inot->ccb_h.flags, 768 inot->tag_id, inot->seq_id, inot->initiator_id, 769 inot->arg); 770 xpt_done((union ccb *)inot); 771 772 if (abortio) { 773 abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_DEV; 774 rc = ocs_scsi_tgt_abort_io(abortio, ocs_io_abort_cb, tmfio); 775 } 776 777ocs_scsi_recv_tmf_out: 778 return rc; 779} 780 781/** 782 * @ingroup scsi_api_initiator 783 * @brief Initializes any initiator fields on the ocs structure. 784 * 785 * Called by OS initialization code when a new device is discovered. 786 * 787 * @param ocs pointer to ocs 788 * 789 * @return returns 0 for success, a negative error code value for failure. 790 */ 791int32_t 792ocs_scsi_ini_new_device(ocs_t *ocs) 793{ 794 795 return 0; 796} 797 798/** 799 * @ingroup scsi_api_initiator 800 * @brief Tears down initiator members of ocs structure. 801 * 802 * Called by OS code when device is removed. 803 * 804 * @param ocs pointer to ocs 805 * 806 * @return returns 0 for success, a negative error code value for failure. 807 */ 808 809int32_t 810ocs_scsi_ini_del_device(ocs_t *ocs) 811{ 812 813 return 0; 814} 815 816 817/** 818 * @ingroup scsi_api_initiator 819 * @brief accept new domain notification 820 * 821 * Called by base drive when new domain is discovered. An initiator-client 822 * will accept this call to prepare for new remote node notifications 823 * arising from ocs_scsi_new_target(). 824 * 825 * The domain context has the element <b>ocs_scsi_ini_domain_t ini_domain</b> 826 * which is declared by the initiator-client code and is used for 827 * initiator-client private data. 828 * 829 * This function will only be called if the base-driver has been enabled for 830 * initiator capability. 831 * 832 * Note that this call is made to initiator-client backends, 833 * the ocs_scsi_tgt_new_domain() function is called to target-server backends. 834 * 835 * @param domain pointer to domain 836 * 837 * @return returns 0 for success, a negative error code value for failure. 838 */ 839int32_t 840ocs_scsi_ini_new_domain(ocs_domain_t *domain) 841{ 842 return 0; 843} 844 845/** 846 * @ingroup scsi_api_initiator 847 * @brief accept domain lost notification 848 * 849 * Called by base-driver when a domain goes away. An initiator-client will 850 * use this call to clean up all domain scoped resources. 851 * 852 * This function will only be called if the base-driver has been enabled for 853 * initiator capability. 854 * 855 * Note that this call is made to initiator-client backends, 856 * the ocs_scsi_tgt_del_domain() function is called to target-server backends. 857 * 858 * @param domain pointer to domain 859 * 860 * @return returns 0 for success, a negative error code value for failure. 861 */ 862void 863ocs_scsi_ini_del_domain(ocs_domain_t *domain) 864{ 865} 866 867/** 868 * @ingroup scsi_api_initiator 869 * @brief accept new sli port notification 870 * 871 * Called by base drive when new sli port (sport) is discovered. 872 * A target-server will use this call to prepare for new remote node 873 * notifications arising from ocs_scsi_new_initiator(). 874 * 875 * This function will only be called if the base-driver has been enabled for 876 * target capability. 877 * 878 * Note that this call is made to target-server backends, 879 * the ocs_scsi_ini_new_sport() function is called to initiator-client backends. 880 * 881 * @param sport pointer to sport 882 * 883 * @return returns 0 for success, a negative error code value for failure. 884 */ 885int32_t 886ocs_scsi_ini_new_sport(ocs_sport_t *sport) 887{ 888 ocs_t *ocs = sport->ocs; 889 ocs_fcport *fcp = FCPORT(ocs, 0); 890 891 if (!sport->is_vport) { 892 sport->tgt_data = fcp; 893 fcp->fc_id = sport->fc_id; 894 } 895 896 return 0; 897} 898 899/** 900 * @ingroup scsi_api_initiator 901 * @brief accept sli port gone notification 902 * 903 * Called by base-driver when a sport goes away. A target-server will 904 * use this call to clean up all sport scoped resources. 905 * 906 * Note that this call is made to target-server backends, 907 * the ocs_scsi_ini_del_sport() function is called to initiator-client backends. 908 * 909 * @param sport pointer to SLI port 910 * 911 * @return returns 0 for success, a negative error code value for failure. 912 */ 913void 914ocs_scsi_ini_del_sport(ocs_sport_t *sport) 915{ 916 ocs_t *ocs = sport->ocs; 917 ocs_fcport *fcp = FCPORT(ocs, 0); 918 919 if (!sport->is_vport) { 920 fcp->fc_id = 0; 921 } 922} 923 924void 925ocs_scsi_sport_deleted(ocs_sport_t *sport) 926{ 927 ocs_t *ocs = sport->ocs; 928 ocs_fcport *fcp = NULL; 929 930 ocs_xport_stats_t value; 931 932 if (!sport->is_vport) { 933 return; 934 } 935 936 fcp = sport->tgt_data; 937 938 ocs_xport_status(ocs->xport, OCS_XPORT_PORT_STATUS, &value); 939 940 if (value.value == 0) { 941 ocs_log_debug(ocs, "PORT offline,.. skipping\n"); 942 return; 943 } 944 945 if ((fcp->role != KNOB_ROLE_NONE)) { 946 if(fcp->vport->sport != NULL) { 947 ocs_log_debug(ocs,"sport is not NULL, skipping\n"); 948 return; 949 } 950 951 ocs_sport_vport_alloc(ocs->domain, fcp->vport); 952 return; 953 } 954 955} 956 957int32_t 958ocs_tgt_find(ocs_fcport *fcp, ocs_node_t *node) 959{ 960 ocs_fc_target_t *tgt = NULL; 961 uint32_t i; 962 963 for (i = 0; i < OCS_MAX_TARGETS; i++) { 964 tgt = &fcp->tgt[i]; 965 966 if (tgt->state == OCS_TGT_STATE_NONE) 967 continue; 968 969 if (ocs_node_get_wwpn(node) == tgt->wwpn) { 970 return i; 971 } 972 } 973 974 return -1; 975} 976 977/** 978 * @ingroup scsi_api_initiator 979 * @brief receive notification of a new SCSI target node 980 * 981 * Sent by base driver to notify an initiator-client of the presense of a new 982 * remote target. The initiator-server may use this call to prepare for 983 * inbound IO from this node. 984 * 985 * This function is only called if the base driver is enabled for 986 * initiator capability. 987 * 988 * @param node pointer to new remote initiator node 989 * 990 * @return none 991 * 992 * @note 993 */ 994 995uint32_t 996ocs_update_tgt(ocs_node_t *node, ocs_fcport *fcp, uint32_t tgt_id) 997{ 998 ocs_fc_target_t *tgt = NULL; 999 1000 tgt = &fcp->tgt[tgt_id]; 1001 1002 tgt->node_id = node->instance_index; 1003 tgt->state = OCS_TGT_STATE_VALID; 1004 1005 tgt->port_id = node->rnode.fc_id; 1006 tgt->wwpn = ocs_node_get_wwpn(node); 1007 tgt->wwnn = ocs_node_get_wwnn(node); 1008 return 0; 1009} 1010 1011uint32_t 1012ocs_add_new_tgt(ocs_node_t *node, ocs_fcport *fcp) 1013{ 1014 uint32_t i; 1015 1016 struct ocs_softc *ocs = node->ocs; 1017 union ccb *ccb = NULL; 1018 for (i = 0; i < OCS_MAX_TARGETS; i++) { 1019 if (fcp->tgt[i].state == OCS_TGT_STATE_NONE) 1020 break; 1021 } 1022 1023 if (NULL == (ccb = xpt_alloc_ccb_nowait())) { 1024 device_printf(ocs->dev, "%s: ccb allocation failed\n", __func__); 1025 return -1; 1026 } 1027 1028 if (CAM_REQ_CMP != xpt_create_path(&ccb->ccb_h.path, xpt_periph, 1029 cam_sim_path(fcp->sim), 1030 i, CAM_LUN_WILDCARD)) { 1031 device_printf( 1032 ocs->dev, "%s: target path creation failed\n", __func__); 1033 xpt_free_ccb(ccb); 1034 return -1; 1035 } 1036 1037 ocs_update_tgt(node, fcp, i); 1038 xpt_rescan(ccb); 1039 return 0; 1040} 1041 1042int32_t 1043ocs_scsi_new_target(ocs_node_t *node) 1044{ 1045 ocs_fcport *fcp = NULL; 1046 int32_t i; 1047 1048 fcp = node->sport->tgt_data; 1049 if (fcp == NULL) { 1050 printf("%s:FCP is NULL \n", __func__); 1051 return 0; 1052 } 1053 1054 i = ocs_tgt_find(fcp, node); 1055 1056 if (i < 0) { 1057 ocs_add_new_tgt(node, fcp); 1058 return 0; 1059 } 1060 1061 ocs_update_tgt(node, fcp, i); 1062 return 0; 1063} 1064 1065static void 1066ocs_delete_target(ocs_t *ocs, ocs_fcport *fcp, int tgt) 1067{ 1068 struct cam_path *cpath = NULL; 1069 1070 if (!fcp->sim) { 1071 device_printf(ocs->dev, "%s: calling with NULL sim\n", __func__); 1072 return; 1073 } 1074 1075 if (CAM_REQ_CMP == xpt_create_path(&cpath, NULL, cam_sim_path(fcp->sim), 1076 tgt, CAM_LUN_WILDCARD)) { 1077 xpt_async(AC_LOST_DEVICE, cpath, NULL); 1078 1079 xpt_free_path(cpath); 1080 } 1081} 1082 1083/* 1084 * Device Lost Timer Function- when we have decided that a device was lost, 1085 * we wait a specific period of time prior to telling the OS about lost device. 1086 * 1087 * This timer function gets activated when the device was lost. 1088 * This function fires once a second and then scans the port database 1089 * for devices that are marked dead but still have a virtual target assigned. 1090 * We decrement a counter for that port database entry, and when it hits zero, 1091 * we tell the OS the device was lost. Timer will be stopped when the device 1092 * comes back active or removed from the OS. 1093 */ 1094static void 1095ocs_ldt(void *arg) 1096{ 1097 ocs_fcport *fcp = arg; 1098 taskqueue_enqueue(taskqueue_thread, &fcp->ltask); 1099} 1100 1101static void 1102ocs_ldt_task(void *arg, int pending) 1103{ 1104 ocs_fcport *fcp = arg; 1105 ocs_t *ocs = fcp->ocs; 1106 int i, more_to_do = 0; 1107 ocs_fc_target_t *tgt = NULL; 1108 1109 for (i = 0; i < OCS_MAX_TARGETS; i++) { 1110 tgt = &fcp->tgt[i]; 1111 1112 if (tgt->state != OCS_TGT_STATE_LOST) { 1113 continue; 1114 } 1115 1116 if ((tgt->gone_timer != 0) && (ocs->attached)){ 1117 tgt->gone_timer -= 1; 1118 more_to_do++; 1119 continue; 1120 } 1121 1122 if (tgt->is_target) { 1123 tgt->is_target = 0; 1124 ocs_delete_target(ocs, fcp, i); 1125 } 1126 1127 tgt->state = OCS_TGT_STATE_NONE; 1128 } 1129 1130 if (more_to_do) { 1131 callout_reset(&fcp->ldt, hz, ocs_ldt, fcp); 1132 } else { 1133 callout_deactivate(&fcp->ldt); 1134 } 1135 1136} 1137 1138/** 1139 * @ingroup scsi_api_initiator 1140 * @brief Delete a SCSI target node 1141 * 1142 * Sent by base driver to notify a initiator-client that a remote target 1143 * is now gone. The base driver will have terminated all outstanding IOs 1144 * and the initiator-client will receive appropriate completions. 1145 * 1146 * The ocs_node_t structure has and elment of type ocs_scsi_ini_node_t named 1147 * ini_node that is declared and used by a target-server for private 1148 * information. 1149 * 1150 * This function is only called if the base driver is enabled for 1151 * initiator capability. 1152 * 1153 * @param node pointer node being deleted 1154 * @param reason reason for deleting the target 1155 * 1156 * @return Returns OCS_SCSI_CALL_ASYNC if target delete is queued for async 1157 * completion and OCS_SCSI_CALL_COMPLETE if call completed or error. 1158 * 1159 * @note 1160 */ 1161int32_t 1162ocs_scsi_del_target(ocs_node_t *node, ocs_scsi_del_target_reason_e reason) 1163{ 1164 struct ocs_softc *ocs = node->ocs; 1165 ocs_fcport *fcp = NULL; 1166 ocs_fc_target_t *tgt = NULL; 1167 uint32_t tgt_id; 1168 1169 fcp = node->sport->tgt_data; 1170 if (fcp == NULL) { 1171 ocs_log_err(ocs,"FCP is NULL \n"); 1172 return 0; 1173 } 1174 1175 tgt_id = ocs_tgt_find(fcp, node); 1176 1177 tgt = &fcp->tgt[tgt_id]; 1178 1179 // IF in shutdown delete target. 1180 if(!ocs->attached) { 1181 ocs_delete_target(ocs, fcp, tgt_id); 1182 } else { 1183 1184 tgt->state = OCS_TGT_STATE_LOST; 1185 tgt->gone_timer = 30; 1186 if (!callout_active(&fcp->ldt)) { 1187 callout_reset(&fcp->ldt, hz, ocs_ldt, fcp); 1188 } 1189 } 1190 1191 return 0; 1192} 1193 1194/** 1195 * @brief Initialize SCSI IO 1196 * 1197 * Initialize SCSI IO, this function is called once per IO during IO pool 1198 * allocation so that the target server may initialize any of its own private 1199 * data. 1200 * 1201 * @param io pointer to SCSI IO object 1202 * 1203 * @return returns 0 for success, a negative error code value for failure. 1204 */ 1205int32_t 1206ocs_scsi_tgt_io_init(ocs_io_t *io) 1207{ 1208 return 0; 1209} 1210 1211/** 1212 * @brief Uninitialize SCSI IO 1213 * 1214 * Uninitialize target server private data in a SCSI io object 1215 * 1216 * @param io pointer to SCSI IO object 1217 * 1218 * @return returns 0 for success, a negative error code value for failure. 1219 */ 1220int32_t 1221ocs_scsi_tgt_io_exit(ocs_io_t *io) 1222{ 1223 return 0; 1224} 1225 1226/** 1227 * @brief Initialize SCSI IO 1228 * 1229 * Initialize SCSI IO, this function is called once per IO during IO pool 1230 * allocation so that the initiator client may initialize any of its own private 1231 * data. 1232 * 1233 * @param io pointer to SCSI IO object 1234 * 1235 * @return returns 0 for success, a negative error code value for failure. 1236 */ 1237int32_t 1238ocs_scsi_ini_io_init(ocs_io_t *io) 1239{ 1240 return 0; 1241} 1242 1243/** 1244 * @brief Uninitialize SCSI IO 1245 * 1246 * Uninitialize initiator client private data in a SCSI io object 1247 * 1248 * @param io pointer to SCSI IO object 1249 * 1250 * @return returns 0 for success, a negative error code value for failure. 1251 */ 1252int32_t 1253ocs_scsi_ini_io_exit(ocs_io_t *io) 1254{ 1255 return 0; 1256} 1257/* 1258 * End of functions required by SCSI base driver API 1259 ***************************************************************************/ 1260 1261static __inline void 1262ocs_set_ccb_status(union ccb *ccb, cam_status status) 1263{ 1264 ccb->ccb_h.status &= ~CAM_STATUS_MASK; 1265 ccb->ccb_h.status |= status; 1266} 1267 1268static int32_t 1269ocs_task_set_full_or_busy_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, 1270 uint32_t flags, void *arg) 1271{ 1272 1273 ocs_target_io_free(io); 1274 1275 return 0; 1276} 1277 1278/** 1279 * @brief send SCSI task set full or busy status 1280 * 1281 * A SCSI task set full or busy response is sent depending on whether 1282 * another IO is already active on the LUN. 1283 * 1284 * @param io pointer to IO context 1285 * 1286 * @return returns 0 for success, a negative error code value for failure. 1287 */ 1288 1289static int32_t 1290ocs_task_set_full_or_busy(ocs_io_t *io) 1291{ 1292 ocs_scsi_cmd_resp_t rsp = { 0 }; 1293 ocs_t *ocs = io->ocs; 1294 1295 /* 1296 * If there is another command for the LUN, then send task set full, 1297 * if this is the first one, then send the busy status. 1298 * 1299 * if 'busy sent' is FALSE, set it to TRUE and send BUSY 1300 * otherwise send FULL 1301 */ 1302 if (atomic_cmpset_acq_32(&io->node->tgt_node.busy_sent, FALSE, TRUE)) { 1303 rsp.scsi_status = SCSI_STATUS_BUSY; /* Busy */ 1304 printf("%s: busy [%s] tag=%x iiu=%d ihw=%d\n", __func__, 1305 io->node->display_name, io->tag, 1306 io->ocs->io_in_use, io->ocs->io_high_watermark); 1307 } else { 1308 rsp.scsi_status = SCSI_STATUS_TASK_SET_FULL; /* Task set full */ 1309 printf("%s: full tag=%x iiu=%d\n", __func__, io->tag, 1310 io->ocs->io_in_use); 1311 } 1312 1313 /* Log a message here indicating a busy or task set full state */ 1314 if (OCS_LOG_ENABLE_Q_FULL_BUSY_MSG(ocs)) { 1315 /* Log Task Set Full */ 1316 if (rsp.scsi_status == SCSI_STATUS_TASK_SET_FULL) { 1317 /* Task Set Full Message */ 1318 ocs_log_info(ocs, "OCS CAM TASK SET FULL. Tasks >= %d\n", 1319 ocs->io_high_watermark); 1320 } 1321 else if (rsp.scsi_status == SCSI_STATUS_BUSY) { 1322 /* Log Busy Message */ 1323 ocs_log_info(ocs, "OCS CAM SCSI BUSY\n"); 1324 } 1325 } 1326 1327 /* Send the response */ 1328 return 1329 ocs_scsi_send_resp(io, 0, &rsp, ocs_task_set_full_or_busy_cb, NULL); 1330} 1331 1332/** 1333 * @ingroup cam_io 1334 * @brief Process target IO completions 1335 * 1336 * @param io 1337 * @param scsi_status did the IO complete successfully 1338 * @param flags 1339 * @param arg application specific pointer provided in the call to ocs_target_io() 1340 * 1341 * @todo 1342 */ 1343static int32_t ocs_scsi_target_io_cb(ocs_io_t *io, 1344 ocs_scsi_io_status_e scsi_status, 1345 uint32_t flags, void *arg) 1346{ 1347 union ccb *ccb = arg; 1348 struct ccb_scsiio *csio = &ccb->csio; 1349 struct ocs_softc *ocs = csio->ccb_h.ccb_ocs_ptr; 1350 uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK; 1351 uint32_t io_is_done = 1352 (ccb->ccb_h.flags & CAM_SEND_STATUS) == CAM_SEND_STATUS; 1353 1354 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 1355 1356 if (CAM_DIR_NONE != cam_dir) { 1357 bus_dmasync_op_t op; 1358 1359 if (CAM_DIR_IN == cam_dir) { 1360 op = BUS_DMASYNC_POSTREAD; 1361 } else { 1362 op = BUS_DMASYNC_POSTWRITE; 1363 } 1364 /* Synchronize the DMA memory with the CPU and free the mapping */ 1365 bus_dmamap_sync(ocs->buf_dmat, io->tgt_io.dmap, op); 1366 if (io->tgt_io.flags & OCS_CAM_IO_F_DMAPPED) { 1367 bus_dmamap_unload(ocs->buf_dmat, io->tgt_io.dmap); 1368 } 1369 } 1370 1371 if (io->tgt_io.sendresp) { 1372 io->tgt_io.sendresp = 0; 1373 ocs_scsi_cmd_resp_t resp = { 0 }; 1374 io->tgt_io.state = OCS_CAM_IO_RESP; 1375 resp.scsi_status = scsi_status; 1376 if (ccb->ccb_h.flags & CAM_SEND_SENSE) { 1377 resp.sense_data = (uint8_t *)&csio->sense_data; 1378 resp.sense_data_length = csio->sense_len; 1379 } 1380 resp.residual = io->exp_xfer_len - io->transferred; 1381 1382 return ocs_scsi_send_resp(io, 0, &resp, ocs_scsi_target_io_cb, ccb); 1383 } 1384 1385 switch (scsi_status) { 1386 case OCS_SCSI_STATUS_GOOD: 1387 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 1388 break; 1389 case OCS_SCSI_STATUS_ABORTED: 1390 ocs_set_ccb_status(ccb, CAM_REQ_ABORTED); 1391 break; 1392 default: 1393 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 1394 } 1395 1396 if (io_is_done) { 1397 if ((io->tgt_io.flags & OCS_CAM_IO_F_ABORT_NOTIFY) == 0) { 1398 ocs_target_io_free(io); 1399 } 1400 } else { 1401 io->tgt_io.state = OCS_CAM_IO_DATA_DONE; 1402 /*device_printf(ocs->dev, "%s: CTIO state=%d tag=%#x\n", 1403 __func__, io->tgt_io.state, io->tag);*/ 1404 } 1405 1406 xpt_done(ccb); 1407 1408 return 0; 1409} 1410 1411/** 1412 * @note 1. Since the CCB is assigned to the ocs_io_t on an XPT_CONT_TARGET_IO 1413 * action, if an initiator aborts a command prior to the SIM receiving 1414 * a CTIO, the IO's CCB will be NULL. 1415 */ 1416static int32_t 1417ocs_io_abort_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg) 1418{ 1419 struct ocs_softc *ocs = NULL; 1420 ocs_io_t *tmfio = arg; 1421 ocs_scsi_tmf_resp_e tmf_resp = OCS_SCSI_TMF_FUNCTION_COMPLETE; 1422 int32_t rc = 0; 1423 1424 ocs = io->ocs; 1425 1426 io->tgt_io.flags &= ~OCS_CAM_IO_F_ABORT_DEV; 1427 1428 /* A good status indicates the IO was aborted and will be completed in 1429 * the IO's completion handler. Handle the other cases here. */ 1430 switch (scsi_status) { 1431 case OCS_SCSI_STATUS_GOOD: 1432 break; 1433 case OCS_SCSI_STATUS_NO_IO: 1434 break; 1435 default: 1436 device_printf(ocs->dev, "%s: unhandled status %d\n", 1437 __func__, scsi_status); 1438 tmf_resp = OCS_SCSI_TMF_FUNCTION_REJECTED; 1439 rc = -1; 1440 } 1441 1442 ocs_scsi_send_tmf_resp(tmfio, tmf_resp, NULL, ocs_target_tmf_cb, NULL); 1443 1444 return rc; 1445} 1446 1447/** 1448 * @ingroup cam_io 1449 * @brief Process initiator IO completions 1450 * 1451 * @param io 1452 * @param scsi_status did the IO complete successfully 1453 * @param rsp pointer to response buffer 1454 * @param flags 1455 * @param arg application specific pointer provided in the call to ocs_target_io() 1456 * 1457 * @todo 1458 */ 1459static int32_t ocs_scsi_initiator_io_cb(ocs_io_t *io, 1460 ocs_scsi_io_status_e scsi_status, 1461 ocs_scsi_cmd_resp_t *rsp, 1462 uint32_t flags, void *arg) 1463{ 1464 union ccb *ccb = arg; 1465 struct ccb_scsiio *csio = &ccb->csio; 1466 struct ocs_softc *ocs = csio->ccb_h.ccb_ocs_ptr; 1467 uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK; 1468 cam_status ccb_status= CAM_REQ_CMP_ERR; 1469 1470 if (CAM_DIR_NONE != cam_dir) { 1471 bus_dmasync_op_t op; 1472 1473 if (CAM_DIR_IN == cam_dir) { 1474 op = BUS_DMASYNC_POSTREAD; 1475 } else { 1476 op = BUS_DMASYNC_POSTWRITE; 1477 } 1478 /* Synchronize the DMA memory with the CPU and free the mapping */ 1479 bus_dmamap_sync(ocs->buf_dmat, io->tgt_io.dmap, op); 1480 if (io->tgt_io.flags & OCS_CAM_IO_F_DMAPPED) { 1481 bus_dmamap_unload(ocs->buf_dmat, io->tgt_io.dmap); 1482 } 1483 } 1484 1485 if (scsi_status == OCS_SCSI_STATUS_CHECK_RESPONSE) { 1486 csio->scsi_status = rsp->scsi_status; 1487 if (SCSI_STATUS_OK != rsp->scsi_status) { 1488 ccb_status = CAM_SCSI_STATUS_ERROR; 1489 } 1490 1491 csio->resid = rsp->residual; 1492 if (rsp->residual > 0) { 1493 uint32_t length = rsp->response_wire_length; 1494 /* underflow */ 1495 if (csio->dxfer_len == (length + csio->resid)) { 1496 ccb_status = CAM_REQ_CMP; 1497 } 1498 } else if (rsp->residual < 0) { 1499 ccb_status = CAM_DATA_RUN_ERR; 1500 } 1501 1502 if ((rsp->sense_data_length) && 1503 !(ccb->ccb_h.flags & (CAM_SENSE_PHYS | CAM_SENSE_PTR))) { 1504 uint32_t sense_len = 0; 1505 1506 ccb->ccb_h.status |= CAM_AUTOSNS_VALID; 1507 if (rsp->sense_data_length < csio->sense_len) { 1508 csio->sense_resid = 1509 csio->sense_len - rsp->sense_data_length; 1510 sense_len = rsp->sense_data_length; 1511 } else { 1512 csio->sense_resid = 0; 1513 sense_len = csio->sense_len; 1514 } 1515 ocs_memcpy(&csio->sense_data, rsp->sense_data, sense_len); 1516 } 1517 } else if (scsi_status != OCS_SCSI_STATUS_GOOD) { 1518 ccb_status = CAM_REQ_CMP_ERR; 1519 ocs_set_ccb_status(ccb, ccb_status); 1520 csio->ccb_h.status |= CAM_DEV_QFRZN; 1521 xpt_freeze_devq(csio->ccb_h.path, 1); 1522 1523 } else { 1524 ccb_status = CAM_REQ_CMP; 1525 } 1526 1527 ocs_set_ccb_status(ccb, ccb_status); 1528 1529 ocs_scsi_io_free(io); 1530 1531 csio->ccb_h.ccb_io_ptr = NULL; 1532 csio->ccb_h.ccb_ocs_ptr = NULL; 1533 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 1534 1535 xpt_done(ccb); 1536 1537 return 0; 1538} 1539 1540/** 1541 * @brief Load scatter-gather list entries into an IO 1542 * 1543 * This routine relies on the driver instance's software context pointer and 1544 * the IO object pointer having been already assigned to hooks in the CCB. 1545 * Although the routine does not return success/fail, callers can look at the 1546 * n_sge member to determine if the mapping failed (0 on failure). 1547 * 1548 * @param arg pointer to the CAM ccb for this IO 1549 * @param seg DMA address/length pairs 1550 * @param nseg number of DMA address/length pairs 1551 * @param error any errors while mapping the IO 1552 */ 1553static void 1554ocs_scsi_dmamap_load(void *arg, bus_dma_segment_t *seg, int nseg, int error) 1555{ 1556 ocs_dmamap_load_arg_t *sglarg = (ocs_dmamap_load_arg_t*) arg; 1557 1558 if (error) { 1559 printf("%s: seg=%p nseg=%d error=%d\n", 1560 __func__, seg, nseg, error); 1561 sglarg->rc = -1; 1562 } else { 1563 uint32_t i = 0; 1564 uint32_t c = 0; 1565 1566 if ((sglarg->sgl_count + nseg) > sglarg->sgl_max) { 1567 printf("%s: sgl_count=%d nseg=%d max=%d\n", __func__, 1568 sglarg->sgl_count, nseg, sglarg->sgl_max); 1569 sglarg->rc = -2; 1570 return; 1571 } 1572 1573 for (i = 0, c = sglarg->sgl_count; i < nseg; i++, c++) { 1574 sglarg->sgl[c].addr = seg[i].ds_addr; 1575 sglarg->sgl[c].len = seg[i].ds_len; 1576 } 1577 1578 sglarg->sgl_count = c; 1579 1580 sglarg->rc = 0; 1581 } 1582} 1583 1584/** 1585 * @brief Build a scatter-gather list from a CAM CCB 1586 * 1587 * @param ocs the driver instance's software context 1588 * @param ccb pointer to the CCB 1589 * @param io pointer to the previously allocated IO object 1590 * @param sgl pointer to SGL 1591 * @param sgl_max number of entries in sgl 1592 * 1593 * @return 0 on success, non-zero otherwise 1594 */ 1595static int32_t 1596ocs_build_scsi_sgl(struct ocs_softc *ocs, union ccb *ccb, ocs_io_t *io, 1597 ocs_scsi_sgl_t *sgl, uint32_t sgl_max) 1598{ 1599 ocs_dmamap_load_arg_t dmaarg; 1600 int32_t err = 0; 1601 1602 if (!ocs || !ccb || !io || !sgl) { 1603 printf("%s: bad param o=%p c=%p i=%p s=%p\n", __func__, 1604 ocs, ccb, io, sgl); 1605 return -1; 1606 } 1607 1608 io->tgt_io.flags &= ~OCS_CAM_IO_F_DMAPPED; 1609 1610 dmaarg.sgl = sgl; 1611 dmaarg.sgl_count = 0; 1612 dmaarg.sgl_max = sgl_max; 1613 dmaarg.rc = 0; 1614 1615 err = bus_dmamap_load_ccb(ocs->buf_dmat, io->tgt_io.dmap, ccb, 1616 ocs_scsi_dmamap_load, &dmaarg, 0); 1617 1618 if (err || dmaarg.rc) { 1619 device_printf( 1620 ocs->dev, "%s: bus_dmamap_load_ccb error (%d %d)\n", 1621 __func__, err, dmaarg.rc); 1622 return -1; 1623 } 1624 1625 io->tgt_io.flags |= OCS_CAM_IO_F_DMAPPED; 1626 return dmaarg.sgl_count; 1627} 1628 1629/** 1630 * @ingroup cam_io 1631 * @brief Send a target IO 1632 * 1633 * @param ocs the driver instance's software context 1634 * @param ccb pointer to the CCB 1635 * 1636 * @return 0 on success, non-zero otherwise 1637 */ 1638static int32_t 1639ocs_target_io(struct ocs_softc *ocs, union ccb *ccb) 1640{ 1641 struct ccb_scsiio *csio = &ccb->csio; 1642 ocs_io_t *io = NULL; 1643 uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK; 1644 bool sendstatus = ccb->ccb_h.flags & CAM_SEND_STATUS; 1645 uint32_t xferlen = csio->dxfer_len; 1646 int32_t rc = 0; 1647 1648 io = ocs_scsi_find_io(ocs, csio->tag_id); 1649 if (io == NULL) { 1650 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 1651 panic("bad tag value"); 1652 return 1; 1653 } 1654 1655 /* Received an ABORT TASK for this IO */ 1656 if (io->tgt_io.flags & OCS_CAM_IO_F_ABORT_RECV) { 1657 /*device_printf(ocs->dev, 1658 "%s: XPT_CONT_TARGET_IO state=%d tag=%#x xid=%#x flags=%#x\n", 1659 __func__, io->tgt_io.state, io->tag, io->init_task_tag, 1660 io->tgt_io.flags);*/ 1661 io->tgt_io.flags |= OCS_CAM_IO_F_ABORT_CAM; 1662 1663 if (ccb->ccb_h.flags & CAM_SEND_STATUS) { 1664 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 1665 ocs_target_io_free(io); 1666 return 1; 1667 } 1668 1669 ocs_set_ccb_status(ccb, CAM_REQ_ABORTED); 1670 1671 return 1; 1672 } 1673 1674 io->tgt_io.app = ccb; 1675 1676 ocs_set_ccb_status(ccb, CAM_REQ_INPROG); 1677 ccb->ccb_h.status |= CAM_SIM_QUEUED; 1678 1679 csio->ccb_h.ccb_ocs_ptr = ocs; 1680 csio->ccb_h.ccb_io_ptr = io; 1681 1682 if ((sendstatus && (xferlen == 0))) { 1683 ocs_scsi_cmd_resp_t resp = { 0 }; 1684 1685 ocs_assert(ccb->ccb_h.flags & CAM_SEND_STATUS, -1); 1686 1687 io->tgt_io.state = OCS_CAM_IO_RESP; 1688 1689 resp.scsi_status = csio->scsi_status; 1690 1691 if (ccb->ccb_h.flags & CAM_SEND_SENSE) { 1692 resp.sense_data = (uint8_t *)&csio->sense_data; 1693 resp.sense_data_length = csio->sense_len; 1694 } 1695 1696 resp.residual = io->exp_xfer_len - io->transferred; 1697 rc = ocs_scsi_send_resp(io, 0, &resp, ocs_scsi_target_io_cb, ccb); 1698 1699 } else if (xferlen != 0) { 1700 ocs_scsi_sgl_t sgl[OCS_FC_MAX_SGL]; 1701 int32_t sgl_count = 0; 1702 1703 io->tgt_io.state = OCS_CAM_IO_DATA; 1704 1705 if (sendstatus) 1706 io->tgt_io.sendresp = 1; 1707 1708 sgl_count = ocs_build_scsi_sgl(ocs, ccb, io, sgl, ARRAY_SIZE(sgl)); 1709 if (sgl_count > 0) { 1710 if (cam_dir == CAM_DIR_IN) { 1711 rc = ocs_scsi_send_rd_data(io, 0, NULL, sgl, 1712 sgl_count, csio->dxfer_len, 1713 ocs_scsi_target_io_cb, ccb); 1714 } else if (cam_dir == CAM_DIR_OUT) { 1715 rc = ocs_scsi_recv_wr_data(io, 0, NULL, sgl, 1716 sgl_count, csio->dxfer_len, 1717 ocs_scsi_target_io_cb, ccb); 1718 } else { 1719 device_printf(ocs->dev, "%s:" 1720 " unknown CAM direction %#x\n", 1721 __func__, cam_dir); 1722 ocs_set_ccb_status(ccb, CAM_REQ_INVALID); 1723 rc = 1; 1724 } 1725 } else { 1726 device_printf(ocs->dev, "%s: building SGL failed\n", 1727 __func__); 1728 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 1729 rc = 1; 1730 } 1731 } else { 1732 device_printf(ocs->dev, "%s: Wrong value xfer and sendstatus" 1733 " are 0 \n", __func__); 1734 ocs_set_ccb_status(ccb, CAM_REQ_INVALID); 1735 rc = 1; 1736 1737 } 1738 1739 if (rc) { 1740 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 1741 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 1742 io->tgt_io.state = OCS_CAM_IO_DATA_DONE; 1743 device_printf(ocs->dev, "%s: CTIO state=%d tag=%#x\n", 1744 __func__, io->tgt_io.state, io->tag); 1745 if ((sendstatus && (xferlen == 0))) { 1746 ocs_target_io_free(io); 1747 } 1748 } 1749 1750 return rc; 1751} 1752 1753static int32_t 1754ocs_target_tmf_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, 1755 void *arg) 1756{ 1757 1758 /*device_printf(io->ocs->dev, "%s: tag=%x io=%p s=%#x\n", 1759 __func__, io->tag, io, scsi_status);*/ 1760 ocs_scsi_io_complete(io); 1761 1762 return 0; 1763} 1764 1765/** 1766 * @ingroup cam_io 1767 * @brief Send an initiator IO 1768 * 1769 * @param ocs the driver instance's software context 1770 * @param ccb pointer to the CCB 1771 * 1772 * @return 0 on success, non-zero otherwise 1773 */ 1774static int32_t 1775ocs_initiator_io(struct ocs_softc *ocs, union ccb *ccb) 1776{ 1777 int32_t rc; 1778 struct ccb_scsiio *csio = &ccb->csio; 1779 struct ccb_hdr *ccb_h = &csio->ccb_h; 1780 ocs_node_t *node = NULL; 1781 ocs_io_t *io = NULL; 1782 ocs_scsi_sgl_t sgl[OCS_FC_MAX_SGL]; 1783 int32_t sgl_count; 1784 1785 ocs_fcport *fcp = NULL; 1786 fcp = FCPORT(ocs, cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path))); 1787 if (fcp == NULL) { 1788 device_printf(ocs->dev, "%s: fcp is NULL\n", __func__); 1789 return -1; 1790 } 1791 1792 if (fcp->tgt[ccb_h->target_id].state == OCS_TGT_STATE_LOST) { 1793 device_printf(ocs->dev, "%s: device LOST %d\n", __func__, 1794 ccb_h->target_id); 1795 return CAM_REQUEUE_REQ; 1796 } 1797 1798 if (fcp->tgt[ccb_h->target_id].state == OCS_TGT_STATE_NONE) { 1799 device_printf(ocs->dev, "%s: device not ready %d\n", __func__, 1800 ccb_h->target_id); 1801 return CAM_SEL_TIMEOUT; 1802 } 1803 1804 node = ocs_node_get_instance(ocs, fcp->tgt[ccb_h->target_id].node_id); 1805 if (node == NULL) { 1806 device_printf(ocs->dev, "%s: no device %d\n", __func__, 1807 ccb_h->target_id); 1808 return CAM_SEL_TIMEOUT; 1809 } 1810 1811 if (!node->targ) { 1812 device_printf(ocs->dev, "%s: not target device %d\n", __func__, 1813 ccb_h->target_id); 1814 return CAM_SEL_TIMEOUT; 1815 } 1816 1817 io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR); 1818 if (io == NULL) { 1819 device_printf(ocs->dev, "%s: unable to alloc IO\n", __func__); 1820 return -1; 1821 } 1822 1823 /* eventhough this is INI, use target structure as ocs_build_scsi_sgl 1824 * only references the tgt_io part of an ocs_io_t */ 1825 io->tgt_io.app = ccb; 1826 1827 csio->ccb_h.ccb_ocs_ptr = ocs; 1828 csio->ccb_h.ccb_io_ptr = io; 1829 1830 sgl_count = ocs_build_scsi_sgl(ocs, ccb, io, sgl, ARRAY_SIZE(sgl)); 1831 if (sgl_count < 0) { 1832 ocs_scsi_io_free(io); 1833 device_printf(ocs->dev, "%s: building SGL failed\n", __func__); 1834 return -1; 1835 } 1836 1837 if (ccb->ccb_h.timeout == CAM_TIME_INFINITY) { 1838 io->timeout = 0; 1839 } else if (ccb->ccb_h.timeout == CAM_TIME_DEFAULT) { 1840 io->timeout = OCS_CAM_IO_TIMEOUT; 1841 } else { 1842 io->timeout = ccb->ccb_h.timeout; 1843 } 1844 1845 switch (ccb->ccb_h.flags & CAM_DIR_MASK) { 1846 case CAM_DIR_NONE: 1847 rc = ocs_scsi_send_nodata_io(node, io, ccb_h->target_lun, 1848 ccb->ccb_h.flags & CAM_CDB_POINTER ? 1849 csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes, 1850 csio->cdb_len, 1851 ocs_scsi_initiator_io_cb, ccb); 1852 break; 1853 case CAM_DIR_IN: 1854 rc = ocs_scsi_send_rd_io(node, io, ccb_h->target_lun, 1855 ccb->ccb_h.flags & CAM_CDB_POINTER ? 1856 csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes, 1857 csio->cdb_len, 1858 NULL, 1859 sgl, sgl_count, csio->dxfer_len, 1860 ocs_scsi_initiator_io_cb, ccb); 1861 break; 1862 case CAM_DIR_OUT: 1863 rc = ocs_scsi_send_wr_io(node, io, ccb_h->target_lun, 1864 ccb->ccb_h.flags & CAM_CDB_POINTER ? 1865 csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes, 1866 csio->cdb_len, 1867 NULL, 1868 sgl, sgl_count, csio->dxfer_len, 1869 ocs_scsi_initiator_io_cb, ccb); 1870 break; 1871 default: 1872 panic("%s invalid data direction %08x\n", __func__, 1873 ccb->ccb_h.flags); 1874 break; 1875 } 1876 1877 return rc; 1878} 1879 1880static uint32_t 1881ocs_fcp_change_role(struct ocs_softc *ocs, ocs_fcport *fcp, uint32_t new_role) 1882{ 1883 1884 uint32_t rc = 0, was = 0, i = 0; 1885 ocs_vport_spec_t *vport = fcp->vport; 1886 1887 for (was = 0, i = 0; i < (ocs->num_vports + 1); i++) { 1888 if (FCPORT(ocs, i)->role != KNOB_ROLE_NONE) 1889 was++; 1890 } 1891 1892 // Physical port 1893 if ((was == 0) || (vport == NULL)) { 1894 fcp->role = new_role; 1895 if (vport == NULL) { 1896 ocs->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0; 1897 ocs->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0; 1898 } else { 1899 vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0; 1900 vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0; 1901 } 1902 1903 rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE); 1904 if (rc) { 1905 ocs_log_debug(ocs, "port offline failed : %d\n", rc); 1906 } 1907 1908 rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE); 1909 if (rc) { 1910 ocs_log_debug(ocs, "port online failed : %d\n", rc); 1911 } 1912 1913 return 0; 1914 } 1915 1916 if ((fcp->role != KNOB_ROLE_NONE)){ 1917 fcp->role = new_role; 1918 vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0; 1919 vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0; 1920 /* New Sport will be created in sport deleted cb */ 1921 return ocs_sport_vport_del(ocs, ocs->domain, vport->wwpn, vport->wwnn); 1922 } 1923 1924 fcp->role = new_role; 1925 1926 vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0; 1927 vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0; 1928 1929 if (fcp->role != KNOB_ROLE_NONE) { 1930 return ocs_sport_vport_alloc(ocs->domain, vport); 1931 } 1932 1933 return (0); 1934} 1935 1936/** 1937 * @ingroup cam_api 1938 * @brief Process CAM actions 1939 * 1940 * The driver supplies this routine to the CAM during intialization and 1941 * is the main entry point for processing CAM Control Blocks (CCB) 1942 * 1943 * @param sim pointer to the SCSI Interface Module 1944 * @param ccb CAM control block 1945 * 1946 * @todo 1947 * - populate path inquiry data via info retrieved from SLI port 1948 */ 1949static void 1950ocs_action(struct cam_sim *sim, union ccb *ccb) 1951{ 1952 struct ocs_softc *ocs = (struct ocs_softc *)cam_sim_softc(sim); 1953 struct ccb_hdr *ccb_h = &ccb->ccb_h; 1954 1955 int32_t rc, bus; 1956 bus = cam_sim_bus(sim); 1957 1958 switch (ccb_h->func_code) { 1959 case XPT_SCSI_IO: 1960 1961 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0) { 1962 if ((ccb->ccb_h.flags & CAM_CDB_PHYS) != 0) { 1963 ccb->ccb_h.status = CAM_REQ_INVALID; 1964 xpt_done(ccb); 1965 break; 1966 } 1967 } 1968 1969 rc = ocs_initiator_io(ocs, ccb); 1970 if (0 == rc) { 1971 ocs_set_ccb_status(ccb, CAM_REQ_INPROG | CAM_SIM_QUEUED); 1972 break; 1973 } else { 1974 if (rc == CAM_REQUEUE_REQ) { 1975 cam_freeze_devq(ccb->ccb_h.path); 1976 cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 100, 0); 1977 ccb->ccb_h.status = CAM_REQUEUE_REQ; 1978 xpt_done(ccb); 1979 break; 1980 } 1981 1982 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 1983 if (rc > 0) { 1984 ocs_set_ccb_status(ccb, rc); 1985 } else { 1986 ocs_set_ccb_status(ccb, CAM_SEL_TIMEOUT); 1987 } 1988 } 1989 xpt_done(ccb); 1990 break; 1991 case XPT_PATH_INQ: 1992 { 1993 struct ccb_pathinq *cpi = &ccb->cpi; 1994 struct ccb_pathinq_settings_fc *fc = &cpi->xport_specific.fc; 1995 ocs_fcport *fcp = FCPORT(ocs, bus); 1996 1997 uint64_t wwn = 0; 1998 ocs_xport_stats_t value; 1999 2000 cpi->version_num = 1; 2001 2002 cpi->protocol = PROTO_SCSI; 2003 cpi->protocol_version = SCSI_REV_SPC; 2004 2005 if (ocs->ocs_xport == OCS_XPORT_FC) { 2006 cpi->transport = XPORT_FC; 2007 } else { 2008 cpi->transport = XPORT_UNKNOWN; 2009 } 2010 2011 cpi->transport_version = 0; 2012 2013 /* Set the transport parameters of the SIM */ 2014 ocs_xport_status(ocs->xport, OCS_XPORT_LINK_SPEED, &value); 2015 fc->bitrate = value.value * 1000; /* speed in Mbps */ 2016 2017 wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWPN)); 2018 fc->wwpn = be64toh(wwn); 2019 2020 wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWNN)); 2021 fc->wwnn = be64toh(wwn); 2022 2023 fc->port = fcp->fc_id; 2024 2025 if (ocs->config_tgt) { 2026 cpi->target_sprt = 2027 PIT_PROCESSOR | PIT_DISCONNECT | PIT_TERM_IO; 2028 } 2029 2030 cpi->hba_misc = PIM_NOBUSRESET | PIM_UNMAPPED; 2031 cpi->hba_misc |= PIM_EXTLUNS | PIM_NOSCAN; 2032 2033 cpi->hba_inquiry = PI_TAG_ABLE; 2034 cpi->max_target = OCS_MAX_TARGETS; 2035 cpi->initiator_id = ocs->max_remote_nodes + 1; 2036 2037 if (!ocs->enable_ini) { 2038 cpi->hba_misc |= PIM_NOINITIATOR; 2039 } 2040 2041 cpi->max_lun = OCS_MAX_LUN; 2042 cpi->bus_id = cam_sim_bus(sim); 2043 2044 /* Need to supply a base transfer speed prior to linking up 2045 * Worst case, this would be FC 1Gbps */ 2046 cpi->base_transfer_speed = 1 * 1000 * 1000; 2047 2048 /* Calculate the max IO supported 2049 * Worst case would be an OS page per SGL entry */ 2050 cpi->maxio = PAGE_SIZE * 2051 (ocs_scsi_get_property(ocs, OCS_SCSI_MAX_SGL) - 1); 2052 2053 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 2054 strncpy(cpi->hba_vid, "Emulex", HBA_IDLEN); 2055 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 2056 cpi->unit_number = cam_sim_unit(sim); 2057 2058 cpi->ccb_h.status = CAM_REQ_CMP; 2059 xpt_done(ccb); 2060 break; 2061 } 2062 case XPT_GET_TRAN_SETTINGS: 2063 { 2064 struct ccb_trans_settings *cts = &ccb->cts; 2065 struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi; 2066 struct ccb_trans_settings_fc *fc = &cts->xport_specific.fc; 2067 ocs_xport_stats_t value; 2068 ocs_fcport *fcp = FCPORT(ocs, bus); 2069 ocs_fc_target_t *tgt = NULL; 2070 2071 if (ocs->ocs_xport != OCS_XPORT_FC) { 2072 ocs_set_ccb_status(ccb, CAM_REQ_INVALID); 2073 xpt_done(ccb); 2074 break; 2075 } 2076 2077 if (cts->ccb_h.target_id > OCS_MAX_TARGETS) { 2078 ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE); 2079 xpt_done(ccb); 2080 break; 2081 } 2082 2083 tgt = &fcp->tgt[cts->ccb_h.target_id]; 2084 if (tgt->state == OCS_TGT_STATE_NONE) { 2085 ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE); 2086 xpt_done(ccb); 2087 break; 2088 } 2089 2090 cts->protocol = PROTO_SCSI; 2091 cts->protocol_version = SCSI_REV_SPC2; 2092 cts->transport = XPORT_FC; 2093 cts->transport_version = 2; 2094 2095 scsi->valid = CTS_SCSI_VALID_TQ; 2096 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB; 2097 2098 /* speed in Mbps */ 2099 ocs_xport_status(ocs->xport, OCS_XPORT_LINK_SPEED, &value); 2100 fc->bitrate = value.value * 100; 2101 2102 fc->wwpn = tgt->wwpn; 2103 2104 fc->wwnn = tgt->wwnn; 2105 2106 fc->port = tgt->port_id; 2107 2108 fc->valid = CTS_FC_VALID_SPEED | 2109 CTS_FC_VALID_WWPN | 2110 CTS_FC_VALID_WWNN | 2111 CTS_FC_VALID_PORT; 2112 2113 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2114 xpt_done(ccb); 2115 break; 2116 } 2117 case XPT_SET_TRAN_SETTINGS: 2118 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2119 xpt_done(ccb); 2120 break; 2121 2122 case XPT_CALC_GEOMETRY: 2123 cam_calc_geometry(&ccb->ccg, TRUE); 2124 xpt_done(ccb); 2125 break; 2126 2127 case XPT_GET_SIM_KNOB: 2128 { 2129 struct ccb_sim_knob *knob = &ccb->knob; 2130 uint64_t wwn = 0; 2131 ocs_fcport *fcp = FCPORT(ocs, bus); 2132 2133 if (ocs->ocs_xport != OCS_XPORT_FC) { 2134 ocs_set_ccb_status(ccb, CAM_REQ_INVALID); 2135 xpt_done(ccb); 2136 break; 2137 } 2138 2139 if (bus == 0) { 2140 wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, 2141 OCS_SCSI_WWNN)); 2142 knob->xport_specific.fc.wwnn = be64toh(wwn); 2143 2144 wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, 2145 OCS_SCSI_WWPN)); 2146 knob->xport_specific.fc.wwpn = be64toh(wwn); 2147 } else { 2148 knob->xport_specific.fc.wwnn = fcp->vport->wwnn; 2149 knob->xport_specific.fc.wwpn = fcp->vport->wwpn; 2150 } 2151 2152 knob->xport_specific.fc.role = fcp->role; 2153 knob->xport_specific.fc.valid = KNOB_VALID_ADDRESS | 2154 KNOB_VALID_ROLE; 2155 2156 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2157 xpt_done(ccb); 2158 break; 2159 } 2160 case XPT_SET_SIM_KNOB: 2161 { 2162 struct ccb_sim_knob *knob = &ccb->knob; 2163 bool role_changed = FALSE; 2164 ocs_fcport *fcp = FCPORT(ocs, bus); 2165 2166 if (ocs->ocs_xport != OCS_XPORT_FC) { 2167 ocs_set_ccb_status(ccb, CAM_REQ_INVALID); 2168 xpt_done(ccb); 2169 break; 2170 } 2171 2172 if (knob->xport_specific.fc.valid & KNOB_VALID_ADDRESS) { 2173 device_printf(ocs->dev, 2174 "%s: XPT_SET_SIM_KNOB wwnn=%llx wwpn=%llx\n", 2175 __func__, 2176 (unsigned long long)knob->xport_specific.fc.wwnn, 2177 (unsigned long long)knob->xport_specific.fc.wwpn); 2178 } 2179 2180 if (knob->xport_specific.fc.valid & KNOB_VALID_ROLE) { 2181 switch (knob->xport_specific.fc.role) { 2182 case KNOB_ROLE_NONE: 2183 if (fcp->role != KNOB_ROLE_NONE) { 2184 role_changed = TRUE; 2185 } 2186 break; 2187 case KNOB_ROLE_TARGET: 2188 if (fcp->role != KNOB_ROLE_TARGET) { 2189 role_changed = TRUE; 2190 } 2191 break; 2192 case KNOB_ROLE_INITIATOR: 2193 if (fcp->role != KNOB_ROLE_INITIATOR) { 2194 role_changed = TRUE; 2195 } 2196 break; 2197 case KNOB_ROLE_BOTH: 2198 if (fcp->role != KNOB_ROLE_BOTH) { 2199 role_changed = TRUE; 2200 } 2201 break; 2202 default: 2203 device_printf(ocs->dev, 2204 "%s: XPT_SET_SIM_KNOB unsupported role: %d\n", 2205 __func__, knob->xport_specific.fc.role); 2206 } 2207 2208 if (role_changed) { 2209 device_printf(ocs->dev, 2210 "BUS:%d XPT_SET_SIM_KNOB old_role: %d new_role: %d\n", 2211 bus, fcp->role, knob->xport_specific.fc.role); 2212 2213 ocs_fcp_change_role(ocs, fcp, knob->xport_specific.fc.role); 2214 } 2215 } 2216 2217 2218 2219 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2220 xpt_done(ccb); 2221 break; 2222 } 2223 case XPT_ABORT: 2224 { 2225 union ccb *accb = ccb->cab.abort_ccb; 2226 2227 switch (accb->ccb_h.func_code) { 2228 case XPT_ACCEPT_TARGET_IO: 2229 ocs_abort_atio(ocs, ccb); 2230 break; 2231 case XPT_IMMEDIATE_NOTIFY: 2232 ocs_abort_inot(ocs, ccb); 2233 break; 2234 case XPT_SCSI_IO: 2235 rc = ocs_abort_initiator_io(ocs, accb); 2236 if (rc) { 2237 ccb->ccb_h.status = CAM_UA_ABORT; 2238 } else { 2239 ccb->ccb_h.status = CAM_REQ_CMP; 2240 } 2241 2242 break; 2243 default: 2244 printf("abort of unknown func %#x\n", 2245 accb->ccb_h.func_code); 2246 ccb->ccb_h.status = CAM_REQ_INVALID; 2247 break; 2248 } 2249 break; 2250 } 2251 case XPT_RESET_BUS: 2252 if (ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE) == 0) { 2253 ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE); 2254 2255 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2256 } else { 2257 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 2258 } 2259 xpt_done(ccb); 2260 break; 2261 case XPT_RESET_DEV: 2262 { 2263 ocs_node_t *node = NULL; 2264 ocs_io_t *io = NULL; 2265 int32_t rc = 0; 2266 ocs_fcport *fcp = FCPORT(ocs, bus); 2267 2268 node = ocs_node_get_instance(ocs, fcp->tgt[ccb_h->target_id].node_id); 2269 if (node == NULL) { 2270 device_printf(ocs->dev, "%s: no device %d\n", 2271 __func__, ccb_h->target_id); 2272 ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE); 2273 xpt_done(ccb); 2274 break; 2275 } 2276 2277 io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR); 2278 if (io == NULL) { 2279 device_printf(ocs->dev, "%s: unable to alloc IO\n", 2280 __func__); 2281 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 2282 xpt_done(ccb); 2283 break; 2284 } 2285 2286 rc = ocs_scsi_send_tmf(node, io, NULL, ccb_h->target_lun, 2287 OCS_SCSI_TMF_LOGICAL_UNIT_RESET, 2288 NULL, 0, 0, /* sgl, sgl_count, length */ 2289 ocs_initiator_tmf_cb, NULL/*arg*/); 2290 2291 if (rc) { 2292 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 2293 } else { 2294 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2295 } 2296 2297 if (node->fcp2device) { 2298 ocs_reset_crn(node, ccb_h->target_lun); 2299 } 2300 2301 xpt_done(ccb); 2302 break; 2303 } 2304 case XPT_EN_LUN: /* target support */ 2305 { 2306 ocs_tgt_resource_t *trsrc = NULL; 2307 uint32_t status = 0; 2308 ocs_fcport *fcp = FCPORT(ocs, bus); 2309 2310 device_printf(ocs->dev, "XPT_EN_LUN %sable %d:%d\n", 2311 ccb->cel.enable ? "en" : "dis", 2312 ccb->ccb_h.target_id, 2313 (unsigned int)ccb->ccb_h.target_lun); 2314 2315 trsrc = ocs_tgt_resource_get(fcp, &ccb->ccb_h, &status); 2316 if (trsrc) { 2317 trsrc->enabled = ccb->cel.enable; 2318 2319 /* Abort all ATIO/INOT on LUN disable */ 2320 if (trsrc->enabled == FALSE) { 2321 ocs_tgt_resource_abort(ocs, trsrc); 2322 } else { 2323 STAILQ_INIT(&trsrc->atio); 2324 STAILQ_INIT(&trsrc->inot); 2325 } 2326 status = CAM_REQ_CMP; 2327 } 2328 2329 ocs_set_ccb_status(ccb, status); 2330 xpt_done(ccb); 2331 break; 2332 } 2333 /* 2334 * The flow of target IOs in CAM is: 2335 * - CAM supplies a number of CCBs to the driver used for received 2336 * commands. 2337 * - when the driver receives a command, it copies the relevant 2338 * information to the CCB and returns it to the CAM using xpt_done() 2339 * - after the target server processes the request, it creates 2340 * a new CCB containing information on how to continue the IO and 2341 * passes that to the driver 2342 * - the driver processes the "continue IO" (a.k.a CTIO) CCB 2343 * - once the IO completes, the driver returns the CTIO to the CAM 2344 * using xpt_done() 2345 */ 2346 case XPT_ACCEPT_TARGET_IO: /* used to inform upper layer of 2347 received CDB (a.k.a. ATIO) */ 2348 case XPT_IMMEDIATE_NOTIFY: /* used to inform upper layer of other 2349 event (a.k.a. INOT) */ 2350 { 2351 ocs_tgt_resource_t *trsrc = NULL; 2352 uint32_t status = 0; 2353 ocs_fcport *fcp = FCPORT(ocs, bus); 2354 2355 /*printf("XPT_%s %p\n", ccb_h->func_code == XPT_ACCEPT_TARGET_IO ? 2356 "ACCEPT_TARGET_IO" : "IMMEDIATE_NOTIFY", ccb);*/ 2357 trsrc = ocs_tgt_resource_get(fcp, &ccb->ccb_h, &status); 2358 if (trsrc == NULL) { 2359 ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE); 2360 xpt_done(ccb); 2361 break; 2362 } 2363 2364 if (XPT_ACCEPT_TARGET_IO == ccb->ccb_h.func_code) { 2365 struct ccb_accept_tio *atio = NULL; 2366 2367 atio = (struct ccb_accept_tio *)ccb; 2368 atio->init_id = 0x0badbeef; 2369 atio->tag_id = 0xdeadc0de; 2370 2371 STAILQ_INSERT_TAIL(&trsrc->atio, &ccb->ccb_h, 2372 sim_links.stqe); 2373 } else { 2374 STAILQ_INSERT_TAIL(&trsrc->inot, &ccb->ccb_h, 2375 sim_links.stqe); 2376 } 2377 ccb->ccb_h.ccb_io_ptr = NULL; 2378 ccb->ccb_h.ccb_ocs_ptr = ocs; 2379 ocs_set_ccb_status(ccb, CAM_REQ_INPROG); 2380 /* 2381 * These actions give resources to the target driver. 2382 * If we didn't return here, this function would call 2383 * xpt_done(), signaling to the upper layers that an 2384 * IO or other event had arrived. 2385 */ 2386 break; 2387 } 2388 case XPT_NOTIFY_ACKNOWLEDGE: 2389 { 2390 ocs_io_t *io = NULL; 2391 ocs_io_t *abortio = NULL; 2392 2393 /* Get the IO reference for this tag */ 2394 io = ocs_scsi_find_io(ocs, ccb->cna2.tag_id); 2395 if (io == NULL) { 2396 device_printf(ocs->dev, 2397 "%s: XPT_NOTIFY_ACKNOWLEDGE no IO with tag %#x\n", 2398 __func__, ccb->cna2.tag_id); 2399 ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR); 2400 xpt_done(ccb); 2401 break; 2402 } 2403 2404 abortio = io->tgt_io.app; 2405 if (abortio) { 2406 abortio->tgt_io.flags &= ~OCS_CAM_IO_F_ABORT_NOTIFY; 2407 device_printf(ocs->dev, 2408 "%s: XPT_NOTIFY_ACK state=%d tag=%#x xid=%#x" 2409 " flags=%#x\n", __func__, abortio->tgt_io.state, 2410 abortio->tag, abortio->init_task_tag, 2411 abortio->tgt_io.flags); 2412 /* TMF response was sent in abort callback */ 2413 } else { 2414 ocs_scsi_send_tmf_resp(io, 2415 OCS_SCSI_TMF_FUNCTION_COMPLETE, 2416 NULL, ocs_target_tmf_cb, NULL); 2417 } 2418 2419 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2420 xpt_done(ccb); 2421 break; 2422 } 2423 case XPT_CONT_TARGET_IO: /* continue target IO, sending data/response (a.k.a. CTIO) */ 2424 if (ocs_target_io(ocs, ccb)) { 2425 device_printf(ocs->dev, 2426 "XPT_CONT_TARGET_IO failed flags=%x tag=%#x\n", 2427 ccb->ccb_h.flags, ccb->csio.tag_id); 2428 xpt_done(ccb); 2429 } 2430 break; 2431 default: 2432 device_printf(ocs->dev, "unhandled func_code = %#x\n", 2433 ccb_h->func_code); 2434 ccb_h->status = CAM_REQ_INVALID; 2435 xpt_done(ccb); 2436 break; 2437 } 2438} 2439 2440/** 2441 * @ingroup cam_api 2442 * @brief Process events 2443 * 2444 * @param sim pointer to the SCSI Interface Module 2445 * 2446 */ 2447static void 2448ocs_poll(struct cam_sim *sim) 2449{ 2450 printf("%s\n", __func__); 2451} 2452 2453static int32_t 2454ocs_initiator_tmf_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, 2455 ocs_scsi_cmd_resp_t *rsp, uint32_t flags, void *arg) 2456{ 2457 int32_t rc = 0; 2458 2459 switch (scsi_status) { 2460 case OCS_SCSI_STATUS_GOOD: 2461 case OCS_SCSI_STATUS_NO_IO: 2462 break; 2463 case OCS_SCSI_STATUS_CHECK_RESPONSE: 2464 if (rsp->response_data_length == 0) { 2465 ocs_log_test(io->ocs, "check response without data?!?\n"); 2466 rc = -1; 2467 break; 2468 } 2469 2470 if (rsp->response_data[3] != 0) { 2471 ocs_log_test(io->ocs, "TMF status %08x\n", 2472 be32toh(*((uint32_t *)rsp->response_data))); 2473 rc = -1; 2474 break; 2475 } 2476 break; 2477 default: 2478 ocs_log_test(io->ocs, "status=%#x\n", scsi_status); 2479 rc = -1; 2480 } 2481 2482 ocs_scsi_io_free(io); 2483 2484 return rc; 2485} 2486 2487/** 2488 * @brief lookup target resource structure 2489 * 2490 * Arbitrarily support 2491 * - wildcard target ID + LU 2492 * - 0 target ID + non-wildcard LU 2493 * 2494 * @param ocs the driver instance's software context 2495 * @param ccb_h pointer to the CCB header 2496 * @param status returned status value 2497 * 2498 * @return pointer to the target resource, NULL if none available (e.g. if LU 2499 * is not enabled) 2500 */ 2501static ocs_tgt_resource_t *ocs_tgt_resource_get(ocs_fcport *fcp, 2502 struct ccb_hdr *ccb_h, uint32_t *status) 2503{ 2504 target_id_t tid = ccb_h->target_id; 2505 lun_id_t lun = ccb_h->target_lun; 2506 2507 if (CAM_TARGET_WILDCARD == tid) { 2508 if (CAM_LUN_WILDCARD != lun) { 2509 *status = CAM_LUN_INVALID; 2510 return NULL; 2511 } 2512 return &fcp->targ_rsrc_wildcard; 2513 } else { 2514 if (lun < OCS_MAX_LUN) { 2515 return &fcp->targ_rsrc[lun]; 2516 } else { 2517 *status = CAM_LUN_INVALID; 2518 return NULL; 2519 } 2520 } 2521 2522} 2523 2524static int32_t 2525ocs_tgt_resource_abort(struct ocs_softc *ocs, ocs_tgt_resource_t *trsrc) 2526{ 2527 union ccb *ccb = NULL; 2528 uint32_t count; 2529 2530 count = 0; 2531 do { 2532 ccb = (union ccb *)STAILQ_FIRST(&trsrc->atio); 2533 if (ccb) { 2534 STAILQ_REMOVE_HEAD(&trsrc->atio, sim_links.stqe); 2535 ccb->ccb_h.status = CAM_REQ_ABORTED; 2536 xpt_done(ccb); 2537 count++; 2538 } 2539 } while (ccb); 2540 2541 count = 0; 2542 do { 2543 ccb = (union ccb *)STAILQ_FIRST(&trsrc->inot); 2544 if (ccb) { 2545 STAILQ_REMOVE_HEAD(&trsrc->inot, sim_links.stqe); 2546 ccb->ccb_h.status = CAM_REQ_ABORTED; 2547 xpt_done(ccb); 2548 count++; 2549 } 2550 } while (ccb); 2551 2552 return 0; 2553} 2554 2555static void 2556ocs_abort_atio(struct ocs_softc *ocs, union ccb *ccb) 2557{ 2558 2559 ocs_io_t *aio = NULL; 2560 ocs_tgt_resource_t *trsrc = NULL; 2561 uint32_t status = CAM_REQ_INVALID; 2562 struct ccb_hdr *cur = NULL; 2563 union ccb *accb = ccb->cab.abort_ccb; 2564 2565 int bus = cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path)); 2566 ocs_fcport *fcp = FCPORT(ocs, bus); 2567 2568 trsrc = ocs_tgt_resource_get(fcp, &accb->ccb_h, &status); 2569 if (trsrc != NULL) { 2570 STAILQ_FOREACH(cur, &trsrc->atio, sim_links.stqe) { 2571 if (cur != &accb->ccb_h) 2572 continue; 2573 2574 STAILQ_REMOVE(&trsrc->atio, cur, ccb_hdr, 2575 sim_links.stqe); 2576 accb->ccb_h.status = CAM_REQ_ABORTED; 2577 xpt_done(accb); 2578 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2579 return; 2580 } 2581 } 2582 2583 /* if the ATIO has a valid IO pointer, CAM is telling 2584 * the driver that the ATIO (which represents the entire 2585 * exchange) has been aborted. */ 2586 2587 aio = accb->ccb_h.ccb_io_ptr; 2588 if (aio == NULL) { 2589 ccb->ccb_h.status = CAM_UA_ABORT; 2590 return; 2591 } 2592 2593 device_printf(ocs->dev, 2594 "%s: XPT_ABORT ATIO state=%d tag=%#x" 2595 " xid=%#x flags=%#x\n", __func__, 2596 aio->tgt_io.state, aio->tag, 2597 aio->init_task_tag, aio->tgt_io.flags); 2598 /* Expectations are: 2599 * - abort task was received 2600 * - already aborted IO in the DEVICE 2601 * - already received NOTIFY ACKNOWLEDGE */ 2602 2603 if ((aio->tgt_io.flags & OCS_CAM_IO_F_ABORT_RECV) == 0) { 2604 device_printf(ocs->dev, "%s: abort not received or io completed \n", __func__); 2605 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2606 return; 2607 } 2608 2609 aio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_CAM; 2610 ocs_target_io_free(aio); 2611 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2612 2613 return; 2614} 2615 2616static void 2617ocs_abort_inot(struct ocs_softc *ocs, union ccb *ccb) 2618{ 2619 ocs_tgt_resource_t *trsrc = NULL; 2620 uint32_t status = CAM_REQ_INVALID; 2621 struct ccb_hdr *cur = NULL; 2622 union ccb *accb = ccb->cab.abort_ccb; 2623 2624 int bus = cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path)); 2625 ocs_fcport *fcp = FCPORT(ocs, bus); 2626 2627 trsrc = ocs_tgt_resource_get(fcp, &accb->ccb_h, &status); 2628 if (trsrc) { 2629 STAILQ_FOREACH(cur, &trsrc->inot, sim_links.stqe) { 2630 if (cur != &accb->ccb_h) 2631 continue; 2632 2633 STAILQ_REMOVE(&trsrc->inot, cur, ccb_hdr, 2634 sim_links.stqe); 2635 accb->ccb_h.status = CAM_REQ_ABORTED; 2636 xpt_done(accb); 2637 ocs_set_ccb_status(ccb, CAM_REQ_CMP); 2638 return; 2639 } 2640 } 2641 2642 ocs_set_ccb_status(ccb, CAM_UA_ABORT); 2643 return; 2644} 2645 2646static uint32_t 2647ocs_abort_initiator_io(struct ocs_softc *ocs, union ccb *accb) 2648{ 2649 2650 ocs_node_t *node = NULL; 2651 ocs_io_t *io = NULL; 2652 int32_t rc = 0; 2653 struct ccb_scsiio *csio = &accb->csio; 2654 2655 ocs_fcport *fcp = FCPORT(ocs, cam_sim_bus(xpt_path_sim((accb)->ccb_h.path))); 2656 node = ocs_node_get_instance(ocs, fcp->tgt[accb->ccb_h.target_id].node_id); 2657 if (node == NULL) { 2658 device_printf(ocs->dev, "%s: no device %d\n", 2659 __func__, accb->ccb_h.target_id); 2660 ocs_set_ccb_status(accb, CAM_DEV_NOT_THERE); 2661 xpt_done(accb); 2662 return (-1); 2663 } 2664 2665 io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR); 2666 if (io == NULL) { 2667 device_printf(ocs->dev, 2668 "%s: unable to alloc IO\n", __func__); 2669 ocs_set_ccb_status(accb, CAM_REQ_CMP_ERR); 2670 xpt_done(accb); 2671 return (-1); 2672 } 2673 2674 rc = ocs_scsi_send_tmf(node, io, 2675 (ocs_io_t *)csio->ccb_h.ccb_io_ptr, 2676 accb->ccb_h.target_lun, 2677 OCS_SCSI_TMF_ABORT_TASK, 2678 NULL, 0, 0, 2679 ocs_initiator_tmf_cb, NULL/*arg*/); 2680 2681 return rc; 2682} 2683 2684void 2685ocs_scsi_ini_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj) 2686{ 2687 switch(type) { 2688 case OCS_SCSI_DDUMP_DEVICE: { 2689 //ocs_t *ocs = obj; 2690 break; 2691 } 2692 case OCS_SCSI_DDUMP_DOMAIN: { 2693 //ocs_domain_t *domain = obj; 2694 break; 2695 } 2696 case OCS_SCSI_DDUMP_SPORT: { 2697 //ocs_sport_t *sport = obj; 2698 break; 2699 } 2700 case OCS_SCSI_DDUMP_NODE: { 2701 //ocs_node_t *node = obj; 2702 break; 2703 } 2704 case OCS_SCSI_DDUMP_IO: { 2705 //ocs_io_t *io = obj; 2706 break; 2707 } 2708 default: { 2709 break; 2710 } 2711 } 2712} 2713 2714void 2715ocs_scsi_tgt_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj) 2716{ 2717 switch(type) { 2718 case OCS_SCSI_DDUMP_DEVICE: { 2719 //ocs_t *ocs = obj; 2720 break; 2721 } 2722 case OCS_SCSI_DDUMP_DOMAIN: { 2723 //ocs_domain_t *domain = obj; 2724 break; 2725 } 2726 case OCS_SCSI_DDUMP_SPORT: { 2727 //ocs_sport_t *sport = obj; 2728 break; 2729 } 2730 case OCS_SCSI_DDUMP_NODE: { 2731 //ocs_node_t *node = obj; 2732 break; 2733 } 2734 case OCS_SCSI_DDUMP_IO: { 2735 ocs_io_t *io = obj; 2736 char *state_str = NULL; 2737 2738 switch (io->tgt_io.state) { 2739 case OCS_CAM_IO_FREE: 2740 state_str = "FREE"; 2741 break; 2742 case OCS_CAM_IO_COMMAND: 2743 state_str = "COMMAND"; 2744 break; 2745 case OCS_CAM_IO_DATA: 2746 state_str = "DATA"; 2747 break; 2748 case OCS_CAM_IO_DATA_DONE: 2749 state_str = "DATA_DONE"; 2750 break; 2751 case OCS_CAM_IO_RESP: 2752 state_str = "RESP"; 2753 break; 2754 default: 2755 state_str = "xxx BAD xxx"; 2756 } 2757 ocs_ddump_value(textbuf, "cam_st", "%s", state_str); 2758 if (io->tgt_io.app) { 2759 ocs_ddump_value(textbuf, "cam_flags", "%#x", 2760 ((union ccb *)(io->tgt_io.app))->ccb_h.flags); 2761 ocs_ddump_value(textbuf, "cam_status", "%#x", 2762 ((union ccb *)(io->tgt_io.app))->ccb_h.status); 2763 } 2764 2765 break; 2766 } 2767 default: { 2768 break; 2769 } 2770 } 2771} 2772 2773int32_t ocs_scsi_get_block_vaddr(ocs_io_t *io, uint64_t blocknumber, 2774 ocs_scsi_vaddr_len_t addrlen[], 2775 uint32_t max_addrlen, void **dif_vaddr) 2776{ 2777 return -1; 2778} 2779 2780uint32_t 2781ocs_get_crn(ocs_node_t *node, uint8_t *crn, uint64_t lun) 2782{ 2783 uint32_t idx; 2784 struct ocs_lun_crn *lcrn = NULL; 2785 idx = lun % OCS_MAX_LUN; 2786 2787 lcrn = node->ini_node.lun_crn[idx]; 2788 2789 if (lcrn == NULL) { 2790 lcrn = ocs_malloc(node->ocs, sizeof(struct ocs_lun_crn), 2791 M_ZERO|M_NOWAIT); 2792 if (lcrn == NULL) { 2793 return (1); 2794 } 2795 2796 lcrn->lun = lun; 2797 node->ini_node.lun_crn[idx] = lcrn; 2798 } 2799 2800 if (lcrn->lun != lun) { 2801 return (1); 2802 } 2803 2804 if (lcrn->crnseed == 0) 2805 lcrn->crnseed = 1; 2806 2807 *crn = lcrn->crnseed++; 2808 return (0); 2809} 2810 2811void 2812ocs_del_crn(ocs_node_t *node) 2813{ 2814 uint32_t i; 2815 struct ocs_lun_crn *lcrn = NULL; 2816 2817 for(i = 0; i < OCS_MAX_LUN; i++) { 2818 lcrn = node->ini_node.lun_crn[i]; 2819 if (lcrn) { 2820 ocs_free(node->ocs, lcrn, sizeof(*lcrn)); 2821 } 2822 } 2823 2824 return; 2825} 2826 2827void 2828ocs_reset_crn(ocs_node_t *node, uint64_t lun) 2829{ 2830 uint32_t idx; 2831 struct ocs_lun_crn *lcrn = NULL; 2832 idx = lun % OCS_MAX_LUN; 2833 2834 lcrn = node->ini_node.lun_crn[idx]; 2835 if (lcrn) 2836 lcrn->crnseed = 0; 2837 2838 return; 2839} 2840