2861 lines
70 KiB
C
2861 lines
70 KiB
C
/*-
|
|
* Copyright (c) 2017 Broadcom. All rights reserved.
|
|
* The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/**
|
|
* @defgroup scsi_api_target SCSI Target API
|
|
* @defgroup scsi_api_initiator SCSI Initiator API
|
|
* @defgroup cam_api Common Access Method (CAM) API
|
|
* @defgroup cam_io CAM IO
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* Provides CAM functionality.
|
|
*/
|
|
|
|
#include "ocs.h"
|
|
#include "ocs_scsi.h"
|
|
#include "ocs_device.h"
|
|
|
|
/* Default IO timeout value for initiators is 30 seconds */
|
|
#define OCS_CAM_IO_TIMEOUT 30
|
|
|
|
typedef struct {
|
|
ocs_scsi_sgl_t *sgl;
|
|
uint32_t sgl_max;
|
|
uint32_t sgl_count;
|
|
int32_t rc;
|
|
} ocs_dmamap_load_arg_t;
|
|
|
|
static void ocs_action(struct cam_sim *, union ccb *);
|
|
static void ocs_poll(struct cam_sim *);
|
|
|
|
static ocs_tgt_resource_t *ocs_tgt_resource_get(ocs_fcport *,
|
|
struct ccb_hdr *, uint32_t *);
|
|
static int32_t ocs_tgt_resource_abort(struct ocs_softc *, ocs_tgt_resource_t *);
|
|
static uint32_t ocs_abort_initiator_io(struct ocs_softc *ocs, union ccb *accb);
|
|
static void ocs_abort_inot(struct ocs_softc *ocs, union ccb *ccb);
|
|
static void ocs_abort_atio(struct ocs_softc *ocs, union ccb *ccb);
|
|
static int32_t ocs_target_tmf_cb(ocs_io_t *, ocs_scsi_io_status_e, uint32_t, void *);
|
|
static int32_t ocs_io_abort_cb(ocs_io_t *, ocs_scsi_io_status_e, uint32_t, void *);
|
|
static int32_t ocs_task_set_full_or_busy(ocs_io_t *io);
|
|
static int32_t ocs_initiator_tmf_cb(ocs_io_t *, ocs_scsi_io_status_e,
|
|
ocs_scsi_cmd_resp_t *, uint32_t, void *);
|
|
static uint32_t
|
|
ocs_fcp_change_role(struct ocs_softc *ocs, ocs_fcport *fcp, uint32_t new_role);
|
|
|
|
static void ocs_ldt(void *arg);
|
|
static void ocs_ldt_task(void *arg, int pending);
|
|
static void ocs_delete_target(ocs_t *ocs, ocs_fcport *fcp, int tgt);
|
|
uint32_t ocs_add_new_tgt(ocs_node_t *node, ocs_fcport *fcp);
|
|
uint32_t ocs_update_tgt(ocs_node_t *node, ocs_fcport *fcp, uint32_t tgt_id);
|
|
|
|
int32_t ocs_tgt_find(ocs_fcport *fcp, ocs_node_t *node);
|
|
|
|
static inline ocs_io_t *ocs_scsi_find_io(struct ocs_softc *ocs, uint32_t tag)
|
|
{
|
|
|
|
return ocs_io_get_instance(ocs, tag);
|
|
}
|
|
|
|
static inline void ocs_target_io_free(ocs_io_t *io)
|
|
{
|
|
io->tgt_io.state = OCS_CAM_IO_FREE;
|
|
io->tgt_io.flags = 0;
|
|
io->tgt_io.app = NULL;
|
|
ocs_scsi_io_complete(io);
|
|
if(io->ocs->io_in_use != 0)
|
|
atomic_subtract_acq_32(&io->ocs->io_in_use, 1);
|
|
}
|
|
|
|
static int32_t
|
|
ocs_attach_port(ocs_t *ocs, int chan)
|
|
{
|
|
|
|
struct cam_sim *sim = NULL;
|
|
struct cam_path *path = NULL;
|
|
uint32_t max_io = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS);
|
|
ocs_fcport *fcp = FCPORT(ocs, chan);
|
|
|
|
if (NULL == (sim = cam_sim_alloc(ocs_action, ocs_poll,
|
|
device_get_name(ocs->dev), ocs,
|
|
device_get_unit(ocs->dev), &ocs->sim_lock,
|
|
max_io, max_io, ocs->devq))) {
|
|
device_printf(ocs->dev, "Can't allocate SIM\n");
|
|
return 1;
|
|
}
|
|
|
|
mtx_lock(&ocs->sim_lock);
|
|
if (CAM_SUCCESS != xpt_bus_register(sim, ocs->dev, chan)) {
|
|
device_printf(ocs->dev, "Can't register bus %d\n", 0);
|
|
mtx_unlock(&ocs->sim_lock);
|
|
cam_sim_free(sim, FALSE);
|
|
return 1;
|
|
}
|
|
mtx_unlock(&ocs->sim_lock);
|
|
|
|
if (CAM_REQ_CMP != xpt_create_path(&path, NULL, cam_sim_path(sim),
|
|
CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)) {
|
|
device_printf(ocs->dev, "Can't create path\n");
|
|
xpt_bus_deregister(cam_sim_path(sim));
|
|
mtx_unlock(&ocs->sim_lock);
|
|
cam_sim_free(sim, FALSE);
|
|
return 1;
|
|
}
|
|
|
|
fcp->ocs = ocs;
|
|
fcp->sim = sim;
|
|
fcp->path = path;
|
|
|
|
callout_init_mtx(&fcp->ldt, &ocs->sim_lock, 0);
|
|
TASK_INIT(&fcp->ltask, 1, ocs_ldt_task, fcp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int32_t
|
|
ocs_detach_port(ocs_t *ocs, int32_t chan)
|
|
{
|
|
ocs_fcport *fcp = NULL;
|
|
struct cam_sim *sim = NULL;
|
|
struct cam_path *path = NULL;
|
|
fcp = FCPORT(ocs, chan);
|
|
|
|
sim = fcp->sim;
|
|
path = fcp->path;
|
|
|
|
callout_drain(&fcp->ldt);
|
|
ocs_ldt_task(fcp, 0);
|
|
|
|
if (fcp->sim) {
|
|
mtx_lock(&ocs->sim_lock);
|
|
ocs_tgt_resource_abort(ocs, &fcp->targ_rsrc_wildcard);
|
|
if (path) {
|
|
xpt_async(AC_LOST_DEVICE, path, NULL);
|
|
xpt_free_path(path);
|
|
fcp->path = NULL;
|
|
}
|
|
xpt_bus_deregister(cam_sim_path(sim));
|
|
|
|
cam_sim_free(sim, FALSE);
|
|
fcp->sim = NULL;
|
|
mtx_unlock(&ocs->sim_lock);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
ocs_cam_attach(ocs_t *ocs)
|
|
{
|
|
struct cam_devq *devq = NULL;
|
|
int i = 0;
|
|
uint32_t max_io = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS);
|
|
|
|
if (NULL == (devq = cam_simq_alloc(max_io))) {
|
|
device_printf(ocs->dev, "Can't allocate SIMQ\n");
|
|
return -1;
|
|
}
|
|
|
|
ocs->devq = devq;
|
|
|
|
if (mtx_initialized(&ocs->sim_lock) == 0) {
|
|
mtx_init(&ocs->sim_lock, "ocs_sim_lock", NULL, MTX_DEF);
|
|
}
|
|
|
|
for (i = 0; i < (ocs->num_vports + 1); i++) {
|
|
if (ocs_attach_port(ocs, i)) {
|
|
ocs_log_err(ocs, "Attach port failed for chan: %d\n", i);
|
|
goto detach_port;
|
|
}
|
|
}
|
|
|
|
ocs->io_high_watermark = max_io;
|
|
ocs->io_in_use = 0;
|
|
return 0;
|
|
|
|
detach_port:
|
|
while (--i >= 0) {
|
|
ocs_detach_port(ocs, i);
|
|
}
|
|
|
|
cam_simq_free(ocs->devq);
|
|
|
|
if (mtx_initialized(&ocs->sim_lock))
|
|
mtx_destroy(&ocs->sim_lock);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
ocs_cam_detach(ocs_t *ocs)
|
|
{
|
|
int i = 0;
|
|
|
|
for (i = (ocs->num_vports); i >= 0; i--) {
|
|
ocs_detach_port(ocs, i);
|
|
}
|
|
|
|
cam_simq_free(ocs->devq);
|
|
|
|
if (mtx_initialized(&ocs->sim_lock))
|
|
mtx_destroy(&ocs->sim_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***************************************************************************
|
|
* Functions required by SCSI base driver API
|
|
*/
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief Attach driver to the BSD SCSI layer (a.k.a CAM)
|
|
*
|
|
* Allocates + initializes CAM related resources and attaches to the CAM
|
|
*
|
|
* @param ocs the driver instance's software context
|
|
*
|
|
* @return 0 on success, non-zero otherwise
|
|
*/
|
|
int32_t
|
|
ocs_scsi_tgt_new_device(ocs_t *ocs)
|
|
{
|
|
ocs->enable_task_set_full = ocs_scsi_get_property(ocs,
|
|
OCS_SCSI_ENABLE_TASK_SET_FULL);
|
|
ocs_log_debug(ocs, "task set full processing is %s\n",
|
|
ocs->enable_task_set_full ? "enabled" : "disabled");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief Tears down target members of ocs structure.
|
|
*
|
|
* Called by OS code when device is removed.
|
|
*
|
|
* @param ocs pointer to ocs
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_tgt_del_device(ocs_t *ocs)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief accept new domain notification
|
|
*
|
|
* Called by base drive when new domain is discovered. A target-server
|
|
* will use this call to prepare for new remote node notifications
|
|
* arising from ocs_scsi_new_initiator().
|
|
*
|
|
* The domain context has an element <b>ocs_scsi_tgt_domain_t tgt_domain</b>
|
|
* which is declared by the target-server code and is used for target-server
|
|
* private data.
|
|
*
|
|
* This function will only be called if the base-driver has been enabled for
|
|
* target capability.
|
|
*
|
|
* Note that this call is made to target-server backends,
|
|
* the ocs_scsi_ini_new_domain() function is called to initiator-client backends.
|
|
*
|
|
* @param domain pointer to domain
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_tgt_new_domain(ocs_domain_t *domain)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief accept domain lost notification
|
|
*
|
|
* Called by base-driver when a domain goes away. A target-server will
|
|
* use this call to clean up all domain scoped resources.
|
|
*
|
|
* Note that this call is made to target-server backends,
|
|
* the ocs_scsi_ini_del_domain() function is called to initiator-client backends.
|
|
*
|
|
* @param domain pointer to domain
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
void
|
|
ocs_scsi_tgt_del_domain(ocs_domain_t *domain)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief accept new sli port (sport) notification
|
|
*
|
|
* Called by base drive when new sport is discovered. A target-server
|
|
* will use this call to prepare for new remote node notifications
|
|
* arising from ocs_scsi_new_initiator().
|
|
*
|
|
* The domain context has an element <b>ocs_scsi_tgt_sport_t tgt_sport</b>
|
|
* which is declared by the target-server code and is used for
|
|
* target-server private data.
|
|
*
|
|
* This function will only be called if the base-driver has been enabled for
|
|
* target capability.
|
|
*
|
|
* Note that this call is made to target-server backends,
|
|
* the ocs_scsi_tgt_new_domain() is called to initiator-client backends.
|
|
*
|
|
* @param sport pointer to SLI port
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_tgt_new_sport(ocs_sport_t *sport)
|
|
{
|
|
ocs_t *ocs = sport->ocs;
|
|
|
|
if(!sport->is_vport) {
|
|
sport->tgt_data = FCPORT(ocs, 0);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief accept SLI port gone notification
|
|
*
|
|
* Called by base-driver when a sport goes away. A target-server will
|
|
* use this call to clean up all sport scoped resources.
|
|
*
|
|
* Note that this call is made to target-server backends,
|
|
* the ocs_scsi_ini_del_sport() is called to initiator-client backends.
|
|
*
|
|
* @param sport pointer to SLI port
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
void
|
|
ocs_scsi_tgt_del_sport(ocs_sport_t *sport)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief receive notification of a new SCSI initiator node
|
|
*
|
|
* Sent by base driver to notify a target-server of the presense of a new
|
|
* remote initiator. The target-server may use this call to prepare for
|
|
* inbound IO from this node.
|
|
*
|
|
* The ocs_node_t structure has and elment of type ocs_scsi_tgt_node_t named
|
|
* tgt_node that is declared and used by a target-server for private
|
|
* information.
|
|
*
|
|
* This function is only called if the target capability is enabled in driver.
|
|
*
|
|
* @param node pointer to new remote initiator node
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*
|
|
* @note
|
|
*/
|
|
int32_t
|
|
ocs_scsi_new_initiator(ocs_node_t *node)
|
|
{
|
|
ocs_t *ocs = node->ocs;
|
|
struct ac_contract ac;
|
|
struct ac_device_changed *adc;
|
|
|
|
ocs_fcport *fcp = NULL;
|
|
|
|
fcp = node->sport->tgt_data;
|
|
if (fcp == NULL) {
|
|
ocs_log_err(ocs, "FCP is NULL \n");
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Update the IO watermark by decrementing it by the
|
|
* number of IOs reserved for each initiator.
|
|
*/
|
|
atomic_subtract_acq_32(&ocs->io_high_watermark, OCS_RSVD_INI_IO);
|
|
|
|
ac.contract_number = AC_CONTRACT_DEV_CHG;
|
|
adc = (struct ac_device_changed *) ac.contract_data;
|
|
adc->wwpn = ocs_node_get_wwpn(node);
|
|
adc->port = node->rnode.fc_id;
|
|
adc->target = node->instance_index;
|
|
adc->arrived = 1;
|
|
xpt_async(AC_CONTRACT, fcp->path, &ac);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief validate new initiator
|
|
*
|
|
* Sent by base driver to validate a remote initiatiator. The target-server
|
|
* returns TRUE if this initiator should be accepted.
|
|
*
|
|
* This function is only called if the target capability is enabled in driver.
|
|
*
|
|
* @param node pointer to remote initiator node to validate
|
|
*
|
|
* @return TRUE if initiator should be accepted, FALSE if it should be rejected
|
|
*
|
|
* @note
|
|
*/
|
|
|
|
int32_t
|
|
ocs_scsi_validate_initiator(ocs_node_t *node)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief Delete a SCSI initiator node
|
|
*
|
|
* Sent by base driver to notify a target-server that a remote initiator
|
|
* is now gone. The base driver will have terminated all outstanding IOs
|
|
* and the target-server will receive appropriate completions.
|
|
*
|
|
* This function is only called if the base driver is enabled for
|
|
* target capability.
|
|
*
|
|
* @param node pointer node being deleted
|
|
* @param reason Reason why initiator is gone.
|
|
*
|
|
* @return OCS_SCSI_CALL_COMPLETE to indicate that all work was completed
|
|
*
|
|
* @note
|
|
*/
|
|
int32_t
|
|
ocs_scsi_del_initiator(ocs_node_t *node, ocs_scsi_del_initiator_reason_e reason)
|
|
{
|
|
ocs_t *ocs = node->ocs;
|
|
|
|
struct ac_contract ac;
|
|
struct ac_device_changed *adc;
|
|
ocs_fcport *fcp = NULL;
|
|
|
|
fcp = node->sport->tgt_data;
|
|
if (fcp == NULL) {
|
|
ocs_log_err(ocs, "FCP is NULL \n");
|
|
return 1;
|
|
}
|
|
|
|
ac.contract_number = AC_CONTRACT_DEV_CHG;
|
|
adc = (struct ac_device_changed *) ac.contract_data;
|
|
adc->wwpn = ocs_node_get_wwpn(node);
|
|
adc->port = node->rnode.fc_id;
|
|
adc->target = node->instance_index;
|
|
adc->arrived = 0;
|
|
xpt_async(AC_CONTRACT, fcp->path, &ac);
|
|
|
|
if (reason == OCS_SCSI_INITIATOR_MISSING) {
|
|
return OCS_SCSI_CALL_COMPLETE;
|
|
}
|
|
|
|
/*
|
|
* Update the IO watermark by incrementing it by the
|
|
* number of IOs reserved for each initiator.
|
|
*/
|
|
atomic_add_acq_32(&ocs->io_high_watermark, OCS_RSVD_INI_IO);
|
|
|
|
return OCS_SCSI_CALL_COMPLETE;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief receive FCP SCSI Command
|
|
*
|
|
* Called by the base driver when a new SCSI command has been received. The
|
|
* target-server will process the command, and issue data and/or response phase
|
|
* requests to the base driver.
|
|
*
|
|
* The IO context (ocs_io_t) structure has and element of type
|
|
* ocs_scsi_tgt_io_t named tgt_io that is declared and used by
|
|
* a target-server for private information.
|
|
*
|
|
* @param io pointer to IO context
|
|
* @param lun LUN for this IO
|
|
* @param cdb pointer to SCSI CDB
|
|
* @param cdb_len length of CDB in bytes
|
|
* @param flags command flags
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t ocs_scsi_recv_cmd(ocs_io_t *io, uint64_t lun, uint8_t *cdb,
|
|
uint32_t cdb_len, uint32_t flags)
|
|
{
|
|
ocs_t *ocs = io->ocs;
|
|
struct ccb_accept_tio *atio = NULL;
|
|
ocs_node_t *node = io->node;
|
|
ocs_tgt_resource_t *trsrc = NULL;
|
|
int32_t rc = -1;
|
|
ocs_fcport *fcp = NULL;
|
|
|
|
fcp = node->sport->tgt_data;
|
|
if (fcp == NULL) {
|
|
ocs_log_err(ocs, "FCP is NULL \n");
|
|
return 1;
|
|
}
|
|
|
|
atomic_add_acq_32(&ocs->io_in_use, 1);
|
|
|
|
/* set target io timeout */
|
|
io->timeout = ocs->target_io_timer_sec;
|
|
|
|
if (ocs->enable_task_set_full &&
|
|
(ocs->io_in_use >= ocs->io_high_watermark)) {
|
|
return ocs_task_set_full_or_busy(io);
|
|
} else {
|
|
atomic_store_rel_32(&io->node->tgt_node.busy_sent, FALSE);
|
|
}
|
|
|
|
if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) {
|
|
trsrc = &fcp->targ_rsrc[lun];
|
|
} else if (fcp->targ_rsrc_wildcard.enabled) {
|
|
trsrc = &fcp->targ_rsrc_wildcard;
|
|
}
|
|
|
|
if (trsrc) {
|
|
atio = (struct ccb_accept_tio *)STAILQ_FIRST(&trsrc->atio);
|
|
}
|
|
|
|
if (atio) {
|
|
STAILQ_REMOVE_HEAD(&trsrc->atio, sim_links.stqe);
|
|
|
|
atio->ccb_h.status = CAM_CDB_RECVD;
|
|
atio->ccb_h.target_lun = lun;
|
|
atio->sense_len = 0;
|
|
|
|
atio->init_id = node->instance_index;
|
|
atio->tag_id = io->tag;
|
|
atio->ccb_h.ccb_io_ptr = io;
|
|
|
|
if (flags & OCS_SCSI_CMD_SIMPLE)
|
|
atio->tag_action = MSG_SIMPLE_Q_TAG;
|
|
else if (flags & OCS_SCSI_CMD_HEAD_OF_QUEUE)
|
|
atio->tag_action = MSG_HEAD_OF_Q_TAG;
|
|
else if (flags & OCS_SCSI_CMD_ORDERED)
|
|
atio->tag_action = MSG_ORDERED_Q_TAG;
|
|
else if (flags & OCS_SCSI_CMD_ACA)
|
|
atio->tag_action = MSG_ACA_TASK;
|
|
else
|
|
atio->tag_action = CAM_TAG_ACTION_NONE;
|
|
atio->priority = (flags & OCS_SCSI_PRIORITY_MASK) >>
|
|
OCS_SCSI_PRIORITY_SHIFT;
|
|
|
|
atio->cdb_len = cdb_len;
|
|
ocs_memcpy(atio->cdb_io.cdb_bytes, cdb, cdb_len);
|
|
|
|
io->tgt_io.flags = 0;
|
|
io->tgt_io.state = OCS_CAM_IO_COMMAND;
|
|
io->tgt_io.lun = lun;
|
|
|
|
xpt_done((union ccb *)atio);
|
|
|
|
rc = 0;
|
|
} else {
|
|
device_printf(
|
|
ocs->dev, "%s: no ATIO for LUN %lx (en=%s) OX_ID %#x\n",
|
|
__func__, (unsigned long)lun,
|
|
trsrc ? (trsrc->enabled ? "T" : "F") : "X",
|
|
be16toh(io->init_task_tag));
|
|
|
|
io->tgt_io.state = OCS_CAM_IO_MAX;
|
|
ocs_target_io_free(io);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief receive FCP SCSI Command with first burst data.
|
|
*
|
|
* Receive a new FCP SCSI command from the base driver with first burst data.
|
|
*
|
|
* @param io pointer to IO context
|
|
* @param lun LUN for this IO
|
|
* @param cdb pointer to SCSI CDB
|
|
* @param cdb_len length of CDB in bytes
|
|
* @param flags command flags
|
|
* @param first_burst_buffers first burst buffers
|
|
* @param first_burst_buffer_count The number of bytes received in the first burst
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t ocs_scsi_recv_cmd_first_burst(ocs_io_t *io, uint64_t lun, uint8_t *cdb,
|
|
uint32_t cdb_len, uint32_t flags,
|
|
ocs_dma_t first_burst_buffers[],
|
|
uint32_t first_burst_buffer_count)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_target
|
|
* @brief receive a TMF command IO
|
|
*
|
|
* Called by the base driver when a SCSI TMF command has been received. The
|
|
* target-server will process the command, aborting commands as needed, and post
|
|
* a response using ocs_scsi_send_resp()
|
|
*
|
|
* The IO context (ocs_io_t) structure has and element of type ocs_scsi_tgt_io_t named
|
|
* tgt_io that is declared and used by a target-server for private information.
|
|
*
|
|
* If the target-server walks the nodes active_ios linked list, and starts IO
|
|
* abort processing, the code <b>must</b> be sure not to abort the IO passed into the
|
|
* ocs_scsi_recv_tmf() command.
|
|
*
|
|
* @param tmfio pointer to IO context
|
|
* @param lun logical unit value
|
|
* @param cmd command request
|
|
* @param abortio pointer to IO object to abort for TASK_ABORT (NULL for all other TMF)
|
|
* @param flags flags
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t ocs_scsi_recv_tmf(ocs_io_t *tmfio, uint64_t lun, ocs_scsi_tmf_cmd_e cmd,
|
|
ocs_io_t *abortio, uint32_t flags)
|
|
{
|
|
ocs_t *ocs = tmfio->ocs;
|
|
ocs_node_t *node = tmfio->node;
|
|
ocs_tgt_resource_t *trsrc = NULL;
|
|
struct ccb_immediate_notify *inot = NULL;
|
|
int32_t rc = -1;
|
|
ocs_fcport *fcp = NULL;
|
|
|
|
fcp = node->sport->tgt_data;
|
|
if (fcp == NULL) {
|
|
ocs_log_err(ocs, "FCP is NULL \n");
|
|
return 1;
|
|
}
|
|
|
|
if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) {
|
|
trsrc = &fcp->targ_rsrc[lun];
|
|
} else if (fcp->targ_rsrc_wildcard.enabled) {
|
|
trsrc = &fcp->targ_rsrc_wildcard;
|
|
}
|
|
|
|
device_printf(tmfio->ocs->dev, "%s: io=%p cmd=%#x LU=%lx en=%s\n",
|
|
__func__, tmfio, cmd, (unsigned long)lun,
|
|
trsrc ? (trsrc->enabled ? "T" : "F") : "X");
|
|
if (trsrc) {
|
|
inot = (struct ccb_immediate_notify *)STAILQ_FIRST(&trsrc->inot);
|
|
}
|
|
|
|
if (!inot) {
|
|
device_printf(
|
|
ocs->dev, "%s: no INOT for LUN %llx (en=%s) OX_ID %#x\n",
|
|
__func__, (unsigned long long)lun, trsrc ? (trsrc->enabled ? "T" : "F") : "X",
|
|
be16toh(tmfio->init_task_tag));
|
|
|
|
if (abortio) {
|
|
ocs_scsi_io_complete(abortio);
|
|
}
|
|
ocs_scsi_io_complete(tmfio);
|
|
goto ocs_scsi_recv_tmf_out;
|
|
}
|
|
|
|
tmfio->tgt_io.app = abortio;
|
|
|
|
STAILQ_REMOVE_HEAD(&trsrc->inot, sim_links.stqe);
|
|
|
|
inot->tag_id = tmfio->tag;
|
|
inot->seq_id = tmfio->tag;
|
|
|
|
if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) {
|
|
inot->initiator_id = node->instance_index;
|
|
} else {
|
|
inot->initiator_id = CAM_TARGET_WILDCARD;
|
|
}
|
|
|
|
inot->ccb_h.status = CAM_MESSAGE_RECV;
|
|
inot->ccb_h.target_lun = lun;
|
|
|
|
switch (cmd) {
|
|
case OCS_SCSI_TMF_ABORT_TASK:
|
|
inot->arg = MSG_ABORT_TASK;
|
|
inot->seq_id = abortio->tag;
|
|
device_printf(ocs->dev, "%s: ABTS IO.%#x st=%#x\n",
|
|
__func__, abortio->tag, abortio->tgt_io.state);
|
|
abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_RECV;
|
|
abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_NOTIFY;
|
|
break;
|
|
case OCS_SCSI_TMF_QUERY_TASK_SET:
|
|
device_printf(ocs->dev,
|
|
"%s: OCS_SCSI_TMF_QUERY_TASK_SET not supported\n",
|
|
__func__);
|
|
STAILQ_INSERT_TAIL(&trsrc->inot, &inot->ccb_h, sim_links.stqe);
|
|
ocs_scsi_io_complete(tmfio);
|
|
goto ocs_scsi_recv_tmf_out;
|
|
break;
|
|
case OCS_SCSI_TMF_ABORT_TASK_SET:
|
|
inot->arg = MSG_ABORT_TASK_SET;
|
|
break;
|
|
case OCS_SCSI_TMF_CLEAR_TASK_SET:
|
|
inot->arg = MSG_CLEAR_TASK_SET;
|
|
break;
|
|
case OCS_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT:
|
|
inot->arg = MSG_QUERY_ASYNC_EVENT;
|
|
break;
|
|
case OCS_SCSI_TMF_LOGICAL_UNIT_RESET:
|
|
inot->arg = MSG_LOGICAL_UNIT_RESET;
|
|
break;
|
|
case OCS_SCSI_TMF_CLEAR_ACA:
|
|
inot->arg = MSG_CLEAR_ACA;
|
|
break;
|
|
case OCS_SCSI_TMF_TARGET_RESET:
|
|
inot->arg = MSG_TARGET_RESET;
|
|
break;
|
|
default:
|
|
device_printf(ocs->dev, "%s: unsupported TMF %#x\n",
|
|
__func__, cmd);
|
|
STAILQ_INSERT_TAIL(&trsrc->inot, &inot->ccb_h, sim_links.stqe);
|
|
goto ocs_scsi_recv_tmf_out;
|
|
}
|
|
|
|
rc = 0;
|
|
|
|
xpt_print(inot->ccb_h.path, "%s: func=%#x stat=%#x id=%#x lun=%#x"
|
|
" flags=%#x tag=%#x seq=%#x ini=%#x arg=%#x\n",
|
|
__func__, inot->ccb_h.func_code, inot->ccb_h.status,
|
|
inot->ccb_h.target_id,
|
|
(unsigned int)inot->ccb_h.target_lun, inot->ccb_h.flags,
|
|
inot->tag_id, inot->seq_id, inot->initiator_id,
|
|
inot->arg);
|
|
xpt_done((union ccb *)inot);
|
|
|
|
if (abortio) {
|
|
abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_DEV;
|
|
rc = ocs_scsi_tgt_abort_io(abortio, ocs_io_abort_cb, tmfio);
|
|
}
|
|
|
|
ocs_scsi_recv_tmf_out:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief Initializes any initiator fields on the ocs structure.
|
|
*
|
|
* Called by OS initialization code when a new device is discovered.
|
|
*
|
|
* @param ocs pointer to ocs
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_ini_new_device(ocs_t *ocs)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief Tears down initiator members of ocs structure.
|
|
*
|
|
* Called by OS code when device is removed.
|
|
*
|
|
* @param ocs pointer to ocs
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
|
|
int32_t
|
|
ocs_scsi_ini_del_device(ocs_t *ocs)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief accept new domain notification
|
|
*
|
|
* Called by base drive when new domain is discovered. An initiator-client
|
|
* will accept this call to prepare for new remote node notifications
|
|
* arising from ocs_scsi_new_target().
|
|
*
|
|
* The domain context has the element <b>ocs_scsi_ini_domain_t ini_domain</b>
|
|
* which is declared by the initiator-client code and is used for
|
|
* initiator-client private data.
|
|
*
|
|
* This function will only be called if the base-driver has been enabled for
|
|
* initiator capability.
|
|
*
|
|
* Note that this call is made to initiator-client backends,
|
|
* the ocs_scsi_tgt_new_domain() function is called to target-server backends.
|
|
*
|
|
* @param domain pointer to domain
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_ini_new_domain(ocs_domain_t *domain)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief accept domain lost notification
|
|
*
|
|
* Called by base-driver when a domain goes away. An initiator-client will
|
|
* use this call to clean up all domain scoped resources.
|
|
*
|
|
* This function will only be called if the base-driver has been enabled for
|
|
* initiator capability.
|
|
*
|
|
* Note that this call is made to initiator-client backends,
|
|
* the ocs_scsi_tgt_del_domain() function is called to target-server backends.
|
|
*
|
|
* @param domain pointer to domain
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
void
|
|
ocs_scsi_ini_del_domain(ocs_domain_t *domain)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief accept new sli port notification
|
|
*
|
|
* Called by base drive when new sli port (sport) is discovered.
|
|
* A target-server will use this call to prepare for new remote node
|
|
* notifications arising from ocs_scsi_new_initiator().
|
|
*
|
|
* This function will only be called if the base-driver has been enabled for
|
|
* target capability.
|
|
*
|
|
* Note that this call is made to target-server backends,
|
|
* the ocs_scsi_ini_new_sport() function is called to initiator-client backends.
|
|
*
|
|
* @param sport pointer to sport
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_ini_new_sport(ocs_sport_t *sport)
|
|
{
|
|
ocs_t *ocs = sport->ocs;
|
|
ocs_fcport *fcp = FCPORT(ocs, 0);
|
|
|
|
if (!sport->is_vport) {
|
|
sport->tgt_data = fcp;
|
|
fcp->fc_id = sport->fc_id;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief accept sli port gone notification
|
|
*
|
|
* Called by base-driver when a sport goes away. A target-server will
|
|
* use this call to clean up all sport scoped resources.
|
|
*
|
|
* Note that this call is made to target-server backends,
|
|
* the ocs_scsi_ini_del_sport() function is called to initiator-client backends.
|
|
*
|
|
* @param sport pointer to SLI port
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
void
|
|
ocs_scsi_ini_del_sport(ocs_sport_t *sport)
|
|
{
|
|
ocs_t *ocs = sport->ocs;
|
|
ocs_fcport *fcp = FCPORT(ocs, 0);
|
|
|
|
if (!sport->is_vport) {
|
|
fcp->fc_id = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
ocs_scsi_sport_deleted(ocs_sport_t *sport)
|
|
{
|
|
ocs_t *ocs = sport->ocs;
|
|
ocs_fcport *fcp = NULL;
|
|
|
|
ocs_xport_stats_t value;
|
|
|
|
if (!sport->is_vport) {
|
|
return;
|
|
}
|
|
|
|
fcp = sport->tgt_data;
|
|
|
|
ocs_xport_status(ocs->xport, OCS_XPORT_PORT_STATUS, &value);
|
|
|
|
if (value.value == 0) {
|
|
ocs_log_debug(ocs, "PORT offline,.. skipping\n");
|
|
return;
|
|
}
|
|
|
|
if ((fcp->role != KNOB_ROLE_NONE)) {
|
|
if(fcp->vport->sport != NULL) {
|
|
ocs_log_debug(ocs,"sport is not NULL, skipping\n");
|
|
return;
|
|
}
|
|
|
|
ocs_sport_vport_alloc(ocs->domain, fcp->vport);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
int32_t
|
|
ocs_tgt_find(ocs_fcport *fcp, ocs_node_t *node)
|
|
{
|
|
ocs_fc_target_t *tgt = NULL;
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < OCS_MAX_TARGETS; i++) {
|
|
tgt = &fcp->tgt[i];
|
|
|
|
if (tgt->state == OCS_TGT_STATE_NONE)
|
|
continue;
|
|
|
|
if (ocs_node_get_wwpn(node) == tgt->wwpn) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief receive notification of a new SCSI target node
|
|
*
|
|
* Sent by base driver to notify an initiator-client of the presense of a new
|
|
* remote target. The initiator-server may use this call to prepare for
|
|
* inbound IO from this node.
|
|
*
|
|
* This function is only called if the base driver is enabled for
|
|
* initiator capability.
|
|
*
|
|
* @param node pointer to new remote initiator node
|
|
*
|
|
* @return none
|
|
*
|
|
* @note
|
|
*/
|
|
|
|
uint32_t
|
|
ocs_update_tgt(ocs_node_t *node, ocs_fcport *fcp, uint32_t tgt_id)
|
|
{
|
|
ocs_fc_target_t *tgt = NULL;
|
|
|
|
tgt = &fcp->tgt[tgt_id];
|
|
|
|
tgt->node_id = node->instance_index;
|
|
tgt->state = OCS_TGT_STATE_VALID;
|
|
|
|
tgt->port_id = node->rnode.fc_id;
|
|
tgt->wwpn = ocs_node_get_wwpn(node);
|
|
tgt->wwnn = ocs_node_get_wwnn(node);
|
|
return 0;
|
|
}
|
|
|
|
uint32_t
|
|
ocs_add_new_tgt(ocs_node_t *node, ocs_fcport *fcp)
|
|
{
|
|
uint32_t i;
|
|
|
|
struct ocs_softc *ocs = node->ocs;
|
|
union ccb *ccb = NULL;
|
|
for (i = 0; i < OCS_MAX_TARGETS; i++) {
|
|
if (fcp->tgt[i].state == OCS_TGT_STATE_NONE)
|
|
break;
|
|
}
|
|
|
|
if (NULL == (ccb = xpt_alloc_ccb_nowait())) {
|
|
device_printf(ocs->dev, "%s: ccb allocation failed\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
if (CAM_REQ_CMP != xpt_create_path(&ccb->ccb_h.path, xpt_periph,
|
|
cam_sim_path(fcp->sim),
|
|
i, CAM_LUN_WILDCARD)) {
|
|
device_printf(
|
|
ocs->dev, "%s: target path creation failed\n", __func__);
|
|
xpt_free_ccb(ccb);
|
|
return -1;
|
|
}
|
|
|
|
ocs_update_tgt(node, fcp, i);
|
|
xpt_rescan(ccb);
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
ocs_scsi_new_target(ocs_node_t *node)
|
|
{
|
|
ocs_fcport *fcp = NULL;
|
|
int32_t i;
|
|
|
|
fcp = node->sport->tgt_data;
|
|
if (fcp == NULL) {
|
|
printf("%s:FCP is NULL \n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
i = ocs_tgt_find(fcp, node);
|
|
|
|
if (i < 0) {
|
|
ocs_add_new_tgt(node, fcp);
|
|
return 0;
|
|
}
|
|
|
|
ocs_update_tgt(node, fcp, i);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
ocs_delete_target(ocs_t *ocs, ocs_fcport *fcp, int tgt)
|
|
{
|
|
struct cam_path *cpath = NULL;
|
|
|
|
if (!fcp->sim) {
|
|
device_printf(ocs->dev, "%s: calling with NULL sim\n", __func__);
|
|
return;
|
|
}
|
|
|
|
if (CAM_REQ_CMP == xpt_create_path(&cpath, NULL, cam_sim_path(fcp->sim),
|
|
tgt, CAM_LUN_WILDCARD)) {
|
|
xpt_async(AC_LOST_DEVICE, cpath, NULL);
|
|
|
|
xpt_free_path(cpath);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Device Lost Timer Function- when we have decided that a device was lost,
|
|
* we wait a specific period of time prior to telling the OS about lost device.
|
|
*
|
|
* This timer function gets activated when the device was lost.
|
|
* This function fires once a second and then scans the port database
|
|
* for devices that are marked dead but still have a virtual target assigned.
|
|
* We decrement a counter for that port database entry, and when it hits zero,
|
|
* we tell the OS the device was lost. Timer will be stopped when the device
|
|
* comes back active or removed from the OS.
|
|
*/
|
|
static void
|
|
ocs_ldt(void *arg)
|
|
{
|
|
ocs_fcport *fcp = arg;
|
|
taskqueue_enqueue(taskqueue_thread, &fcp->ltask);
|
|
}
|
|
|
|
static void
|
|
ocs_ldt_task(void *arg, int pending)
|
|
{
|
|
ocs_fcport *fcp = arg;
|
|
ocs_t *ocs = fcp->ocs;
|
|
int i, more_to_do = 0;
|
|
ocs_fc_target_t *tgt = NULL;
|
|
|
|
for (i = 0; i < OCS_MAX_TARGETS; i++) {
|
|
tgt = &fcp->tgt[i];
|
|
|
|
if (tgt->state != OCS_TGT_STATE_LOST) {
|
|
continue;
|
|
}
|
|
|
|
if ((tgt->gone_timer != 0) && (ocs->attached)){
|
|
tgt->gone_timer -= 1;
|
|
more_to_do++;
|
|
continue;
|
|
}
|
|
|
|
ocs_delete_target(ocs, fcp, i);
|
|
|
|
tgt->state = OCS_TGT_STATE_NONE;
|
|
}
|
|
|
|
if (more_to_do) {
|
|
callout_reset(&fcp->ldt, hz, ocs_ldt, fcp);
|
|
} else {
|
|
callout_deactivate(&fcp->ldt);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @ingroup scsi_api_initiator
|
|
* @brief Delete a SCSI target node
|
|
*
|
|
* Sent by base driver to notify a initiator-client that a remote target
|
|
* is now gone. The base driver will have terminated all outstanding IOs
|
|
* and the initiator-client will receive appropriate completions.
|
|
*
|
|
* The ocs_node_t structure has and elment of type ocs_scsi_ini_node_t named
|
|
* ini_node that is declared and used by a target-server for private
|
|
* information.
|
|
*
|
|
* This function is only called if the base driver is enabled for
|
|
* initiator capability.
|
|
*
|
|
* @param node pointer node being deleted
|
|
* @param reason reason for deleting the target
|
|
*
|
|
* @return Returns OCS_SCSI_CALL_ASYNC if target delete is queued for async
|
|
* completion and OCS_SCSI_CALL_COMPLETE if call completed or error.
|
|
*
|
|
* @note
|
|
*/
|
|
int32_t
|
|
ocs_scsi_del_target(ocs_node_t *node, ocs_scsi_del_target_reason_e reason)
|
|
{
|
|
struct ocs_softc *ocs = node->ocs;
|
|
ocs_fcport *fcp = NULL;
|
|
ocs_fc_target_t *tgt = NULL;
|
|
int32_t tgt_id;
|
|
|
|
if (ocs == NULL) {
|
|
ocs_log_err(ocs,"OCS is NULL \n");
|
|
return -1;
|
|
}
|
|
|
|
fcp = node->sport->tgt_data;
|
|
if (fcp == NULL) {
|
|
ocs_log_err(ocs,"FCP is NULL \n");
|
|
return -1;
|
|
}
|
|
|
|
tgt_id = ocs_tgt_find(fcp, node);
|
|
if (tgt_id == -1) {
|
|
ocs_log_err(ocs,"target is invalid\n");
|
|
return -1;
|
|
}
|
|
|
|
tgt = &fcp->tgt[tgt_id];
|
|
|
|
// IF in shutdown delete target.
|
|
if(!ocs->attached) {
|
|
ocs_delete_target(ocs, fcp, tgt_id);
|
|
} else {
|
|
tgt->state = OCS_TGT_STATE_LOST;
|
|
tgt->gone_timer = 30;
|
|
if (!callout_active(&fcp->ldt)) {
|
|
callout_reset(&fcp->ldt, hz, ocs_ldt, fcp);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize SCSI IO
|
|
*
|
|
* Initialize SCSI IO, this function is called once per IO during IO pool
|
|
* allocation so that the target server may initialize any of its own private
|
|
* data.
|
|
*
|
|
* @param io pointer to SCSI IO object
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_tgt_io_init(ocs_io_t *io)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Uninitialize SCSI IO
|
|
*
|
|
* Uninitialize target server private data in a SCSI io object
|
|
*
|
|
* @param io pointer to SCSI IO object
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_tgt_io_exit(ocs_io_t *io)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize SCSI IO
|
|
*
|
|
* Initialize SCSI IO, this function is called once per IO during IO pool
|
|
* allocation so that the initiator client may initialize any of its own private
|
|
* data.
|
|
*
|
|
* @param io pointer to SCSI IO object
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_ini_io_init(ocs_io_t *io)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Uninitialize SCSI IO
|
|
*
|
|
* Uninitialize initiator client private data in a SCSI io object
|
|
*
|
|
* @param io pointer to SCSI IO object
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
int32_t
|
|
ocs_scsi_ini_io_exit(ocs_io_t *io)
|
|
{
|
|
return 0;
|
|
}
|
|
/*
|
|
* End of functions required by SCSI base driver API
|
|
***************************************************************************/
|
|
|
|
static __inline void
|
|
ocs_set_ccb_status(union ccb *ccb, cam_status status)
|
|
{
|
|
ccb->ccb_h.status &= ~CAM_STATUS_MASK;
|
|
ccb->ccb_h.status |= status;
|
|
}
|
|
|
|
static int32_t
|
|
ocs_task_set_full_or_busy_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status,
|
|
uint32_t flags, void *arg)
|
|
{
|
|
|
|
ocs_target_io_free(io);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief send SCSI task set full or busy status
|
|
*
|
|
* A SCSI task set full or busy response is sent depending on whether
|
|
* another IO is already active on the LUN.
|
|
*
|
|
* @param io pointer to IO context
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
|
|
static int32_t
|
|
ocs_task_set_full_or_busy(ocs_io_t *io)
|
|
{
|
|
ocs_scsi_cmd_resp_t rsp = { 0 };
|
|
ocs_t *ocs = io->ocs;
|
|
|
|
/*
|
|
* If there is another command for the LUN, then send task set full,
|
|
* if this is the first one, then send the busy status.
|
|
*
|
|
* if 'busy sent' is FALSE, set it to TRUE and send BUSY
|
|
* otherwise send FULL
|
|
*/
|
|
if (atomic_cmpset_acq_32(&io->node->tgt_node.busy_sent, FALSE, TRUE)) {
|
|
rsp.scsi_status = SCSI_STATUS_BUSY; /* Busy */
|
|
printf("%s: busy [%s] tag=%x iiu=%d ihw=%d\n", __func__,
|
|
io->node->display_name, io->tag,
|
|
io->ocs->io_in_use, io->ocs->io_high_watermark);
|
|
} else {
|
|
rsp.scsi_status = SCSI_STATUS_TASK_SET_FULL; /* Task set full */
|
|
printf("%s: full tag=%x iiu=%d\n", __func__, io->tag,
|
|
io->ocs->io_in_use);
|
|
}
|
|
|
|
/* Log a message here indicating a busy or task set full state */
|
|
if (OCS_LOG_ENABLE_Q_FULL_BUSY_MSG(ocs)) {
|
|
/* Log Task Set Full */
|
|
if (rsp.scsi_status == SCSI_STATUS_TASK_SET_FULL) {
|
|
/* Task Set Full Message */
|
|
ocs_log_info(ocs, "OCS CAM TASK SET FULL. Tasks >= %d\n",
|
|
ocs->io_high_watermark);
|
|
}
|
|
else if (rsp.scsi_status == SCSI_STATUS_BUSY) {
|
|
/* Log Busy Message */
|
|
ocs_log_info(ocs, "OCS CAM SCSI BUSY\n");
|
|
}
|
|
}
|
|
|
|
/* Send the response */
|
|
return
|
|
ocs_scsi_send_resp(io, 0, &rsp, ocs_task_set_full_or_busy_cb, NULL);
|
|
}
|
|
|
|
/**
|
|
* @ingroup cam_io
|
|
* @brief Process target IO completions
|
|
*
|
|
* @param io
|
|
* @param scsi_status did the IO complete successfully
|
|
* @param flags
|
|
* @param arg application specific pointer provided in the call to ocs_target_io()
|
|
*
|
|
* @todo
|
|
*/
|
|
static int32_t ocs_scsi_target_io_cb(ocs_io_t *io,
|
|
ocs_scsi_io_status_e scsi_status,
|
|
uint32_t flags, void *arg)
|
|
{
|
|
union ccb *ccb = arg;
|
|
struct ccb_scsiio *csio = &ccb->csio;
|
|
struct ocs_softc *ocs = csio->ccb_h.ccb_ocs_ptr;
|
|
uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK;
|
|
uint32_t io_is_done =
|
|
(ccb->ccb_h.flags & CAM_SEND_STATUS) == CAM_SEND_STATUS;
|
|
|
|
ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
|
|
|
|
if (CAM_DIR_NONE != cam_dir) {
|
|
bus_dmasync_op_t op;
|
|
|
|
if (CAM_DIR_IN == cam_dir) {
|
|
op = BUS_DMASYNC_POSTREAD;
|
|
} else {
|
|
op = BUS_DMASYNC_POSTWRITE;
|
|
}
|
|
/* Synchronize the DMA memory with the CPU and free the mapping */
|
|
bus_dmamap_sync(ocs->buf_dmat, io->tgt_io.dmap, op);
|
|
if (io->tgt_io.flags & OCS_CAM_IO_F_DMAPPED) {
|
|
bus_dmamap_unload(ocs->buf_dmat, io->tgt_io.dmap);
|
|
}
|
|
}
|
|
|
|
if (io->tgt_io.sendresp) {
|
|
io->tgt_io.sendresp = 0;
|
|
ocs_scsi_cmd_resp_t resp = { 0 };
|
|
io->tgt_io.state = OCS_CAM_IO_RESP;
|
|
resp.scsi_status = scsi_status;
|
|
if (ccb->ccb_h.flags & CAM_SEND_SENSE) {
|
|
resp.sense_data = (uint8_t *)&csio->sense_data;
|
|
resp.sense_data_length = csio->sense_len;
|
|
}
|
|
resp.residual = io->exp_xfer_len - io->transferred;
|
|
|
|
return ocs_scsi_send_resp(io, 0, &resp, ocs_scsi_target_io_cb, ccb);
|
|
}
|
|
|
|
switch (scsi_status) {
|
|
case OCS_SCSI_STATUS_GOOD:
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
break;
|
|
case OCS_SCSI_STATUS_ABORTED:
|
|
ocs_set_ccb_status(ccb, CAM_REQ_ABORTED);
|
|
break;
|
|
default:
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
}
|
|
|
|
if (io_is_done) {
|
|
if ((io->tgt_io.flags & OCS_CAM_IO_F_ABORT_NOTIFY) == 0) {
|
|
ocs_target_io_free(io);
|
|
}
|
|
} else {
|
|
io->tgt_io.state = OCS_CAM_IO_DATA_DONE;
|
|
/*device_printf(ocs->dev, "%s: CTIO state=%d tag=%#x\n",
|
|
__func__, io->tgt_io.state, io->tag);*/
|
|
}
|
|
|
|
xpt_done(ccb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @note 1. Since the CCB is assigned to the ocs_io_t on an XPT_CONT_TARGET_IO
|
|
* action, if an initiator aborts a command prior to the SIM receiving
|
|
* a CTIO, the IO's CCB will be NULL.
|
|
*/
|
|
static int32_t
|
|
ocs_io_abort_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
|
|
{
|
|
struct ocs_softc *ocs = NULL;
|
|
ocs_io_t *tmfio = arg;
|
|
ocs_scsi_tmf_resp_e tmf_resp = OCS_SCSI_TMF_FUNCTION_COMPLETE;
|
|
int32_t rc = 0;
|
|
|
|
ocs = io->ocs;
|
|
|
|
io->tgt_io.flags &= ~OCS_CAM_IO_F_ABORT_DEV;
|
|
|
|
/* A good status indicates the IO was aborted and will be completed in
|
|
* the IO's completion handler. Handle the other cases here. */
|
|
switch (scsi_status) {
|
|
case OCS_SCSI_STATUS_GOOD:
|
|
break;
|
|
case OCS_SCSI_STATUS_NO_IO:
|
|
break;
|
|
default:
|
|
device_printf(ocs->dev, "%s: unhandled status %d\n",
|
|
__func__, scsi_status);
|
|
tmf_resp = OCS_SCSI_TMF_FUNCTION_REJECTED;
|
|
rc = -1;
|
|
}
|
|
|
|
ocs_scsi_send_tmf_resp(tmfio, tmf_resp, NULL, ocs_target_tmf_cb, NULL);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* @ingroup cam_io
|
|
* @brief Process initiator IO completions
|
|
*
|
|
* @param io
|
|
* @param scsi_status did the IO complete successfully
|
|
* @param rsp pointer to response buffer
|
|
* @param flags
|
|
* @param arg application specific pointer provided in the call to ocs_target_io()
|
|
*
|
|
* @todo
|
|
*/
|
|
static int32_t ocs_scsi_initiator_io_cb(ocs_io_t *io,
|
|
ocs_scsi_io_status_e scsi_status,
|
|
ocs_scsi_cmd_resp_t *rsp,
|
|
uint32_t flags, void *arg)
|
|
{
|
|
union ccb *ccb = arg;
|
|
struct ccb_scsiio *csio = &ccb->csio;
|
|
struct ocs_softc *ocs = csio->ccb_h.ccb_ocs_ptr;
|
|
uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK;
|
|
cam_status ccb_status= CAM_REQ_CMP_ERR;
|
|
|
|
if (CAM_DIR_NONE != cam_dir) {
|
|
bus_dmasync_op_t op;
|
|
|
|
if (CAM_DIR_IN == cam_dir) {
|
|
op = BUS_DMASYNC_POSTREAD;
|
|
} else {
|
|
op = BUS_DMASYNC_POSTWRITE;
|
|
}
|
|
/* Synchronize the DMA memory with the CPU and free the mapping */
|
|
bus_dmamap_sync(ocs->buf_dmat, io->tgt_io.dmap, op);
|
|
if (io->tgt_io.flags & OCS_CAM_IO_F_DMAPPED) {
|
|
bus_dmamap_unload(ocs->buf_dmat, io->tgt_io.dmap);
|
|
}
|
|
}
|
|
|
|
if (scsi_status == OCS_SCSI_STATUS_CHECK_RESPONSE) {
|
|
csio->scsi_status = rsp->scsi_status;
|
|
if (SCSI_STATUS_OK != rsp->scsi_status)
|
|
ccb_status = CAM_SCSI_STATUS_ERROR;
|
|
else
|
|
ccb_status = CAM_REQ_CMP;
|
|
|
|
csio->resid = rsp->residual;
|
|
|
|
/*
|
|
* If we've already got a SCSI error, prefer that because it
|
|
* will have more detail.
|
|
*/
|
|
if ((rsp->residual < 0) && (ccb_status == CAM_REQ_CMP)) {
|
|
ccb_status = CAM_DATA_RUN_ERR;
|
|
}
|
|
|
|
if ((rsp->sense_data_length) &&
|
|
!(ccb->ccb_h.flags & (CAM_SENSE_PHYS | CAM_SENSE_PTR))) {
|
|
uint32_t sense_len = 0;
|
|
|
|
ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
|
|
if (rsp->sense_data_length < csio->sense_len) {
|
|
csio->sense_resid =
|
|
csio->sense_len - rsp->sense_data_length;
|
|
sense_len = rsp->sense_data_length;
|
|
} else {
|
|
csio->sense_resid = 0;
|
|
sense_len = csio->sense_len;
|
|
}
|
|
ocs_memcpy(&csio->sense_data, rsp->sense_data, sense_len);
|
|
}
|
|
} else if (scsi_status != OCS_SCSI_STATUS_GOOD) {
|
|
ccb_status = CAM_REQ_CMP_ERR;
|
|
} else {
|
|
ccb_status = CAM_REQ_CMP;
|
|
}
|
|
|
|
ocs_set_ccb_status(ccb, ccb_status);
|
|
|
|
ocs_scsi_io_free(io);
|
|
|
|
csio->ccb_h.ccb_io_ptr = NULL;
|
|
csio->ccb_h.ccb_ocs_ptr = NULL;
|
|
|
|
ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
|
|
|
|
if ((ccb_status != CAM_REQ_CMP) &&
|
|
((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0)) {
|
|
ccb->ccb_h.status |= CAM_DEV_QFRZN;
|
|
xpt_freeze_devq(ccb->ccb_h.path, 1);
|
|
}
|
|
|
|
xpt_done(ccb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Load scatter-gather list entries into an IO
|
|
*
|
|
* This routine relies on the driver instance's software context pointer and
|
|
* the IO object pointer having been already assigned to hooks in the CCB.
|
|
* Although the routine does not return success/fail, callers can look at the
|
|
* n_sge member to determine if the mapping failed (0 on failure).
|
|
*
|
|
* @param arg pointer to the CAM ccb for this IO
|
|
* @param seg DMA address/length pairs
|
|
* @param nseg number of DMA address/length pairs
|
|
* @param error any errors while mapping the IO
|
|
*/
|
|
static void
|
|
ocs_scsi_dmamap_load(void *arg, bus_dma_segment_t *seg, int nseg, int error)
|
|
{
|
|
ocs_dmamap_load_arg_t *sglarg = (ocs_dmamap_load_arg_t*) arg;
|
|
|
|
if (error) {
|
|
printf("%s: seg=%p nseg=%d error=%d\n",
|
|
__func__, seg, nseg, error);
|
|
sglarg->rc = -1;
|
|
} else {
|
|
uint32_t i = 0;
|
|
uint32_t c = 0;
|
|
|
|
if ((sglarg->sgl_count + nseg) > sglarg->sgl_max) {
|
|
printf("%s: sgl_count=%d nseg=%d max=%d\n", __func__,
|
|
sglarg->sgl_count, nseg, sglarg->sgl_max);
|
|
sglarg->rc = -2;
|
|
return;
|
|
}
|
|
|
|
for (i = 0, c = sglarg->sgl_count; i < nseg; i++, c++) {
|
|
sglarg->sgl[c].addr = seg[i].ds_addr;
|
|
sglarg->sgl[c].len = seg[i].ds_len;
|
|
}
|
|
|
|
sglarg->sgl_count = c;
|
|
|
|
sglarg->rc = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Build a scatter-gather list from a CAM CCB
|
|
*
|
|
* @param ocs the driver instance's software context
|
|
* @param ccb pointer to the CCB
|
|
* @param io pointer to the previously allocated IO object
|
|
* @param sgl pointer to SGL
|
|
* @param sgl_max number of entries in sgl
|
|
*
|
|
* @return 0 on success, non-zero otherwise
|
|
*/
|
|
static int32_t
|
|
ocs_build_scsi_sgl(struct ocs_softc *ocs, union ccb *ccb, ocs_io_t *io,
|
|
ocs_scsi_sgl_t *sgl, uint32_t sgl_max)
|
|
{
|
|
ocs_dmamap_load_arg_t dmaarg;
|
|
int32_t err = 0;
|
|
|
|
if (!ocs || !ccb || !io || !sgl) {
|
|
printf("%s: bad param o=%p c=%p i=%p s=%p\n", __func__,
|
|
ocs, ccb, io, sgl);
|
|
return -1;
|
|
}
|
|
|
|
io->tgt_io.flags &= ~OCS_CAM_IO_F_DMAPPED;
|
|
|
|
dmaarg.sgl = sgl;
|
|
dmaarg.sgl_count = 0;
|
|
dmaarg.sgl_max = sgl_max;
|
|
dmaarg.rc = 0;
|
|
|
|
err = bus_dmamap_load_ccb(ocs->buf_dmat, io->tgt_io.dmap, ccb,
|
|
ocs_scsi_dmamap_load, &dmaarg, 0);
|
|
|
|
if (err || dmaarg.rc) {
|
|
device_printf(
|
|
ocs->dev, "%s: bus_dmamap_load_ccb error (%d %d)\n",
|
|
__func__, err, dmaarg.rc);
|
|
return -1;
|
|
}
|
|
|
|
io->tgt_io.flags |= OCS_CAM_IO_F_DMAPPED;
|
|
return dmaarg.sgl_count;
|
|
}
|
|
|
|
/**
|
|
* @ingroup cam_io
|
|
* @brief Send a target IO
|
|
*
|
|
* @param ocs the driver instance's software context
|
|
* @param ccb pointer to the CCB
|
|
*
|
|
* @return 0 on success, non-zero otherwise
|
|
*/
|
|
static int32_t
|
|
ocs_target_io(struct ocs_softc *ocs, union ccb *ccb)
|
|
{
|
|
struct ccb_scsiio *csio = &ccb->csio;
|
|
ocs_io_t *io = NULL;
|
|
uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK;
|
|
bool sendstatus = ccb->ccb_h.flags & CAM_SEND_STATUS;
|
|
uint32_t xferlen = csio->dxfer_len;
|
|
int32_t rc = 0;
|
|
|
|
io = ocs_scsi_find_io(ocs, csio->tag_id);
|
|
if (io == NULL) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
panic("bad tag value");
|
|
return 1;
|
|
}
|
|
|
|
/* Received an ABORT TASK for this IO */
|
|
if (io->tgt_io.flags & OCS_CAM_IO_F_ABORT_RECV) {
|
|
/*device_printf(ocs->dev,
|
|
"%s: XPT_CONT_TARGET_IO state=%d tag=%#x xid=%#x flags=%#x\n",
|
|
__func__, io->tgt_io.state, io->tag, io->init_task_tag,
|
|
io->tgt_io.flags);*/
|
|
io->tgt_io.flags |= OCS_CAM_IO_F_ABORT_CAM;
|
|
|
|
if (ccb->ccb_h.flags & CAM_SEND_STATUS) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
ocs_target_io_free(io);
|
|
return 1;
|
|
}
|
|
|
|
ocs_set_ccb_status(ccb, CAM_REQ_ABORTED);
|
|
|
|
return 1;
|
|
}
|
|
|
|
io->tgt_io.app = ccb;
|
|
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INPROG);
|
|
ccb->ccb_h.status |= CAM_SIM_QUEUED;
|
|
|
|
csio->ccb_h.ccb_ocs_ptr = ocs;
|
|
csio->ccb_h.ccb_io_ptr = io;
|
|
|
|
if ((sendstatus && (xferlen == 0))) {
|
|
ocs_scsi_cmd_resp_t resp = { 0 };
|
|
|
|
ocs_assert(ccb->ccb_h.flags & CAM_SEND_STATUS, -1);
|
|
|
|
io->tgt_io.state = OCS_CAM_IO_RESP;
|
|
|
|
resp.scsi_status = csio->scsi_status;
|
|
|
|
if (ccb->ccb_h.flags & CAM_SEND_SENSE) {
|
|
resp.sense_data = (uint8_t *)&csio->sense_data;
|
|
resp.sense_data_length = csio->sense_len;
|
|
}
|
|
|
|
resp.residual = io->exp_xfer_len - io->transferred;
|
|
rc = ocs_scsi_send_resp(io, 0, &resp, ocs_scsi_target_io_cb, ccb);
|
|
|
|
} else if (xferlen != 0) {
|
|
ocs_scsi_sgl_t *sgl;
|
|
int32_t sgl_count = 0;
|
|
|
|
io->tgt_io.state = OCS_CAM_IO_DATA;
|
|
|
|
if (sendstatus)
|
|
io->tgt_io.sendresp = 1;
|
|
|
|
sgl = io->sgl;
|
|
|
|
sgl_count = ocs_build_scsi_sgl(ocs, ccb, io, sgl, io->sgl_allocated);
|
|
if (sgl_count > 0) {
|
|
if (cam_dir == CAM_DIR_IN) {
|
|
rc = ocs_scsi_send_rd_data(io, 0, NULL, sgl,
|
|
sgl_count, csio->dxfer_len,
|
|
ocs_scsi_target_io_cb, ccb);
|
|
} else if (cam_dir == CAM_DIR_OUT) {
|
|
rc = ocs_scsi_recv_wr_data(io, 0, NULL, sgl,
|
|
sgl_count, csio->dxfer_len,
|
|
ocs_scsi_target_io_cb, ccb);
|
|
} else {
|
|
device_printf(ocs->dev, "%s:"
|
|
" unknown CAM direction %#x\n",
|
|
__func__, cam_dir);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
|
|
rc = 1;
|
|
}
|
|
} else {
|
|
device_printf(ocs->dev, "%s: building SGL failed\n",
|
|
__func__);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
rc = 1;
|
|
}
|
|
} else {
|
|
device_printf(ocs->dev, "%s: Wrong value xfer and sendstatus"
|
|
" are 0 \n", __func__);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
|
|
rc = 1;
|
|
}
|
|
|
|
if (rc) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
|
|
io->tgt_io.state = OCS_CAM_IO_DATA_DONE;
|
|
device_printf(ocs->dev, "%s: CTIO state=%d tag=%#x\n",
|
|
__func__, io->tgt_io.state, io->tag);
|
|
if ((sendstatus && (xferlen == 0))) {
|
|
ocs_target_io_free(io);
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int32_t
|
|
ocs_target_tmf_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags,
|
|
void *arg)
|
|
{
|
|
|
|
/*device_printf(io->ocs->dev, "%s: tag=%x io=%p s=%#x\n",
|
|
__func__, io->tag, io, scsi_status);*/
|
|
ocs_scsi_io_complete(io);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup cam_io
|
|
* @brief Send an initiator IO
|
|
*
|
|
* @param ocs the driver instance's software context
|
|
* @param ccb pointer to the CCB
|
|
*
|
|
* @return 0 on success, non-zero otherwise
|
|
*/
|
|
static int32_t
|
|
ocs_initiator_io(struct ocs_softc *ocs, union ccb *ccb)
|
|
{
|
|
int32_t rc;
|
|
struct ccb_scsiio *csio = &ccb->csio;
|
|
struct ccb_hdr *ccb_h = &csio->ccb_h;
|
|
ocs_node_t *node = NULL;
|
|
ocs_io_t *io = NULL;
|
|
ocs_scsi_sgl_t *sgl;
|
|
int32_t flags, sgl_count;
|
|
ocs_fcport *fcp;
|
|
|
|
fcp = FCPORT(ocs, cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path)));
|
|
|
|
if (fcp->tgt[ccb_h->target_id].state == OCS_TGT_STATE_LOST) {
|
|
device_printf(ocs->dev, "%s: device LOST %d\n", __func__,
|
|
ccb_h->target_id);
|
|
return CAM_REQUEUE_REQ;
|
|
}
|
|
|
|
if (fcp->tgt[ccb_h->target_id].state == OCS_TGT_STATE_NONE) {
|
|
device_printf(ocs->dev, "%s: device not ready %d\n", __func__,
|
|
ccb_h->target_id);
|
|
return CAM_SEL_TIMEOUT;
|
|
}
|
|
|
|
node = ocs_node_get_instance(ocs, fcp->tgt[ccb_h->target_id].node_id);
|
|
if (node == NULL) {
|
|
device_printf(ocs->dev, "%s: no device %d\n", __func__,
|
|
ccb_h->target_id);
|
|
return CAM_SEL_TIMEOUT;
|
|
}
|
|
|
|
if (!node->targ) {
|
|
device_printf(ocs->dev, "%s: not target device %d\n", __func__,
|
|
ccb_h->target_id);
|
|
return CAM_SEL_TIMEOUT;
|
|
}
|
|
|
|
io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR);
|
|
if (io == NULL) {
|
|
device_printf(ocs->dev, "%s: unable to alloc IO\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
/* eventhough this is INI, use target structure as ocs_build_scsi_sgl
|
|
* only references the tgt_io part of an ocs_io_t */
|
|
io->tgt_io.app = ccb;
|
|
|
|
csio->ccb_h.ccb_ocs_ptr = ocs;
|
|
csio->ccb_h.ccb_io_ptr = io;
|
|
sgl = io->sgl;
|
|
|
|
sgl_count = ocs_build_scsi_sgl(ocs, ccb, io, sgl, io->sgl_allocated);
|
|
if (sgl_count < 0) {
|
|
ocs_scsi_io_free(io);
|
|
device_printf(ocs->dev, "%s: building SGL failed\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
if (ccb->ccb_h.timeout == CAM_TIME_INFINITY) {
|
|
io->timeout = 0;
|
|
} else if (ccb->ccb_h.timeout == CAM_TIME_DEFAULT) {
|
|
io->timeout = OCS_CAM_IO_TIMEOUT;
|
|
} else {
|
|
io->timeout = ccb->ccb_h.timeout;
|
|
}
|
|
|
|
switch (csio->tag_action) {
|
|
case MSG_HEAD_OF_Q_TAG:
|
|
flags = OCS_SCSI_CMD_HEAD_OF_QUEUE;
|
|
break;
|
|
case MSG_ORDERED_Q_TAG:
|
|
flags = OCS_SCSI_CMD_ORDERED;
|
|
break;
|
|
case MSG_ACA_TASK:
|
|
flags = OCS_SCSI_CMD_ACA;
|
|
break;
|
|
case CAM_TAG_ACTION_NONE:
|
|
case MSG_SIMPLE_Q_TAG:
|
|
default:
|
|
flags = OCS_SCSI_CMD_SIMPLE;
|
|
break;
|
|
}
|
|
flags |= (csio->priority << OCS_SCSI_PRIORITY_SHIFT) &
|
|
OCS_SCSI_PRIORITY_MASK;
|
|
|
|
switch (ccb->ccb_h.flags & CAM_DIR_MASK) {
|
|
case CAM_DIR_NONE:
|
|
rc = ocs_scsi_send_nodata_io(node, io, ccb_h->target_lun,
|
|
ccb->ccb_h.flags & CAM_CDB_POINTER ?
|
|
csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes,
|
|
csio->cdb_len,
|
|
ocs_scsi_initiator_io_cb, ccb, flags);
|
|
break;
|
|
case CAM_DIR_IN:
|
|
rc = ocs_scsi_send_rd_io(node, io, ccb_h->target_lun,
|
|
ccb->ccb_h.flags & CAM_CDB_POINTER ?
|
|
csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes,
|
|
csio->cdb_len,
|
|
NULL,
|
|
sgl, sgl_count, csio->dxfer_len,
|
|
ocs_scsi_initiator_io_cb, ccb, flags);
|
|
break;
|
|
case CAM_DIR_OUT:
|
|
rc = ocs_scsi_send_wr_io(node, io, ccb_h->target_lun,
|
|
ccb->ccb_h.flags & CAM_CDB_POINTER ?
|
|
csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes,
|
|
csio->cdb_len,
|
|
NULL,
|
|
sgl, sgl_count, csio->dxfer_len,
|
|
ocs_scsi_initiator_io_cb, ccb, flags);
|
|
break;
|
|
default:
|
|
panic("%s invalid data direction %08x\n", __func__,
|
|
ccb->ccb_h.flags);
|
|
break;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static uint32_t
|
|
ocs_fcp_change_role(struct ocs_softc *ocs, ocs_fcport *fcp, uint32_t new_role)
|
|
{
|
|
|
|
uint32_t rc = 0, was = 0, i = 0;
|
|
ocs_vport_spec_t *vport = fcp->vport;
|
|
|
|
for (was = 0, i = 0; i < (ocs->num_vports + 1); i++) {
|
|
if (FCPORT(ocs, i)->role != KNOB_ROLE_NONE)
|
|
was++;
|
|
}
|
|
|
|
// Physical port
|
|
if ((was == 0) || (vport == NULL)) {
|
|
fcp->role = new_role;
|
|
if (vport == NULL) {
|
|
ocs->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
|
|
ocs->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
|
|
} else {
|
|
vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
|
|
vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
|
|
}
|
|
|
|
rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
|
|
if (rc) {
|
|
ocs_log_debug(ocs, "port offline failed : %d\n", rc);
|
|
}
|
|
|
|
rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
|
|
if (rc) {
|
|
ocs_log_debug(ocs, "port online failed : %d\n", rc);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
if ((fcp->role != KNOB_ROLE_NONE)){
|
|
fcp->role = new_role;
|
|
vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
|
|
vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
|
|
/* New Sport will be created in sport deleted cb */
|
|
return ocs_sport_vport_del(ocs, ocs->domain, vport->wwpn, vport->wwnn);
|
|
}
|
|
|
|
fcp->role = new_role;
|
|
|
|
vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
|
|
vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
|
|
|
|
if (fcp->role != KNOB_ROLE_NONE) {
|
|
return ocs_sport_vport_alloc(ocs->domain, vport);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* @ingroup cam_api
|
|
* @brief Process CAM actions
|
|
*
|
|
* The driver supplies this routine to the CAM during intialization and
|
|
* is the main entry point for processing CAM Control Blocks (CCB)
|
|
*
|
|
* @param sim pointer to the SCSI Interface Module
|
|
* @param ccb CAM control block
|
|
*
|
|
* @todo
|
|
* - populate path inquiry data via info retrieved from SLI port
|
|
*/
|
|
static void
|
|
ocs_action(struct cam_sim *sim, union ccb *ccb)
|
|
{
|
|
struct ocs_softc *ocs = (struct ocs_softc *)cam_sim_softc(sim);
|
|
struct ccb_hdr *ccb_h = &ccb->ccb_h;
|
|
|
|
int32_t rc, bus;
|
|
bus = cam_sim_bus(sim);
|
|
|
|
switch (ccb_h->func_code) {
|
|
case XPT_SCSI_IO:
|
|
|
|
if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0) {
|
|
if ((ccb->ccb_h.flags & CAM_CDB_PHYS) != 0) {
|
|
ccb->ccb_h.status = CAM_REQ_INVALID;
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
}
|
|
|
|
rc = ocs_initiator_io(ocs, ccb);
|
|
if (0 == rc) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INPROG | CAM_SIM_QUEUED);
|
|
break;
|
|
} else {
|
|
if (rc == CAM_REQUEUE_REQ) {
|
|
cam_freeze_devq(ccb->ccb_h.path);
|
|
cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 100, 0);
|
|
ccb->ccb_h.status = CAM_REQUEUE_REQ;
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
|
|
if (rc > 0) {
|
|
ocs_set_ccb_status(ccb, rc);
|
|
} else {
|
|
ocs_set_ccb_status(ccb, CAM_SEL_TIMEOUT);
|
|
}
|
|
}
|
|
xpt_done(ccb);
|
|
break;
|
|
case XPT_PATH_INQ:
|
|
{
|
|
struct ccb_pathinq *cpi = &ccb->cpi;
|
|
struct ccb_pathinq_settings_fc *fc = &cpi->xport_specific.fc;
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
uint64_t wwn = 0;
|
|
ocs_xport_stats_t value;
|
|
|
|
cpi->version_num = 1;
|
|
|
|
cpi->protocol = PROTO_SCSI;
|
|
cpi->protocol_version = SCSI_REV_SPC;
|
|
|
|
if (ocs->ocs_xport == OCS_XPORT_FC) {
|
|
cpi->transport = XPORT_FC;
|
|
} else {
|
|
cpi->transport = XPORT_UNKNOWN;
|
|
}
|
|
|
|
cpi->transport_version = 0;
|
|
|
|
/* Set the transport parameters of the SIM */
|
|
ocs_xport_status(ocs->xport, OCS_XPORT_LINK_SPEED, &value);
|
|
fc->bitrate = value.value * 1000; /* speed in Mbps */
|
|
|
|
wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWPN));
|
|
fc->wwpn = be64toh(wwn);
|
|
|
|
wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWNN));
|
|
fc->wwnn = be64toh(wwn);
|
|
|
|
fc->port = fcp->fc_id;
|
|
|
|
if (ocs->config_tgt) {
|
|
cpi->target_sprt =
|
|
PIT_PROCESSOR | PIT_DISCONNECT | PIT_TERM_IO;
|
|
}
|
|
|
|
cpi->hba_misc = PIM_NOBUSRESET | PIM_UNMAPPED;
|
|
cpi->hba_misc |= PIM_EXTLUNS | PIM_NOSCAN;
|
|
|
|
cpi->hba_inquiry = PI_TAG_ABLE;
|
|
cpi->max_target = OCS_MAX_TARGETS;
|
|
cpi->initiator_id = ocs->max_remote_nodes + 1;
|
|
|
|
if (!ocs->enable_ini) {
|
|
cpi->hba_misc |= PIM_NOINITIATOR;
|
|
}
|
|
|
|
cpi->max_lun = OCS_MAX_LUN;
|
|
cpi->bus_id = cam_sim_bus(sim);
|
|
|
|
/* Need to supply a base transfer speed prior to linking up
|
|
* Worst case, this would be FC 1Gbps */
|
|
cpi->base_transfer_speed = 1 * 1000 * 1000;
|
|
|
|
/* Calculate the max IO supported
|
|
* Worst case would be an OS page per SGL entry */
|
|
|
|
cpi->maxio = PAGE_SIZE *
|
|
(ocs_scsi_get_property(ocs, OCS_SCSI_MAX_SGL) - 1);
|
|
|
|
strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
|
|
strncpy(cpi->hba_vid, "Emulex", HBA_IDLEN);
|
|
strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
|
|
cpi->unit_number = cam_sim_unit(sim);
|
|
|
|
cpi->ccb_h.status = CAM_REQ_CMP;
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
case XPT_GET_TRAN_SETTINGS:
|
|
{
|
|
struct ccb_trans_settings *cts = &ccb->cts;
|
|
struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
|
|
struct ccb_trans_settings_fc *fc = &cts->xport_specific.fc;
|
|
ocs_xport_stats_t value;
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
ocs_fc_target_t *tgt = NULL;
|
|
|
|
if (ocs->ocs_xport != OCS_XPORT_FC) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
if (cts->ccb_h.target_id > OCS_MAX_TARGETS) {
|
|
ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
tgt = &fcp->tgt[cts->ccb_h.target_id];
|
|
if (tgt->state == OCS_TGT_STATE_NONE) {
|
|
ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
cts->protocol = PROTO_SCSI;
|
|
cts->protocol_version = SCSI_REV_SPC2;
|
|
cts->transport = XPORT_FC;
|
|
cts->transport_version = 2;
|
|
|
|
scsi->valid = CTS_SCSI_VALID_TQ;
|
|
scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
|
|
|
|
/* speed in Mbps */
|
|
ocs_xport_status(ocs->xport, OCS_XPORT_LINK_SPEED, &value);
|
|
fc->bitrate = value.value * 100;
|
|
|
|
fc->wwpn = tgt->wwpn;
|
|
|
|
fc->wwnn = tgt->wwnn;
|
|
|
|
fc->port = tgt->port_id;
|
|
|
|
fc->valid = CTS_FC_VALID_SPEED |
|
|
CTS_FC_VALID_WWPN |
|
|
CTS_FC_VALID_WWNN |
|
|
CTS_FC_VALID_PORT;
|
|
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
case XPT_SET_TRAN_SETTINGS:
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
xpt_done(ccb);
|
|
break;
|
|
|
|
case XPT_CALC_GEOMETRY:
|
|
cam_calc_geometry(&ccb->ccg, TRUE);
|
|
xpt_done(ccb);
|
|
break;
|
|
|
|
case XPT_GET_SIM_KNOB:
|
|
{
|
|
struct ccb_sim_knob *knob = &ccb->knob;
|
|
uint64_t wwn = 0;
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
if (ocs->ocs_xport != OCS_XPORT_FC) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
if (bus == 0) {
|
|
wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs,
|
|
OCS_SCSI_WWNN));
|
|
knob->xport_specific.fc.wwnn = be64toh(wwn);
|
|
|
|
wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs,
|
|
OCS_SCSI_WWPN));
|
|
knob->xport_specific.fc.wwpn = be64toh(wwn);
|
|
} else {
|
|
knob->xport_specific.fc.wwnn = fcp->vport->wwnn;
|
|
knob->xport_specific.fc.wwpn = fcp->vport->wwpn;
|
|
}
|
|
|
|
knob->xport_specific.fc.role = fcp->role;
|
|
knob->xport_specific.fc.valid = KNOB_VALID_ADDRESS |
|
|
KNOB_VALID_ROLE;
|
|
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
case XPT_SET_SIM_KNOB:
|
|
{
|
|
struct ccb_sim_knob *knob = &ccb->knob;
|
|
bool role_changed = FALSE;
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
if (ocs->ocs_xport != OCS_XPORT_FC) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
if (knob->xport_specific.fc.valid & KNOB_VALID_ADDRESS) {
|
|
device_printf(ocs->dev,
|
|
"%s: XPT_SET_SIM_KNOB wwnn=%llx wwpn=%llx\n",
|
|
__func__,
|
|
(unsigned long long)knob->xport_specific.fc.wwnn,
|
|
(unsigned long long)knob->xport_specific.fc.wwpn);
|
|
}
|
|
|
|
if (knob->xport_specific.fc.valid & KNOB_VALID_ROLE) {
|
|
switch (knob->xport_specific.fc.role) {
|
|
case KNOB_ROLE_NONE:
|
|
if (fcp->role != KNOB_ROLE_NONE) {
|
|
role_changed = TRUE;
|
|
}
|
|
break;
|
|
case KNOB_ROLE_TARGET:
|
|
if (fcp->role != KNOB_ROLE_TARGET) {
|
|
role_changed = TRUE;
|
|
}
|
|
break;
|
|
case KNOB_ROLE_INITIATOR:
|
|
if (fcp->role != KNOB_ROLE_INITIATOR) {
|
|
role_changed = TRUE;
|
|
}
|
|
break;
|
|
case KNOB_ROLE_BOTH:
|
|
if (fcp->role != KNOB_ROLE_BOTH) {
|
|
role_changed = TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
device_printf(ocs->dev,
|
|
"%s: XPT_SET_SIM_KNOB unsupported role: %d\n",
|
|
__func__, knob->xport_specific.fc.role);
|
|
}
|
|
|
|
if (role_changed) {
|
|
device_printf(ocs->dev,
|
|
"BUS:%d XPT_SET_SIM_KNOB old_role: %d new_role: %d\n",
|
|
bus, fcp->role, knob->xport_specific.fc.role);
|
|
|
|
ocs_fcp_change_role(ocs, fcp, knob->xport_specific.fc.role);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
case XPT_ABORT:
|
|
{
|
|
union ccb *accb = ccb->cab.abort_ccb;
|
|
|
|
switch (accb->ccb_h.func_code) {
|
|
case XPT_ACCEPT_TARGET_IO:
|
|
ocs_abort_atio(ocs, ccb);
|
|
break;
|
|
case XPT_IMMEDIATE_NOTIFY:
|
|
ocs_abort_inot(ocs, ccb);
|
|
break;
|
|
case XPT_SCSI_IO:
|
|
rc = ocs_abort_initiator_io(ocs, accb);
|
|
if (rc) {
|
|
ccb->ccb_h.status = CAM_UA_ABORT;
|
|
} else {
|
|
ccb->ccb_h.status = CAM_REQ_CMP;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
printf("abort of unknown func %#x\n",
|
|
accb->ccb_h.func_code);
|
|
ccb->ccb_h.status = CAM_REQ_INVALID;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case XPT_RESET_BUS:
|
|
if (ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE) == 0) {
|
|
rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
|
|
if (rc) {
|
|
ocs_log_debug(ocs, "Failed to bring port online"
|
|
" : %d\n", rc);
|
|
}
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
} else {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
}
|
|
xpt_done(ccb);
|
|
break;
|
|
case XPT_RESET_DEV:
|
|
{
|
|
ocs_node_t *node = NULL;
|
|
ocs_io_t *io = NULL;
|
|
int32_t rc = 0;
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
node = ocs_node_get_instance(ocs, fcp->tgt[ccb_h->target_id].node_id);
|
|
if (node == NULL) {
|
|
device_printf(ocs->dev, "%s: no device %d\n",
|
|
__func__, ccb_h->target_id);
|
|
ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR);
|
|
if (io == NULL) {
|
|
device_printf(ocs->dev, "%s: unable to alloc IO\n",
|
|
__func__);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
rc = ocs_scsi_send_tmf(node, io, NULL, ccb_h->target_lun,
|
|
OCS_SCSI_TMF_LOGICAL_UNIT_RESET,
|
|
NULL, 0, 0, /* sgl, sgl_count, length */
|
|
ocs_initiator_tmf_cb, NULL/*arg*/);
|
|
|
|
if (rc) {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
} else {
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
}
|
|
|
|
if (node->fcp2device) {
|
|
ocs_reset_crn(node, ccb_h->target_lun);
|
|
}
|
|
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
case XPT_EN_LUN: /* target support */
|
|
{
|
|
ocs_tgt_resource_t *trsrc = NULL;
|
|
uint32_t status = 0;
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
device_printf(ocs->dev, "XPT_EN_LUN %sable %d:%d\n",
|
|
ccb->cel.enable ? "en" : "dis",
|
|
ccb->ccb_h.target_id,
|
|
(unsigned int)ccb->ccb_h.target_lun);
|
|
|
|
trsrc = ocs_tgt_resource_get(fcp, &ccb->ccb_h, &status);
|
|
if (trsrc) {
|
|
trsrc->enabled = ccb->cel.enable;
|
|
|
|
/* Abort all ATIO/INOT on LUN disable */
|
|
if (trsrc->enabled == FALSE) {
|
|
ocs_tgt_resource_abort(ocs, trsrc);
|
|
} else {
|
|
STAILQ_INIT(&trsrc->atio);
|
|
STAILQ_INIT(&trsrc->inot);
|
|
}
|
|
status = CAM_REQ_CMP;
|
|
}
|
|
|
|
ocs_set_ccb_status(ccb, status);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
/*
|
|
* The flow of target IOs in CAM is:
|
|
* - CAM supplies a number of CCBs to the driver used for received
|
|
* commands.
|
|
* - when the driver receives a command, it copies the relevant
|
|
* information to the CCB and returns it to the CAM using xpt_done()
|
|
* - after the target server processes the request, it creates
|
|
* a new CCB containing information on how to continue the IO and
|
|
* passes that to the driver
|
|
* - the driver processes the "continue IO" (a.k.a CTIO) CCB
|
|
* - once the IO completes, the driver returns the CTIO to the CAM
|
|
* using xpt_done()
|
|
*/
|
|
case XPT_ACCEPT_TARGET_IO: /* used to inform upper layer of
|
|
received CDB (a.k.a. ATIO) */
|
|
case XPT_IMMEDIATE_NOTIFY: /* used to inform upper layer of other
|
|
event (a.k.a. INOT) */
|
|
{
|
|
ocs_tgt_resource_t *trsrc = NULL;
|
|
uint32_t status = 0;
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
/*printf("XPT_%s %p\n", ccb_h->func_code == XPT_ACCEPT_TARGET_IO ?
|
|
"ACCEPT_TARGET_IO" : "IMMEDIATE_NOTIFY", ccb);*/
|
|
trsrc = ocs_tgt_resource_get(fcp, &ccb->ccb_h, &status);
|
|
if (trsrc == NULL) {
|
|
ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
if (XPT_ACCEPT_TARGET_IO == ccb->ccb_h.func_code) {
|
|
struct ccb_accept_tio *atio = NULL;
|
|
|
|
atio = (struct ccb_accept_tio *)ccb;
|
|
atio->init_id = 0x0badbeef;
|
|
atio->tag_id = 0xdeadc0de;
|
|
|
|
STAILQ_INSERT_TAIL(&trsrc->atio, &ccb->ccb_h,
|
|
sim_links.stqe);
|
|
} else {
|
|
STAILQ_INSERT_TAIL(&trsrc->inot, &ccb->ccb_h,
|
|
sim_links.stqe);
|
|
}
|
|
ccb->ccb_h.ccb_io_ptr = NULL;
|
|
ccb->ccb_h.ccb_ocs_ptr = ocs;
|
|
ocs_set_ccb_status(ccb, CAM_REQ_INPROG);
|
|
/*
|
|
* These actions give resources to the target driver.
|
|
* If we didn't return here, this function would call
|
|
* xpt_done(), signaling to the upper layers that an
|
|
* IO or other event had arrived.
|
|
*/
|
|
break;
|
|
}
|
|
case XPT_NOTIFY_ACKNOWLEDGE:
|
|
{
|
|
ocs_io_t *io = NULL;
|
|
ocs_io_t *abortio = NULL;
|
|
|
|
/* Get the IO reference for this tag */
|
|
io = ocs_scsi_find_io(ocs, ccb->cna2.tag_id);
|
|
if (io == NULL) {
|
|
device_printf(ocs->dev,
|
|
"%s: XPT_NOTIFY_ACKNOWLEDGE no IO with tag %#x\n",
|
|
__func__, ccb->cna2.tag_id);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
|
|
abortio = io->tgt_io.app;
|
|
if (abortio) {
|
|
abortio->tgt_io.flags &= ~OCS_CAM_IO_F_ABORT_NOTIFY;
|
|
device_printf(ocs->dev,
|
|
"%s: XPT_NOTIFY_ACK state=%d tag=%#x xid=%#x"
|
|
" flags=%#x\n", __func__, abortio->tgt_io.state,
|
|
abortio->tag, abortio->init_task_tag,
|
|
abortio->tgt_io.flags);
|
|
/* TMF response was sent in abort callback */
|
|
} else {
|
|
ocs_scsi_send_tmf_resp(io,
|
|
OCS_SCSI_TMF_FUNCTION_COMPLETE,
|
|
NULL, ocs_target_tmf_cb, NULL);
|
|
}
|
|
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
case XPT_CONT_TARGET_IO: /* continue target IO, sending data/response (a.k.a. CTIO) */
|
|
if (ocs_target_io(ocs, ccb)) {
|
|
device_printf(ocs->dev,
|
|
"XPT_CONT_TARGET_IO failed flags=%x tag=%#x\n",
|
|
ccb->ccb_h.flags, ccb->csio.tag_id);
|
|
xpt_done(ccb);
|
|
}
|
|
break;
|
|
default:
|
|
device_printf(ocs->dev, "unhandled func_code = %#x\n",
|
|
ccb_h->func_code);
|
|
ccb_h->status = CAM_REQ_INVALID;
|
|
xpt_done(ccb);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ingroup cam_api
|
|
* @brief Process events
|
|
*
|
|
* @param sim pointer to the SCSI Interface Module
|
|
*
|
|
*/
|
|
static void
|
|
ocs_poll(struct cam_sim *sim)
|
|
{
|
|
printf("%s\n", __func__);
|
|
}
|
|
|
|
static int32_t
|
|
ocs_initiator_tmf_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status,
|
|
ocs_scsi_cmd_resp_t *rsp, uint32_t flags, void *arg)
|
|
{
|
|
int32_t rc = 0;
|
|
|
|
switch (scsi_status) {
|
|
case OCS_SCSI_STATUS_GOOD:
|
|
case OCS_SCSI_STATUS_NO_IO:
|
|
break;
|
|
case OCS_SCSI_STATUS_CHECK_RESPONSE:
|
|
if (rsp->response_data_length == 0) {
|
|
ocs_log_test(io->ocs, "check response without data?!?\n");
|
|
rc = -1;
|
|
break;
|
|
}
|
|
|
|
if (rsp->response_data[3] != 0) {
|
|
ocs_log_test(io->ocs, "TMF status %08x\n",
|
|
be32toh(*((uint32_t *)rsp->response_data)));
|
|
rc = -1;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
ocs_log_test(io->ocs, "status=%#x\n", scsi_status);
|
|
rc = -1;
|
|
}
|
|
|
|
ocs_scsi_io_free(io);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* @brief lookup target resource structure
|
|
*
|
|
* Arbitrarily support
|
|
* - wildcard target ID + LU
|
|
* - 0 target ID + non-wildcard LU
|
|
*
|
|
* @param ocs the driver instance's software context
|
|
* @param ccb_h pointer to the CCB header
|
|
* @param status returned status value
|
|
*
|
|
* @return pointer to the target resource, NULL if none available (e.g. if LU
|
|
* is not enabled)
|
|
*/
|
|
static ocs_tgt_resource_t *ocs_tgt_resource_get(ocs_fcport *fcp,
|
|
struct ccb_hdr *ccb_h, uint32_t *status)
|
|
{
|
|
target_id_t tid = ccb_h->target_id;
|
|
lun_id_t lun = ccb_h->target_lun;
|
|
|
|
if (CAM_TARGET_WILDCARD == tid) {
|
|
if (CAM_LUN_WILDCARD != lun) {
|
|
*status = CAM_LUN_INVALID;
|
|
return NULL;
|
|
}
|
|
return &fcp->targ_rsrc_wildcard;
|
|
} else {
|
|
if (lun < OCS_MAX_LUN) {
|
|
return &fcp->targ_rsrc[lun];
|
|
} else {
|
|
*status = CAM_LUN_INVALID;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static int32_t
|
|
ocs_tgt_resource_abort(struct ocs_softc *ocs, ocs_tgt_resource_t *trsrc)
|
|
{
|
|
union ccb *ccb = NULL;
|
|
|
|
do {
|
|
ccb = (union ccb *)STAILQ_FIRST(&trsrc->atio);
|
|
if (ccb) {
|
|
STAILQ_REMOVE_HEAD(&trsrc->atio, sim_links.stqe);
|
|
ccb->ccb_h.status = CAM_REQ_ABORTED;
|
|
xpt_done(ccb);
|
|
}
|
|
} while (ccb);
|
|
|
|
do {
|
|
ccb = (union ccb *)STAILQ_FIRST(&trsrc->inot);
|
|
if (ccb) {
|
|
STAILQ_REMOVE_HEAD(&trsrc->inot, sim_links.stqe);
|
|
ccb->ccb_h.status = CAM_REQ_ABORTED;
|
|
xpt_done(ccb);
|
|
}
|
|
} while (ccb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
ocs_abort_atio(struct ocs_softc *ocs, union ccb *ccb)
|
|
{
|
|
|
|
ocs_io_t *aio = NULL;
|
|
ocs_tgt_resource_t *trsrc = NULL;
|
|
uint32_t status = CAM_REQ_INVALID;
|
|
struct ccb_hdr *cur = NULL;
|
|
union ccb *accb = ccb->cab.abort_ccb;
|
|
|
|
int bus = cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path));
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
trsrc = ocs_tgt_resource_get(fcp, &accb->ccb_h, &status);
|
|
if (trsrc != NULL) {
|
|
STAILQ_FOREACH(cur, &trsrc->atio, sim_links.stqe) {
|
|
if (cur != &accb->ccb_h)
|
|
continue;
|
|
|
|
STAILQ_REMOVE(&trsrc->atio, cur, ccb_hdr,
|
|
sim_links.stqe);
|
|
accb->ccb_h.status = CAM_REQ_ABORTED;
|
|
xpt_done(accb);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* if the ATIO has a valid IO pointer, CAM is telling
|
|
* the driver that the ATIO (which represents the entire
|
|
* exchange) has been aborted. */
|
|
|
|
aio = accb->ccb_h.ccb_io_ptr;
|
|
if (aio == NULL) {
|
|
ccb->ccb_h.status = CAM_UA_ABORT;
|
|
return;
|
|
}
|
|
|
|
device_printf(ocs->dev,
|
|
"%s: XPT_ABORT ATIO state=%d tag=%#x"
|
|
" xid=%#x flags=%#x\n", __func__,
|
|
aio->tgt_io.state, aio->tag,
|
|
aio->init_task_tag, aio->tgt_io.flags);
|
|
/* Expectations are:
|
|
* - abort task was received
|
|
* - already aborted IO in the DEVICE
|
|
* - already received NOTIFY ACKNOWLEDGE */
|
|
|
|
if ((aio->tgt_io.flags & OCS_CAM_IO_F_ABORT_RECV) == 0) {
|
|
device_printf(ocs->dev, "%s: abort not received or io completed \n", __func__);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
return;
|
|
}
|
|
|
|
aio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_CAM;
|
|
ocs_target_io_free(aio);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
|
|
return;
|
|
}
|
|
|
|
static void
|
|
ocs_abort_inot(struct ocs_softc *ocs, union ccb *ccb)
|
|
{
|
|
ocs_tgt_resource_t *trsrc = NULL;
|
|
uint32_t status = CAM_REQ_INVALID;
|
|
struct ccb_hdr *cur = NULL;
|
|
union ccb *accb = ccb->cab.abort_ccb;
|
|
|
|
int bus = cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path));
|
|
ocs_fcport *fcp = FCPORT(ocs, bus);
|
|
|
|
trsrc = ocs_tgt_resource_get(fcp, &accb->ccb_h, &status);
|
|
if (trsrc) {
|
|
STAILQ_FOREACH(cur, &trsrc->inot, sim_links.stqe) {
|
|
if (cur != &accb->ccb_h)
|
|
continue;
|
|
|
|
STAILQ_REMOVE(&trsrc->inot, cur, ccb_hdr,
|
|
sim_links.stqe);
|
|
accb->ccb_h.status = CAM_REQ_ABORTED;
|
|
xpt_done(accb);
|
|
ocs_set_ccb_status(ccb, CAM_REQ_CMP);
|
|
return;
|
|
}
|
|
}
|
|
|
|
ocs_set_ccb_status(ccb, CAM_UA_ABORT);
|
|
return;
|
|
}
|
|
|
|
static uint32_t
|
|
ocs_abort_initiator_io(struct ocs_softc *ocs, union ccb *accb)
|
|
{
|
|
|
|
ocs_node_t *node = NULL;
|
|
ocs_io_t *io = NULL;
|
|
int32_t rc = 0;
|
|
struct ccb_scsiio *csio = &accb->csio;
|
|
|
|
ocs_fcport *fcp = FCPORT(ocs, cam_sim_bus(xpt_path_sim((accb)->ccb_h.path)));
|
|
node = ocs_node_get_instance(ocs, fcp->tgt[accb->ccb_h.target_id].node_id);
|
|
if (node == NULL) {
|
|
device_printf(ocs->dev, "%s: no device %d\n",
|
|
__func__, accb->ccb_h.target_id);
|
|
ocs_set_ccb_status(accb, CAM_DEV_NOT_THERE);
|
|
xpt_done(accb);
|
|
return (-1);
|
|
}
|
|
|
|
io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR);
|
|
if (io == NULL) {
|
|
device_printf(ocs->dev,
|
|
"%s: unable to alloc IO\n", __func__);
|
|
ocs_set_ccb_status(accb, CAM_REQ_CMP_ERR);
|
|
xpt_done(accb);
|
|
return (-1);
|
|
}
|
|
|
|
rc = ocs_scsi_send_tmf(node, io,
|
|
(ocs_io_t *)csio->ccb_h.ccb_io_ptr,
|
|
accb->ccb_h.target_lun,
|
|
OCS_SCSI_TMF_ABORT_TASK,
|
|
NULL, 0, 0,
|
|
ocs_initiator_tmf_cb, NULL/*arg*/);
|
|
|
|
return rc;
|
|
}
|
|
|
|
void
|
|
ocs_scsi_ini_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj)
|
|
{
|
|
switch(type) {
|
|
case OCS_SCSI_DDUMP_DEVICE: {
|
|
//ocs_t *ocs = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_DOMAIN: {
|
|
//ocs_domain_t *domain = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_SPORT: {
|
|
//ocs_sport_t *sport = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_NODE: {
|
|
//ocs_node_t *node = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_IO: {
|
|
//ocs_io_t *io = obj;
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ocs_scsi_tgt_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj)
|
|
{
|
|
switch(type) {
|
|
case OCS_SCSI_DDUMP_DEVICE: {
|
|
//ocs_t *ocs = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_DOMAIN: {
|
|
//ocs_domain_t *domain = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_SPORT: {
|
|
//ocs_sport_t *sport = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_NODE: {
|
|
//ocs_node_t *node = obj;
|
|
break;
|
|
}
|
|
case OCS_SCSI_DDUMP_IO: {
|
|
ocs_io_t *io = obj;
|
|
char *state_str = NULL;
|
|
|
|
switch (io->tgt_io.state) {
|
|
case OCS_CAM_IO_FREE:
|
|
state_str = "FREE";
|
|
break;
|
|
case OCS_CAM_IO_COMMAND:
|
|
state_str = "COMMAND";
|
|
break;
|
|
case OCS_CAM_IO_DATA:
|
|
state_str = "DATA";
|
|
break;
|
|
case OCS_CAM_IO_DATA_DONE:
|
|
state_str = "DATA_DONE";
|
|
break;
|
|
case OCS_CAM_IO_RESP:
|
|
state_str = "RESP";
|
|
break;
|
|
default:
|
|
state_str = "xxx BAD xxx";
|
|
}
|
|
ocs_ddump_value(textbuf, "cam_st", "%s", state_str);
|
|
if (io->tgt_io.app) {
|
|
ocs_ddump_value(textbuf, "cam_flags", "%#x",
|
|
((union ccb *)(io->tgt_io.app))->ccb_h.flags);
|
|
ocs_ddump_value(textbuf, "cam_status", "%#x",
|
|
((union ccb *)(io->tgt_io.app))->ccb_h.status);
|
|
}
|
|
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t ocs_scsi_get_block_vaddr(ocs_io_t *io, uint64_t blocknumber,
|
|
ocs_scsi_vaddr_len_t addrlen[],
|
|
uint32_t max_addrlen, void **dif_vaddr)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
uint32_t
|
|
ocs_get_crn(ocs_node_t *node, uint8_t *crn, uint64_t lun)
|
|
{
|
|
uint32_t idx;
|
|
struct ocs_lun_crn *lcrn = NULL;
|
|
idx = lun % OCS_MAX_LUN;
|
|
|
|
lcrn = node->ini_node.lun_crn[idx];
|
|
|
|
if (lcrn == NULL) {
|
|
lcrn = ocs_malloc(node->ocs, sizeof(struct ocs_lun_crn),
|
|
M_ZERO|M_NOWAIT);
|
|
if (lcrn == NULL) {
|
|
return (1);
|
|
}
|
|
|
|
lcrn->lun = lun;
|
|
node->ini_node.lun_crn[idx] = lcrn;
|
|
}
|
|
|
|
if (lcrn->lun != lun) {
|
|
return (1);
|
|
}
|
|
|
|
if (lcrn->crnseed == 0)
|
|
lcrn->crnseed = 1;
|
|
|
|
*crn = lcrn->crnseed++;
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
ocs_del_crn(ocs_node_t *node)
|
|
{
|
|
uint32_t i;
|
|
struct ocs_lun_crn *lcrn = NULL;
|
|
|
|
for(i = 0; i < OCS_MAX_LUN; i++) {
|
|
lcrn = node->ini_node.lun_crn[i];
|
|
if (lcrn) {
|
|
ocs_free(node->ocs, lcrn, sizeof(*lcrn));
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
ocs_reset_crn(ocs_node_t *node, uint64_t lun)
|
|
{
|
|
uint32_t idx;
|
|
struct ocs_lun_crn *lcrn = NULL;
|
|
idx = lun % OCS_MAX_LUN;
|
|
|
|
lcrn = node->ini_node.lun_crn[idx];
|
|
if (lcrn)
|
|
lcrn->crnseed = 0;
|
|
|
|
return;
|
|
}
|