openEuler/openEuler_kernel_rk3588
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
openEuler_kernel_rk3588/drivers/scsi/huawei/hifc/unf_exchg.c
ardu a3d3d6db49 new
2026-01-21 18:59:54 +08:00

3633 lines
109 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
/* Huawei Hifc PCI Express Linux driver
* Copyright(c) 2017 Huawei Technologies Co., Ltd
*
*/
#include "unf_log.h"
#include "unf_common.h"
#include "unf_exchg.h"
#include "unf_rport.h"
#include "unf_service.h"
#include "unf_io.h"
#define UNF_DEL_XCHG_TIMER_SAFE(v_xchg) \
do { \
if (cancel_delayed_work(&((v_xchg)->timeout_work))) { \
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_IO_ATT, \
UNF_MAJOR, \
"Exchange(0x%p) is free, but timer is pending.", \
v_xchg); \
} else { \
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_IO_ATT, \
UNF_CRITICAL, \
"Exchange(0x%p) is free, but timer is running.", \
v_xchg); \
} \
} while (0)
#define UNF_XCHG_IS_ELS_REPLY(v_xchg) \
((((v_xchg)->cmnd_code & 0x0ffff) == ELS_ACC) || \
(((v_xchg)->cmnd_code & 0x0ffff) == ELS_RJT))
static struct unf_ioflow_id_s io_stage[] = {
{ "XCHG_ALLOC" },
{ "TGT_RECEIVE_ABTS" },
{ "TGT_ABTS_DONE" },
{ "TGT_IO_SRR" },
{ "SFS_RESPONSE" },
{ "SFS_TIMEOUT" },
{ "INI_SEND_CMND" },
{ "INI_RESPONSE_DONE" },
{ "INI_EH_ABORT" },
{ "INI_EH_DEVICE_RESET" },
{ "INI_EH_BLS_DONE" },
{ "INI_IO_TIMEOUT" },
{ "INI_REQ_TIMEOUT" },
{ "XCHG_CANCEL_TIMER" },
{ "XCHG_FREE_XCHG" },
{ "SEND_ELS" },
{ "IO_XCHG_WAIT" },
};
void unf_wakeup_scsi_task_cmnd(struct unf_lport_s *v_lport)
{
struct list_head *node = NULL;
struct list_head *next_node = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long hot_pool_lock_flags = 0;
unsigned long xchg_flag = 0;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
unsigned int i = 0;
UNF_CHECK_VALID(0x850, UNF_TRUE, v_lport, return);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
xchg_mgr = unf_get_xchg_mgr_by_lport(v_lport, i);
if (!xchg_mgr) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_EVENT, UNF_MINOR,
"Can't find LPort(0x%x) MgrIdx %u exchange manager.",
v_lport->port_id, i);
continue;
}
spin_lock_irqsave(&xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
list_for_each_safe(node, next_node,
&xchg_mgr->hot_pool->ini_busylist) {
xchg = list_entry(node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock, xchg_flag);
if (INI_IO_STATE_UPTASK & xchg->io_state &&
(atomic_read(&xchg->ref_cnt) > 0)) {
UNF_SET_SCSI_CMND_RESULT(xchg, UNF_IO_SUCCESS);
up(&xchg->task_sema);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_EVENT, UNF_MINOR,
"Wake up task command exchange(0x%p), Hot Pool Tag(0x%x).",
xchg, xchg->hot_pool_tag);
}
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_flag);
}
spin_unlock_irqrestore(&xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
}
}
void unf_cm_xchg_mgr_abort_io_by_id(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport,
unsigned int v_sid, unsigned int v_did,
unsigned int v_extra_io_state)
{
/*
* for target session: set ABORT
* 1. R_Port remove
* 2. Send PLOGI_ACC callback
* 3. RCVD PLOGI
* 4. RCVD LOGO
*/
UNF_CHECK_VALID(0x852, UNF_TRUE, v_lport, return);
if (v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_io_xchg_abort) {
/* The SID/DID of the Xchg is in reverse direction in
* different phases. Therefore, the reverse direction
* needs to be considered
*/
v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_io_xchg_abort(
v_lport,
v_rport,
v_sid, v_did,
v_extra_io_state);
v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_io_xchg_abort(
v_lport, v_rport,
v_did, v_sid,
v_extra_io_state);
}
}
void unf_cm_xchg_mgr_abort_sfs_by_id(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport,
unsigned int v_sid, unsigned int v_did)
{
UNF_CHECK_VALID(0x990, UNF_TRUE, v_lport, return);
if (v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_sfs_xchg_abort) {
/* The SID/DID of the Xchg is in reverse direction in different
* phases, therefore, the reverse direction
* needs to be considered
*/
v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_sfs_xchg_abort(v_lport,
v_rport,
v_sid,
v_did);
v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_sfs_xchg_abort(v_lport,
v_rport,
v_did,
v_sid);
}
}
void unf_cm_xchg_abort_by_lun(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport,
unsigned long long v_lun_id,
void *v_tm_xchg,
int v_abort_all_lun_flag)
{
/*
* LUN Reset: set UP_ABORT tag, with:
* INI_Busy_list, IO_Wait_list,
* IO_Delay_list, IO_Delay_transfer_list
*/
void (*unf_xchg_abort_by_lun)(void*, void*, unsigned long long,
void*, int) = NULL;
UNF_CHECK_VALID(0x853, UNF_TRUE, v_lport, return);
unf_xchg_abort_by_lun =
v_lport->xchg_mgr_temp.pfn_unf_xchg_abort_by_lun;
if (unf_xchg_abort_by_lun) {
unf_xchg_abort_by_lun((void *)v_lport, (void *)v_rport,
v_lun_id, v_tm_xchg,
v_abort_all_lun_flag);
}
}
void unf_cm_xchg_abort_by_session(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
void (*pfn_unf_xchg_abort_by_session)(void*, void*) = NULL;
UNF_CHECK_VALID(0x853, UNF_TRUE, v_lport, return);
pfn_unf_xchg_abort_by_session =
v_lport->xchg_mgr_temp.pfn_unf_xchg_abort_by_session;
if (pfn_unf_xchg_abort_by_session) {
pfn_unf_xchg_abort_by_session((void *)v_lport,
(void *)v_rport);
}
}
void *unf_cm_get_free_xchg(void *v_lport, unsigned int v_xchg_type)
{
struct unf_lport_s *lport = NULL;
struct unf_cm_xchg_mgr_template_s *xch_mgr_temp = NULL;
UNF_CHECK_VALID(0x855, UNF_TRUE, unlikely(v_lport), return NULL);
lport = (struct unf_lport_s *)v_lport;
xch_mgr_temp = &lport->xchg_mgr_temp;
/* Find the corresponding Lport Xchg management template. */
UNF_CHECK_VALID(0x856, UNF_TRUE,
unlikely(xch_mgr_temp->pfn_unf_xchg_get_free_and_init),
return NULL);
return xch_mgr_temp->pfn_unf_xchg_get_free_and_init(lport, v_xchg_type,
INVALID_VALUE16);
}
void unf_cm_free_xchg(void *v_lport, void *v_xchg)
{
struct unf_lport_s *lport = NULL;
struct unf_cm_xchg_mgr_template_s *xch_mgr_temp = NULL;
UNF_CHECK_VALID(0x857, UNF_TRUE, unlikely(v_lport), return);
UNF_CHECK_VALID(0x858, UNF_TRUE, unlikely(v_xchg), return);
lport = (struct unf_lport_s *)v_lport;
xch_mgr_temp = &lport->xchg_mgr_temp;
UNF_CHECK_VALID(0x859, UNF_TRUE,
unlikely(xch_mgr_temp->pfn_unf_xchg_release),
return);
/*
* unf_cm_free_xchg --->>> unf_free_xchg
* --->>> unf_xchg_ref_dec --->>> unf_free_fcp_xchg
* --->>> unf_done_ini_xchg
*/
xch_mgr_temp->pfn_unf_xchg_release(v_lport, v_xchg);
}
void *unf_cm_lookup_xchg_by_tag(void *v_lport, unsigned short v_hot_pool_tag)
{
struct unf_lport_s *lport = NULL;
struct unf_cm_xchg_mgr_template_s *xch_mgr_temp = NULL;
UNF_CHECK_VALID(0x860, UNF_TRUE, unlikely(v_lport), return NULL);
/* Find the corresponding Lport Xchg management template */
lport = (struct unf_lport_s *)v_lport;
xch_mgr_temp = &lport->xchg_mgr_temp;
UNF_CHECK_VALID(0x861, UNF_TRUE,
unlikely(xch_mgr_temp->pfn_unf_look_up_xchg_by_tag),
return NULL);
return xch_mgr_temp->pfn_unf_look_up_xchg_by_tag(v_lport,
v_hot_pool_tag);
}
void *unf_cm_lookup_xchg_by_id(void *v_lport, unsigned short v_ox_id,
unsigned int v_oid)
{
struct unf_lport_s *lport = NULL;
struct unf_cm_xchg_mgr_template_s *xch_mgr_temp = NULL;
UNF_CHECK_VALID(0x862, UNF_TRUE, unlikely(v_lport), return NULL);
lport = (struct unf_lport_s *)v_lport;
xch_mgr_temp = &lport->xchg_mgr_temp;
/* Find the corresponding Lport Xchg management template */
UNF_CHECK_VALID(0x863, UNF_TRUE,
unlikely(xch_mgr_temp->pfn_unf_look_up_xchg_by_id),
return NULL);
return xch_mgr_temp->pfn_unf_look_up_xchg_by_id(v_lport, v_ox_id,
v_oid);
}
struct unf_xchg_s *unf_cm_lookup_xchg_by_cmnd_sn(
void *v_lport,
unsigned long long v_command_sn,
unsigned int v_world_id)
{
struct unf_lport_s *lport = NULL;
struct unf_cm_xchg_mgr_template_s *xch_mgr_temp = NULL;
struct unf_xchg_s *xchg = NULL;
UNF_CHECK_VALID(0x864, UNF_TRUE, unlikely(v_lport), return NULL);
lport = (struct unf_lport_s *)v_lport;
xch_mgr_temp = &lport->xchg_mgr_temp;
UNF_CHECK_VALID(
0x865, UNF_TRUE,
unlikely(xch_mgr_temp->pfn_unf_look_up_xchg_by_cmnd_sn),
return NULL);
xchg =
(struct unf_xchg_s *)xch_mgr_temp->pfn_unf_look_up_xchg_by_cmnd_sn(
lport, v_command_sn,
v_world_id);
return xchg;
}
static void unf_free_all_rsp_pages(struct unf_xchg_mgr_s *v_xchg_mgr)
{
unsigned int buff_index;
UNF_CHECK_VALID(0x868, UNF_TRUE, v_xchg_mgr, return);
if (v_xchg_mgr->rsp_buf_list.buflist) {
for (buff_index = 0; buff_index <
v_xchg_mgr->rsp_buf_list.buf_num;
buff_index++) {
if (v_xchg_mgr->rsp_buf_list.buflist[buff_index].vaddr) {
dma_free_coherent(
&v_xchg_mgr->hot_pool->lport->low_level_func.dev->dev,
v_xchg_mgr->rsp_buf_list.buf_size,
v_xchg_mgr->rsp_buf_list.buflist[buff_index].vaddr,
v_xchg_mgr->rsp_buf_list.buflist[buff_index].paddr);
v_xchg_mgr->rsp_buf_list.buflist[buff_index].vaddr = NULL;
}
}
kfree(v_xchg_mgr->rsp_buf_list.buflist);
v_xchg_mgr->rsp_buf_list.buflist = NULL;
}
}
static unsigned int unf_init_xchg(struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr,
unsigned int v_xchg_sum,
unsigned int v_sfs_sum)
{
struct unf_xchg_s *xchg_mem = NULL;
union unf_sfs_u *sfs_mm_start = NULL;
dma_addr_t sfs_dma_addr;
struct unf_xchg_s *xchg = NULL;
struct unf_xchg_free_pool_s *free_pool = NULL;
unsigned int rsp_iu_nums_per_page = 0;
unsigned int rsp_iu_size = 0;
unsigned long flags = 0;
unsigned int xchg_sum = 0;
unsigned int i = 0;
unsigned int rsp_iu_loop = 0;
unsigned int buf_num;
unsigned int buf_size;
unsigned int curbuf_idx = 0;
void *page_addr;
dma_addr_t phy_addr;
UNF_CHECK_VALID(0x871, UNF_TRUE, v_sfs_sum <= v_xchg_sum,
return UNF_RETURN_ERROR);
free_pool = &v_xchg_mgr->free_pool;
xchg_sum = v_xchg_sum;
xchg_mem = v_xchg_mgr->fcp_mm_start;
xchg = xchg_mem;
sfs_mm_start = (union unf_sfs_u *)v_xchg_mgr->sfs_mm_start;
sfs_dma_addr = v_xchg_mgr->sfs_phy_addr;
/* 1. Allocate the SFS UNION memory to each SFS XCHG
* and mount the SFS XCHG to the corresponding FREE linked list
*/
free_pool->total_sfs_xchg = 0;
free_pool->sfs_xchg_sum = v_sfs_sum;
for (i = 0; i < v_sfs_sum; i++) {
INIT_LIST_HEAD(&xchg->list_xchg_entry);
INIT_LIST_HEAD(&xchg->list_esgls);
spin_lock_init(&xchg->xchg_state_lock);
sema_init(&xchg->task_sema, 0);
sema_init(&xchg->echo_info.echo_sync_sema, 0);
spin_lock_irqsave(&free_pool->xchg_free_pool_lock, flags);
xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr = sfs_mm_start;
xchg->fcp_sfs_union.sfs_entry.sfs_buff_phy_addr = sfs_dma_addr;
xchg->fcp_sfs_union.sfs_entry.sfs_buff_len =
sizeof(*sfs_mm_start);
list_add_tail(&xchg->list_xchg_entry,
&free_pool->list_sfs_xchg_list);
free_pool->total_sfs_xchg++;
spin_unlock_irqrestore(&free_pool->xchg_free_pool_lock, flags);
sfs_mm_start++;
sfs_dma_addr = sfs_dma_addr + sizeof(union unf_sfs_u);
xchg++;
}
/*
* 2. Allocate RSP IU memory for each IO XCHG and mount IO
* XCHG to the corresponding FREE linked list
* The memory size of each RSP IU is rsp_iu_size.
*/
rsp_iu_size = (UNF_FCPRSP_CTL_LEN + UNF_MAX_RSP_INFO_LEN +
UNF_SCSI_SENSE_DATA_LEN);
buf_size = BUF_LIST_PAGE_SIZE;
if ((xchg_sum - v_sfs_sum) * rsp_iu_size < BUF_LIST_PAGE_SIZE)
buf_size = (xchg_sum - v_sfs_sum) * rsp_iu_size;
rsp_iu_nums_per_page = buf_size / rsp_iu_size;
buf_num = (xchg_sum - v_sfs_sum) % rsp_iu_nums_per_page ?
(xchg_sum - v_sfs_sum) / rsp_iu_nums_per_page + 1 :
(xchg_sum - v_sfs_sum) / rsp_iu_nums_per_page;
v_xchg_mgr->rsp_buf_list.buflist =
(struct buff_list_s *)kmalloc(
buf_num * sizeof(struct buff_list_s),
GFP_KERNEL);
v_xchg_mgr->rsp_buf_list.buf_num = buf_num;
v_xchg_mgr->rsp_buf_list.buf_size = buf_size;
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_REG_ATT, UNF_MAJOR,
"[info]Port(0x%x) buff num 0x%x buff size 0x%x",
v_lport->port_id, buf_num,
v_xchg_mgr->rsp_buf_list.buf_size);
if (!v_xchg_mgr->rsp_buf_list.buflist) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_REG_ATT, UNF_WARN,
"[err]Allocate BigSfs pool buf list failed out of memory");
goto free_buff;
}
memset(v_xchg_mgr->rsp_buf_list.buflist, 0,
buf_num * sizeof(struct buff_list_s));
free_pool->total_fcp_xchg = 0;
for (i = 0, curbuf_idx = 0; curbuf_idx < buf_num; curbuf_idx++) {
page_addr = dma_alloc_coherent(
&v_lport->low_level_func.dev->dev,
v_xchg_mgr->rsp_buf_list.buf_size,
&phy_addr, GFP_KERNEL);
if (!page_addr)
goto free_buff;
memset(page_addr, 0, v_xchg_mgr->rsp_buf_list.buf_size);
v_xchg_mgr->rsp_buf_list.buflist[curbuf_idx].vaddr = page_addr;
v_xchg_mgr->rsp_buf_list.buflist[curbuf_idx].paddr = phy_addr;
for (rsp_iu_loop = 0;
(rsp_iu_loop < rsp_iu_nums_per_page &&
i < xchg_sum - v_sfs_sum); rsp_iu_loop++) {
INIT_LIST_HEAD(&xchg->list_xchg_entry);
INIT_LIST_HEAD(&xchg->list_esgls);
spin_lock_init(&xchg->xchg_state_lock);
sema_init(&xchg->task_sema, 0);
sema_init(&xchg->echo_info.echo_sync_sema, 0);
/* alloc dma buffer for fcp_rsp_iu */
spin_lock_irqsave(&free_pool->xchg_free_pool_lock,
flags);
xchg->fcp_sfs_union.fcp_rsp_entry.fcp_rsp_iu =
(struct unf_fcprsp_iu_s *)page_addr;
xchg->fcp_sfs_union.fcp_rsp_entry.fcp_rsp_iu_phy_addr =
phy_addr;
list_add_tail(&xchg->list_xchg_entry,
&free_pool->list_free_xchg_list);
free_pool->total_fcp_xchg++;
spin_unlock_irqrestore(&free_pool->xchg_free_pool_lock,
flags);
page_addr += rsp_iu_size;
phy_addr += rsp_iu_size;
i++;
xchg++;
}
}
free_pool->fcp_xchg_sum = free_pool->total_fcp_xchg;
return RETURN_OK;
free_buff:
unf_free_all_rsp_pages(v_xchg_mgr);
return UNF_RETURN_ERROR;
}
static unsigned int unf_get_xchg_config_sum(struct unf_lport_s *v_lport,
unsigned int *v_xchg_sum)
{
struct unf_lport_cfg_item_s *lport_cfg_items = NULL;
lport_cfg_items = &v_lport->low_level_func.lport_cfg_items;
/* It has been checked at the bottom layer.
* Don't need to check it again.
*/
*v_xchg_sum = lport_cfg_items->max_sfs_xchg + lport_cfg_items->max_io;
if ((*v_xchg_sum / UNF_EXCHG_MGR_NUM) == 0 ||
lport_cfg_items->max_sfs_xchg / UNF_EXCHG_MGR_NUM == 0) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_REG_ATT, UNF_ERR,
"[err]Port(0x%x) Xchgsum(%u) or SfsXchg(%u) is less than ExchangeMgrNum(%u).",
v_lport->port_id, *v_xchg_sum,
lport_cfg_items->max_sfs_xchg,
UNF_EXCHG_MGR_NUM);
return UNF_RETURN_ERROR;
}
if (*v_xchg_sum > (INVALID_VALUE16 - 1)) {
/* If the format of ox_id/rx_id is exceeded,
* this function is not supported
*/
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_ERR,
"Port(0x%x) Exchange num(0x%x) is Too Big.",
v_lport->port_id, *v_xchg_sum);
return UNF_RETURN_ERROR;
}
return RETURN_OK;
}
static void unf_xchg_cancel_timer(void *v_xchg)
{
struct unf_xchg_s *xchg = NULL;
int need_dec_xchg_ref = UNF_FALSE;
unsigned long flag = 0;
UNF_CHECK_VALID(0x874, UNF_TRUE, v_xchg, return);
xchg = (struct unf_xchg_s *)v_xchg;
spin_lock_irqsave(&xchg->xchg_state_lock, flag);
if (cancel_delayed_work(&xchg->timeout_work))
need_dec_xchg_ref = UNF_TRUE;
spin_unlock_irqrestore(&xchg->xchg_state_lock, flag);
if (need_dec_xchg_ref == UNF_TRUE)
unf_xchg_ref_dec(v_xchg, XCHG_CANCEL_TIMER);
}
void unf_show_all_xchg(struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr)
{
struct unf_lport_s *lport = NULL;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
struct unf_xchg_s *xchg = NULL;
struct list_head *xchg_node = NULL;
struct list_head *next_xchg_node = NULL;
unsigned long flags = 0;
UNF_CHECK_VALID(0x879, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x880, UNF_TRUE, v_xchg_mgr, return);
UNF_REFERNCE_VAR(lport);
UNF_REFERNCE_VAR(xchg);
xchg_mgr = v_xchg_mgr;
lport = v_lport;
/* hot Xchg */
spin_lock_irqsave(&xchg_mgr->hot_pool->xchg_hot_pool_lock, flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_NORMAL, UNF_WARN,
"INI busy :");
list_for_each_safe(xchg_node, next_xchg_node,
&xchg_mgr->hot_pool->ini_busylist) {
xchg = list_entry(xchg_node, struct unf_xchg_s,
list_xchg_entry);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_NORMAL, UNF_MAJOR,
"0x%p---0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----%llu.",
xchg,
(unsigned int)xchg->hot_pool_tag,
(unsigned int)xchg->xchg_type,
(unsigned int)xchg->ox_id,
(unsigned int)xchg->rx_id,
(unsigned int)xchg->sid,
(unsigned int)xchg->did,
atomic_read(&xchg->ref_cnt),
(unsigned int)xchg->io_state,
xchg->alloc_jif);
}
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_NORMAL,
UNF_WARN, "SFS :");
list_for_each_safe(xchg_node, next_xchg_node,
&xchg_mgr->hot_pool->sfs_busylist) {
xchg = list_entry(xchg_node, struct unf_xchg_s,
list_xchg_entry);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_NORMAL, UNF_WARN,
"0x%p---0x%x---0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----%llu.",
xchg,
xchg->cmnd_code,
(unsigned int)xchg->hot_pool_tag,
(unsigned int)xchg->xchg_type,
(unsigned int)xchg->ox_id,
(unsigned int)xchg->rx_id,
(unsigned int)xchg->sid,
(unsigned int)xchg->did,
atomic_read(&xchg->ref_cnt),
(unsigned int)xchg->io_state,
xchg->alloc_jif);
}
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_NORMAL, UNF_WARN,
"Destroy list.");
list_for_each_safe(xchg_node, next_xchg_node,
&xchg_mgr->hot_pool->list_destroy_xchg) {
xchg = list_entry(xchg_node, struct unf_xchg_s,
list_xchg_entry);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_NORMAL, UNF_WARN,
"0x%p---0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----%llu.",
xchg,
(unsigned int)xchg->hot_pool_tag,
(unsigned int)xchg->xchg_type,
(unsigned int)xchg->ox_id,
(unsigned int)xchg->rx_id,
(unsigned int)xchg->sid,
(unsigned int)xchg->did,
atomic_read(&xchg->ref_cnt),
(unsigned int)xchg->io_state,
xchg->alloc_jif);
}
spin_unlock_irqrestore(&xchg_mgr->hot_pool->xchg_hot_pool_lock, flags);
UNF_REFERNCE_VAR(xchg);
UNF_REFERNCE_VAR(lport);
}
static void unf_delay_work_del_syn(struct unf_xchg_s *v_xchg)
{
struct unf_xchg_s *xchg = NULL;
UNF_CHECK_VALID(0x884, UNF_TRUE, v_xchg, return);
xchg = v_xchg;
/* synchronous release timer */
if (!cancel_delayed_work_sync(&xchg->timeout_work)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"Exchange(0x%p), State(0x%x) can't delete work timer, timer is running or no timer.",
xchg, xchg->io_state);
} else {
/* The reference count cannot be directly subtracted.
* This prevents the XCHG from being moved to the
* Free linked list when the card is unloaded.
*/
unf_cm_free_xchg(xchg->lport, xchg);
}
}
static void unf_free_lport_sfs_xchg(struct unf_xchg_mgr_s *v_xchg_mgr,
int v_done_ini_flag)
{
struct list_head *list = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long hot_pool_lock_flags = 0;
UNF_REFERNCE_VAR(v_done_ini_flag);
UNF_CHECK_VALID(0x887, UNF_TRUE, v_xchg_mgr, return);
UNF_CHECK_VALID(0x888, UNF_TRUE, v_xchg_mgr->hot_pool, return);
spin_lock_irqsave(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
while (!list_empty(&v_xchg_mgr->hot_pool->sfs_busylist)) {
list = (&v_xchg_mgr->hot_pool->sfs_busylist)->next;
list_del_init(list);
/* Prevent the xchg of the sfs from being accessed repeatedly.
* The xchg is first mounted to the destroy linked list.
*/
list_add_tail(list, &v_xchg_mgr->hot_pool->list_destroy_xchg);
xchg = list_entry(list, struct unf_xchg_s, list_xchg_entry);
spin_unlock_irqrestore(
&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
unf_delay_work_del_syn(xchg);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"Free SFS Exchange(0x%p), State(0x%x), Reference count(%d), Start time(%llu).",
xchg, xchg->io_state, atomic_read(&xchg->ref_cnt),
xchg->alloc_jif);
unf_cm_free_xchg(xchg->lport, xchg);
spin_lock_irqsave(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
}
spin_unlock_irqrestore(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
}
static void unf_free_lport_destroy_xchg(struct unf_xchg_mgr_s *v_xchg_mgr)
{
#define UNF_WAIT_DESTROY_EMPTY_STEP_MS 1000
#define UNF_WAIT_IO_STATE_TGT_FRONT_MS (10 * 1000)
struct unf_xchg_s *xchg = NULL;
struct list_head *next_xchg_node = NULL;
unsigned long hot_pool_lock_flags = 0;
unsigned long xchg_flag = 0;
UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, v_xchg_mgr, return);
UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, v_xchg_mgr->hot_pool,
return);
/* In this case, the timer on the destroy linked list is deleted.
* You only need to check whether the timer is released
* at the end of the tgt.
*/
spin_lock_irqsave(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
while (!list_empty(&v_xchg_mgr->hot_pool->list_destroy_xchg)) {
next_xchg_node =
(&v_xchg_mgr->hot_pool->list_destroy_xchg)->next;
xchg = list_entry(next_xchg_node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock, xchg_flag);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"Free Exchange(0x%p), Type(0x%x), State(0x%x), Reference count(%d), Start time(%llu)",
xchg, xchg->xchg_type, xchg->io_state,
atomic_read(&xchg->ref_cnt),
xchg->alloc_jif);
spin_unlock_irqrestore(&xchg->xchg_state_lock, xchg_flag);
spin_unlock_irqrestore(
&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
/* This interface can be invoked to ensure that
* the timer is successfully canceled
* or wait until the timer execution is complete
*/
unf_delay_work_del_syn(xchg);
/*
* If the timer is canceled successfully, delete Xchg
* If the timer has burst, the Xchg may have been released,
* In this case, deleting the Xchg will be failed
*/
unf_cm_free_xchg(xchg->lport, xchg);
spin_lock_irqsave(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
};
spin_unlock_irqrestore(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
}
static unsigned int unf_free_lport_xchg(struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr)
{
#define UNF_OS_WAITIO_TIMEOUT (10 * 1000)
unsigned long free_pool_lock_flags = 0;
int wait = UNF_FALSE;
unsigned int total_xchg = 0;
unsigned int total_xchg_sum = 0;
unsigned int ret = RETURN_OK;
unsigned long long timeout = 0;
struct completion xchg_mgr_completion =
COMPLETION_INITIALIZER(xchg_mgr_completion);
UNF_CHECK_VALID(0x881, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
UNF_CHECK_VALID(0x882, UNF_TRUE, v_xchg_mgr, return UNF_RETURN_ERROR);
UNF_CHECK_VALID(0x883, UNF_TRUE, v_xchg_mgr->hot_pool,
return UNF_RETURN_ERROR);
UNF_REFERNCE_VAR(v_lport);
unf_free_lport_sfs_xchg(v_xchg_mgr, UNF_FALSE);
/* free INI Mode exchanges belong to L_Port */
unf_free_lport_ini_xchg(v_xchg_mgr, UNF_FALSE);
spin_lock_irqsave(&v_xchg_mgr->free_pool.xchg_free_pool_lock,
free_pool_lock_flags);
total_xchg = v_xchg_mgr->free_pool.total_fcp_xchg +
v_xchg_mgr->free_pool.total_sfs_xchg;
total_xchg_sum = v_xchg_mgr->free_pool.fcp_xchg_sum +
v_xchg_mgr->free_pool.sfs_xchg_sum;
if (total_xchg != total_xchg_sum) {
v_xchg_mgr->free_pool.xchg_mgr_completion =
&xchg_mgr_completion;
wait = UNF_TRUE;
}
spin_unlock_irqrestore(&v_xchg_mgr->free_pool.xchg_free_pool_lock,
free_pool_lock_flags);
if (wait == UNF_TRUE) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"[info]Port(0x%x) begin to wait for exchange manager completion(%ld) (0x%x:0x%x)",
v_lport->port_id, jiffies, total_xchg,
total_xchg_sum);
unf_show_all_xchg(v_lport, v_xchg_mgr);
timeout = wait_for_completion_timeout(
v_xchg_mgr->free_pool.xchg_mgr_completion,
msecs_to_jiffies(UNF_OS_WAITIO_TIMEOUT));
if (timeout == 0)
unf_free_lport_destroy_xchg(v_xchg_mgr);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"[info]Port(0x%x) wait for exchange manager completion end",
v_lport->port_id);
spin_lock_irqsave(&v_xchg_mgr->free_pool.xchg_free_pool_lock,
free_pool_lock_flags);
v_xchg_mgr->free_pool.xchg_mgr_completion = NULL;
spin_unlock_irqrestore(
&v_xchg_mgr->free_pool.xchg_free_pool_lock,
free_pool_lock_flags);
}
return ret;
}
void unf_free_lport_all_xchg(struct unf_lport_s *v_lport)
{
struct unf_xchg_mgr_s *xchg_mgr;
unsigned int i;
UNF_CHECK_VALID(0x881, UNF_TRUE, v_lport, return);
UNF_REFERNCE_VAR(v_lport);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
xchg_mgr = unf_get_xchg_mgr_by_lport(v_lport, i);
if (unlikely(!xchg_mgr)) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Port(0x%x) hot pool is NULL",
v_lport->port_id);
continue;
}
unf_free_lport_sfs_xchg(xchg_mgr, UNF_FALSE);
/* free INI Mode exchanges belong to L_Port */
unf_free_lport_ini_xchg(xchg_mgr, UNF_FALSE);
unf_free_lport_destroy_xchg(xchg_mgr);
}
}
void unf_free_lport_ini_xchg(struct unf_xchg_mgr_s *v_xchg_mgr,
int v_done_ini_flag)
{
/*
* 1. L_Port destroy
* 2. AC power down
*/
struct list_head *list = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long hot_pool_lock_flags = 0;
unsigned int up_status = 0;
UNF_REFERNCE_VAR(v_done_ini_flag);
UNF_CHECK_VALID(0x889, UNF_TRUE, v_xchg_mgr, return);
UNF_CHECK_VALID(0x890, UNF_TRUE, v_xchg_mgr->hot_pool, return);
spin_lock_irqsave(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
while (!list_empty(&v_xchg_mgr->hot_pool->ini_busylist)) {
/* for each INI busy_list (exchange) node */
list = (&v_xchg_mgr->hot_pool->ini_busylist)->next;
/* Put exchange node to destroy_list, prevent done repeatly */
list_del_init(list);
list_add_tail(list, &v_xchg_mgr->hot_pool->list_destroy_xchg);
xchg = list_entry(list, struct unf_xchg_s, list_xchg_entry);
if (atomic_read(&xchg->ref_cnt) <= 0)
continue;
spin_unlock_irqrestore(
&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
unf_delay_work_del_syn(xchg);
/* In the case of INI done, the command should be set to fail
* to prevent data inconsistency caused by the return of OK
*/
up_status = unf_get_uplevel_cmnd_errcode(
xchg->scsi_cmnd_info.err_code_table,
xchg->scsi_cmnd_info.err_code_table_cout,
UNF_IO_PORT_LOGOUT);
if (xchg->io_state & INI_IO_STATE_UPABORT) {
/*
* About L_Port destroy or AC power down:
* UP_ABORT ---to--->>> ABORT_Port_Removing
*/
up_status = UNF_IO_ABORT_PORT_REMOVING;
}
xchg->scsi_cmnd_info.result = up_status;
up(&xchg->task_sema);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"[info]Free INI exchange(0x%p) state(0x%x) reference count(%d) start time(%llu)",
xchg, xchg->io_state, atomic_read(&xchg->ref_cnt),
xchg->alloc_jif);
unf_cm_free_xchg(xchg->lport, xchg);
/* go to next INI busy_list (exchange) node */
spin_lock_irqsave(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
}
spin_unlock_irqrestore(&v_xchg_mgr->hot_pool->xchg_hot_pool_lock,
hot_pool_lock_flags);
}
static void unf_free_all_big_sfs(struct unf_xchg_mgr_s *v_xchg_mgr)
{
struct unf_xchg_mgr_s *xchg_mgr = v_xchg_mgr;
struct unf_big_sfs_s *big_sfs = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
unsigned long flag = 0;
unsigned int buff_index;
UNF_CHECK_VALID(0x891, UNF_TRUE, xchg_mgr, return);
/* Release the free resources in the busy state */
spin_lock_irqsave(&xchg_mgr->st_big_sfs_pool.big_sfs_pool_lock, flag);
list_for_each_safe(node, next_node,
&xchg_mgr->st_big_sfs_pool.list_busy_pool) {
list_del(node);
list_add_tail(node, &xchg_mgr->st_big_sfs_pool.list_free_pool);
}
list_for_each_safe(node, next_node,
&xchg_mgr->st_big_sfs_pool.list_free_pool) {
list_del(node);
big_sfs = list_entry(node, struct unf_big_sfs_s,
entry_big_sfs);
if (big_sfs->vaddr)
big_sfs->vaddr = NULL;
}
spin_unlock_irqrestore(&xchg_mgr->st_big_sfs_pool.big_sfs_pool_lock,
flag);
if (xchg_mgr->big_sfs_buf_list.buflist) {
for (buff_index = 0;
buff_index < xchg_mgr->big_sfs_buf_list.buf_num;
buff_index++) {
if (xchg_mgr->big_sfs_buf_list.buflist[buff_index].vaddr) {
kfree(xchg_mgr->big_sfs_buf_list.buflist[buff_index].vaddr);
xchg_mgr->big_sfs_buf_list.buflist[buff_index].vaddr = NULL;
}
}
kfree(xchg_mgr->big_sfs_buf_list.buflist);
xchg_mgr->big_sfs_buf_list.buflist = NULL;
}
}
static void unf_free_big_sfs_pool(struct unf_xchg_mgr_s *v_xchg_mgr)
{
UNF_CHECK_VALID(0x892, UNF_TRUE, v_xchg_mgr, return);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_INFO,
"Free Big SFS Pool, Count(0x%x).",
v_xchg_mgr->st_big_sfs_pool.free_count);
unf_free_all_big_sfs(v_xchg_mgr);
v_xchg_mgr->st_big_sfs_pool.free_count = 0;
if (v_xchg_mgr->st_big_sfs_pool.big_sfs_pool) {
vfree(v_xchg_mgr->st_big_sfs_pool.big_sfs_pool);
v_xchg_mgr->st_big_sfs_pool.big_sfs_pool = NULL;
}
}
static void unf_free_xchg_mgr_mem(struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr)
{
struct unf_xchg_mgr_s *xchg_mgr = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned int i = 0;
unsigned int xchg_sum = 0;
struct unf_xchg_free_pool_s *free_pool = NULL;
UNF_CHECK_VALID(0x893, UNF_TRUE, v_xchg_mgr, return);
xchg_mgr = v_xchg_mgr;
/* Release the reserved Rsp IU Page */
unf_free_all_rsp_pages(xchg_mgr);
unf_free_big_sfs_pool(xchg_mgr);
/* The sfs is released first, and the XchgMgr is allocated
* by the get free page.
* Therefore, the XchgMgr is compared with the '0'
*/
if (xchg_mgr->sfs_mm_start != 0) {
dma_free_coherent(&v_lport->low_level_func.dev->dev,
xchg_mgr->sfs_mem_size,
xchg_mgr->sfs_mm_start,
xchg_mgr->sfs_phy_addr);
xchg_mgr->sfs_mm_start = 0;
}
/* Release Xchg first */
if (xchg_mgr->fcp_mm_start) {
unf_get_xchg_config_sum(v_lport, &xchg_sum);
xchg_sum = xchg_sum / UNF_EXCHG_MGR_NUM;
xchg = xchg_mgr->fcp_mm_start;
for (i = 0; i < xchg_sum; i++) {
if (!xchg)
break;
xchg++;
}
vfree(xchg_mgr->fcp_mm_start);
xchg_mgr->fcp_mm_start = NULL;
}
/* release the hot pool */
if (xchg_mgr->hot_pool) {
vfree(xchg_mgr->hot_pool);
xchg_mgr->hot_pool = NULL;
}
free_pool = &xchg_mgr->free_pool;
vfree(xchg_mgr);
UNF_REFERNCE_VAR(xchg_mgr);
UNF_REFERNCE_VAR(free_pool);
}
static void unf_free_xchg_mgr(struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr)
{
unsigned long flags = 0;
unsigned int ret = UNF_RETURN_ERROR;
UNF_CHECK_VALID(0x894, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x895, UNF_TRUE, v_xchg_mgr, return);
/* 1. At first, free exchanges for this Exch_Mgr */
ret = unf_free_lport_xchg(v_lport, v_xchg_mgr);
/* 2. Delete this Exch_Mgr entry */
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
list_del_init(&v_xchg_mgr->xchg_mgr_entry);
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
/* 3. free Exch_Mgr memory if necessary */
if (ret == RETURN_OK) {
/* free memory directly */
unf_free_xchg_mgr_mem(v_lport, v_xchg_mgr);
} else {
/* Add it to Dirty list */
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
list_add_tail(&v_xchg_mgr->xchg_mgr_entry,
&v_lport->list_dirty_xchg_mgr_head);
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
/* Mark dirty flag */
unf_cmmark_dirty_mem(v_lport,
UNF_LPORT_DIRTY_FLAG_XCHGMGR_DIRTY);
}
}
void unf_free_all_xchg_mgr(struct unf_lport_s *v_lport)
{
struct unf_xchg_mgr_s *xchg_mgr = NULL;
unsigned long flags = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x896, UNF_TRUE, v_lport, return);
/* for each L_Port->Exch_Mgr_List */
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
while (!list_empty(&v_lport->list_xchg_mgr_head)) {
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
xchg_mgr = unf_get_xchg_mgr_by_lport(v_lport, i);
unf_free_xchg_mgr(v_lport, xchg_mgr);
if (i < UNF_EXCHG_MGR_NUM)
v_lport->p_xchg_mgr[i] = NULL;
i++;
/* go to next */
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
}
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
v_lport->destroy_step = UNF_LPORT_DESTROY_STEP_4_DESTROY_EXCH_MGR;
}
static unsigned int unf_init_xchg_mgr(struct unf_xchg_mgr_s *v_xchg_mgr)
{
struct unf_xchg_mgr_s *xchg_mgr = NULL;
UNF_CHECK_VALID(0x897, UNF_TRUE, v_xchg_mgr, return UNF_RETURN_ERROR);
xchg_mgr = v_xchg_mgr;
memset(xchg_mgr, 0, sizeof(struct unf_xchg_mgr_s));
INIT_LIST_HEAD(&xchg_mgr->xchg_mgr_entry);
xchg_mgr->mgr_type = UNF_XCHG_MGR_FC;
xchg_mgr->min_xid = UNF_XCHG_MIN_XID;
xchg_mgr->max_xid = UNF_XCHG_MAX_XID;
xchg_mgr->fcp_mm_start = NULL;
xchg_mgr->mem_size = sizeof(struct unf_xchg_mgr_s);
return RETURN_OK;
}
static unsigned int unf_init_xchg_mgr_free_pool(
struct unf_xchg_mgr_s *v_xchg_mgr)
{
struct unf_xchg_free_pool_s *free_pool = NULL;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
UNF_CHECK_VALID(0x898, UNF_TRUE, v_xchg_mgr, return UNF_RETURN_ERROR);
xchg_mgr = v_xchg_mgr;
free_pool = &xchg_mgr->free_pool;
INIT_LIST_HEAD(&free_pool->list_free_xchg_list);
INIT_LIST_HEAD(&free_pool->list_sfs_xchg_list);
spin_lock_init(&free_pool->xchg_free_pool_lock);
free_pool->fcp_xchg_sum = 0;
free_pool->xchg_mgr_completion = NULL;
return RETURN_OK;
}
static unsigned int unf_init_xchg_hot_pool(
struct unf_lport_s *v_lport,
struct unf_xchg_hot_pool_s *v_hot_pool,
unsigned int v_xchg_sum)
{
struct unf_xchg_hot_pool_s *hot_pool = NULL;
UNF_CHECK_VALID(0x899, UNF_TRUE, v_hot_pool, return UNF_RETURN_ERROR);
hot_pool = v_hot_pool;
INIT_LIST_HEAD(&hot_pool->sfs_busylist);
INIT_LIST_HEAD(&hot_pool->ini_busylist);
spin_lock_init(&hot_pool->xchg_hot_pool_lock);
INIT_LIST_HEAD(&hot_pool->list_destroy_xchg);
hot_pool->total_xchges = 0;
hot_pool->total_res_cnt = 0;
hot_pool->wait_state = UNF_FALSE;
hot_pool->lport = v_lport;
/* Slab Pool Index */
hot_pool->slab_next_index = 0;
UNF_TOU16_CHECK(hot_pool->slab_total_sum, v_xchg_sum,
return UNF_RETURN_ERROR);
return RETURN_OK;
}
static unsigned int unf_alloc_and_init_big_sfs_pool(
struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr)
{
unsigned int i = 0;
unsigned int size = 0;
unsigned int align_size = 0;
unsigned int npiv_cnt = 0;
struct unf_big_sfs_pool_s *big_sfs_pool = NULL;
struct unf_big_sfs_s *big_sfs_buf = NULL;
unsigned int buf_total_size;
unsigned int buf_num;
unsigned int buf_cnt_perhugebuf;
unsigned int alloc_idx;
unsigned int curbuf_idx = 0;
unsigned int curbuf_offset = 0;
UNF_CHECK_VALID(0x900, UNF_TRUE, v_xchg_mgr, return UNF_RETURN_ERROR);
UNF_CHECK_VALID(0x901, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
big_sfs_pool = &v_xchg_mgr->st_big_sfs_pool;
INIT_LIST_HEAD(&big_sfs_pool->list_free_pool);
INIT_LIST_HEAD(&big_sfs_pool->list_busy_pool);
spin_lock_init(&big_sfs_pool->big_sfs_pool_lock);
npiv_cnt = v_lport->low_level_func.support_max_npiv_num;
/*
* The value*6 indicates GID_PT/GID_FT, RSCN, and ECHO
* Another command is received when a command is being responded
* A maximum of 20 resources are reserved for the RSCN.
* During the test, multiple rscn are found. As a result,
* the resources are insufficient and the disc fails.
*/
big_sfs_pool->free_count = (npiv_cnt + 1) * 6 + 20;
big_sfs_buf = (struct unf_big_sfs_s *)vmalloc(
big_sfs_pool->free_count
* sizeof(struct unf_big_sfs_s));
if (!big_sfs_buf) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_REG_ATT, UNF_ERR,
"Allocate Big SFS buf fail.");
return UNF_RETURN_ERROR;
}
memset(big_sfs_buf, 0, big_sfs_pool->free_count *
sizeof(struct unf_big_sfs_s));
v_xchg_mgr->mem_size +=
(unsigned int)
(big_sfs_pool->free_count * sizeof(struct unf_big_sfs_s));
big_sfs_pool->big_sfs_pool = (void *)big_sfs_buf;
/*
* Use the larger value of sizeof (struct unf_gif_acc_pld_s) and
* sizeof (struct unf_rscn_pld_s) to avoid the icp error.Therefore,
* the value is directly assigned instead of being compared.
*/
size = sizeof(struct unf_gif_acc_pld_s);
align_size = ALIGN(size, PAGE_SIZE);
buf_total_size = align_size * big_sfs_pool->free_count;
v_xchg_mgr->big_sfs_buf_list.buf_size =
buf_total_size > BUF_LIST_PAGE_SIZE ?
BUF_LIST_PAGE_SIZE : buf_total_size;
buf_cnt_perhugebuf =
v_xchg_mgr->big_sfs_buf_list.buf_size / align_size;
buf_num =
big_sfs_pool->free_count % buf_cnt_perhugebuf ?
big_sfs_pool->free_count / buf_cnt_perhugebuf + 1 :
big_sfs_pool->free_count / buf_cnt_perhugebuf;
v_xchg_mgr->big_sfs_buf_list.buflist =
(struct buff_list_s *)kmalloc(
buf_num * sizeof(struct buff_list_s),
GFP_KERNEL);
v_xchg_mgr->big_sfs_buf_list.buf_num = buf_num;
if (!v_xchg_mgr->big_sfs_buf_list.buflist) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_REG_ATT, UNF_WARN,
"[err]Allocate BigSfs pool buf list failed out of memory");
goto free_buff;
}
memset(v_xchg_mgr->big_sfs_buf_list.buflist, 0, buf_num *
sizeof(struct buff_list_s));
for (alloc_idx = 0; alloc_idx < buf_num; alloc_idx++) {
v_xchg_mgr->big_sfs_buf_list.buflist[alloc_idx].vaddr =
kmalloc(v_xchg_mgr->big_sfs_buf_list.buf_size,
GFP_ATOMIC);
if (!v_xchg_mgr->big_sfs_buf_list.buflist[alloc_idx].vaddr)
goto free_buff;
memset(v_xchg_mgr->big_sfs_buf_list.buflist[alloc_idx].vaddr,
0, v_xchg_mgr->big_sfs_buf_list.buf_size);
}
for (i = 0; i < big_sfs_pool->free_count; i++) {
if ((i != 0) && !(i % buf_cnt_perhugebuf))
curbuf_idx++;
curbuf_offset = align_size * (i % buf_cnt_perhugebuf);
big_sfs_buf->vaddr =
v_xchg_mgr->big_sfs_buf_list.buflist[curbuf_idx].vaddr +
curbuf_offset;
big_sfs_buf->size = size;
v_xchg_mgr->mem_size += size;
list_add_tail(&big_sfs_buf->entry_big_sfs,
&big_sfs_pool->list_free_pool);
big_sfs_buf++;
}
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"[EVENT]Allocate BigSfs pool size:%d,uiAlignSize:%d,buf_num:%d,buf_size:%d",
size, align_size, v_xchg_mgr->big_sfs_buf_list.buf_num,
v_xchg_mgr->big_sfs_buf_list.buf_size);
return RETURN_OK;
free_buff:
unf_free_all_big_sfs(v_xchg_mgr);
vfree(big_sfs_buf);
big_sfs_pool->big_sfs_pool = NULL;
return UNF_RETURN_ERROR;
}
/*
* Function Name : unf_free_one_big_sfs
* Function Description: Put the big sfs memory in xchg back to bigsfspool
* Input Parameters : struct unf_xchg_s * v_xchg
* Output Parameters : N/A
* Return Type : static void
*/
static void unf_free_one_big_sfs(struct unf_xchg_s *v_xchg)
{
unsigned long flag = 0;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
UNF_CHECK_VALID(0x902, UNF_TRUE, v_xchg, return);
xchg_mgr = v_xchg->xchg_mgr;
UNF_CHECK_VALID(0x903, UNF_TRUE, xchg_mgr, return);
if (!v_xchg->big_sfs_buf)
return;
if ((v_xchg->cmnd_code != NS_GID_PT) &&
(v_xchg->cmnd_code != NS_GID_FT) &&
(v_xchg->cmnd_code != ELS_ECHO) &&
(UNF_SET_ELS_ACC_TYPE(ELS_ECHO) != v_xchg->cmnd_code) &&
(v_xchg->cmnd_code != ELS_RSCN) &&
(UNF_SET_ELS_ACC_TYPE(ELS_RSCN) != v_xchg->cmnd_code)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
UNF_MAJOR,
"Exchange(0x%p), Command(0x%x) big SFS buf is not NULL.",
v_xchg, v_xchg->cmnd_code);
}
spin_lock_irqsave(&xchg_mgr->st_big_sfs_pool.big_sfs_pool_lock, flag);
list_del(&v_xchg->big_sfs_buf->entry_big_sfs);
list_add_tail(&v_xchg->big_sfs_buf->entry_big_sfs,
&xchg_mgr->st_big_sfs_pool.list_free_pool);
xchg_mgr->st_big_sfs_pool.free_count++;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
"Free one big SFS buf(0x%p), Count(0x%x), Exchange(0x%p), Command(0x%x).",
v_xchg->big_sfs_buf->vaddr,
xchg_mgr->st_big_sfs_pool.free_count,
v_xchg, v_xchg->cmnd_code);
spin_unlock_irqrestore(&xchg_mgr->st_big_sfs_pool.big_sfs_pool_lock,
flag);
}
static void unf_free_exchg_mgr_info(struct unf_lport_s *v_lport)
{
unsigned int i;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
unsigned long flags = 0;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
list_for_each_safe(node, next_node, &v_lport->list_xchg_mgr_head) {
list_del(node);
xchg_mgr = list_entry(node, struct unf_xchg_mgr_s,
xchg_mgr_entry);
}
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
xchg_mgr = v_lport->p_xchg_mgr[i];
if (xchg_mgr) {
unf_free_big_sfs_pool(xchg_mgr);
unf_free_all_rsp_pages(xchg_mgr);
if (xchg_mgr->sfs_mm_start) {
dma_free_coherent(
&v_lport->low_level_func.dev->dev,
xchg_mgr->sfs_mem_size,
xchg_mgr->sfs_mm_start,
xchg_mgr->sfs_phy_addr);
xchg_mgr->sfs_mm_start = 0;
}
if (xchg_mgr->fcp_mm_start) {
vfree(xchg_mgr->fcp_mm_start);
xchg_mgr->fcp_mm_start = NULL;
}
if (xchg_mgr->hot_pool) {
vfree(xchg_mgr->hot_pool);
xchg_mgr->hot_pool = NULL;
}
vfree(xchg_mgr);
v_lport->p_xchg_mgr[i] = NULL;
}
}
}
static unsigned int unf_alloc_and_init_xchg_mgr(struct unf_lport_s *v_lport)
{
struct unf_xchg_mgr_s *xchg_mgr = NULL;
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct unf_xchg_s *xchg_mem = NULL;
void *sfs_mm_start = 0;
dma_addr_t sfs_phy_addr = 0;
unsigned int xchg_sum = 0;
unsigned int sfs_xchg_sum = 0;
unsigned long flags = 0;
unsigned int order = 0;
unsigned int ret = UNF_RETURN_ERROR;
unsigned int slab_num = 0;
unsigned int i = 0;
UNF_REFERNCE_VAR(order);
/* SFS_EXCH + I/O_EXCH */
ret = unf_get_xchg_config_sum(v_lport, &xchg_sum);
if (ret != RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"Port(0x%x) can't get Exchange.",
v_lport->port_id);
return UNF_RETURN_ERROR;
}
/* SFS Exchange Sum */
sfs_xchg_sum = v_lport->low_level_func.lport_cfg_items.max_sfs_xchg /
UNF_EXCHG_MGR_NUM;
xchg_sum = xchg_sum / UNF_EXCHG_MGR_NUM;
slab_num = v_lport->low_level_func.support_max_xid_range /
UNF_EXCHG_MGR_NUM;
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
/* Alloc Exchange Manager */
xchg_mgr = (struct unf_xchg_mgr_s *)
vmalloc(sizeof(struct unf_xchg_mgr_s));
if (!xchg_mgr) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR,
UNF_LOG_REG_ATT, UNF_ERR,
"Port(0x%x) allocate Exchange Manager Memory Fail.",
v_lport->port_id);
goto exit;
}
/* Init Exchange Manager */
ret = unf_init_xchg_mgr(xchg_mgr);
if (ret != RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_REG_ATT, UNF_MAJOR,
"Port(0x%x) initialization Exchange Manager unsuccessful.",
v_lport->port_id);
goto free_xchg_mgr;
}
/* Initialize the Exchange Free Pool resource */
ret = unf_init_xchg_mgr_free_pool(xchg_mgr);
if (ret != RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_REG_ATT, UNF_MAJOR,
"Port(0x%x) initialization Exchange Manager Free Pool unsuccessful.",
v_lport->port_id);
goto free_xchg_mgr;
}
/* Allocate memory for Hot Pool and Xchg slab */
hot_pool = vmalloc(sizeof(struct unf_xchg_hot_pool_s) +
sizeof(struct unf_xchg_s *) * slab_num);
if (!hot_pool) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR,
UNF_LOG_REG_ATT, UNF_ERR,
"Port(0x%x) allocate Hot Pool Memory Fail.",
v_lport->port_id);
goto free_xchg_mgr;
}
memset(hot_pool, 0,
sizeof(struct unf_xchg_hot_pool_s) +
sizeof(struct unf_xchg_s *) * slab_num);
xchg_mgr->mem_size +=
(unsigned int)(sizeof(struct unf_xchg_hot_pool_s) +
sizeof(struct unf_xchg_s *) * slab_num);
/* Initialize the Exchange Hot Pool resource */
ret = unf_init_xchg_hot_pool(v_lport, hot_pool, slab_num);
if (ret != RETURN_OK)
goto free_hot_pool;
hot_pool->base += (unsigned short)(i * slab_num);
/* Allocate the memory of all Xchg (IO/SFS) */
xchg_mem = vmalloc(sizeof(struct unf_xchg_s) * xchg_sum);
if (!xchg_mem) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR,
UNF_LOG_REG_ATT, UNF_ERR,
"Port(0x%x) allocate Exchange Memory Fail.",
v_lport->port_id);
goto free_hot_pool;
}
memset(xchg_mem, 0, sizeof(struct unf_xchg_s) * xchg_sum);
xchg_mgr->mem_size +=
(unsigned int)(sizeof(struct unf_xchg_s) * xchg_sum);
xchg_mgr->hot_pool = hot_pool;
xchg_mgr->fcp_mm_start = xchg_mem;
/* Allocate the memory used by the SFS Xchg
* to carry the ELS/BLS/GS command and response
*/
xchg_mgr->sfs_mem_size =
(unsigned int)(sizeof(union unf_sfs_u) * sfs_xchg_sum);
/* Apply for the DMA space for sending sfs frames.
* If the value of DMA32 is less than 4 GB,
* cross-4G problems will not occur
*/
order = (unsigned int)get_order(xchg_mgr->sfs_mem_size);
sfs_mm_start = dma_alloc_coherent(
&v_lport->low_level_func.dev->dev,
xchg_mgr->sfs_mem_size,
&sfs_phy_addr, GFP_KERNEL);
if (!sfs_mm_start) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR,
UNF_LOG_REG_ATT, UNF_ERR,
"Port(0x%x) Get Free Pagers Fail, Order(%u).",
v_lport->port_id, order);
goto free_xchg_mem;
}
memset(sfs_mm_start, 0, sizeof(union unf_sfs_u) * sfs_xchg_sum);
xchg_mgr->mem_size += xchg_mgr->sfs_mem_size;
xchg_mgr->sfs_mm_start = sfs_mm_start;
xchg_mgr->sfs_phy_addr = sfs_phy_addr;
/* The Xchg is initialized and mounted to the Free Pool */
ret = unf_init_xchg(v_lport, xchg_mgr, xchg_sum, sfs_xchg_sum);
if (ret != RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_REG_ATT, UNF_MAJOR,
"Port(0x%x) initialization Exchange unsuccessful, Exchange Number(%u), SFS Exchange number(%u).",
v_lport->port_id, xchg_sum, sfs_xchg_sum);
dma_free_coherent(&v_lport->low_level_func.dev->dev,
xchg_mgr->sfs_mem_size,
xchg_mgr->sfs_mm_start,
xchg_mgr->sfs_phy_addr);
xchg_mgr->sfs_mm_start = 0;
goto free_xchg_mem;
}
/* Apply for the memory used by GID_PT, GID_FT, and RSCN */
ret = unf_alloc_and_init_big_sfs_pool(v_lport, xchg_mgr);
if (ret != RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR,
UNF_LOG_REG_ATT, UNF_ERR,
"Port(0x%x) allocate big SFS fail",
v_lport->port_id);
unf_free_all_rsp_pages(xchg_mgr);
dma_free_coherent(&v_lport->low_level_func.dev->dev,
xchg_mgr->sfs_mem_size,
xchg_mgr->sfs_mm_start,
xchg_mgr->sfs_phy_addr);
xchg_mgr->sfs_mm_start = 0;
goto free_xchg_mem;
}
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
v_lport->p_xchg_mgr[i] = (void *)xchg_mgr;
list_add_tail(&xchg_mgr->xchg_mgr_entry,
&v_lport->list_xchg_mgr_head);
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"[info]Port(0x%x) ExchangeMgr:(0x%p),Base:(0x%x).",
v_lport->port_id, v_lport->p_xchg_mgr[i],
hot_pool->base);
}
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_INFO,
"Port(0x%x) allocate Exchange Manager size(0x%x).",
v_lport->port_id, xchg_mgr->mem_size);
return RETURN_OK;
free_xchg_mem:
vfree(xchg_mem);
free_hot_pool:
vfree(hot_pool);
free_xchg_mgr:
vfree(xchg_mgr);
exit:
unf_free_exchg_mgr_info(v_lport);
return UNF_RETURN_ERROR;
}
void unf_xchg_mgr_destroy(struct unf_lport_s *v_lport)
{
UNF_CHECK_VALID(0x905, UNF_TRUE, v_lport, return);
unf_free_all_xchg_mgr(v_lport);
}
unsigned int unf_alloc_xchg_resource(struct unf_lport_s *v_lport)
{
UNF_CHECK_VALID(0x906, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
INIT_LIST_HEAD(&v_lport->list_dirty_xchg_mgr_head);
INIT_LIST_HEAD(&v_lport->list_xchg_mgr_head);
spin_lock_init(&v_lport->xchg_mgr_lock);
/* LPort Xchg Management Unit Allocation */
if (unf_alloc_and_init_xchg_mgr(v_lport) != RETURN_OK)
return UNF_RETURN_ERROR;
return RETURN_OK;
}
void unf_destroy_dirty_xchg(struct unf_lport_s *v_lport, int v_show_only)
{
unsigned int dirty_xchg = 0;
struct unf_xchg_mgr_s *exch_mgr = NULL;
unsigned long flags = 0;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
UNF_CHECK_VALID(0x908, UNF_TRUE, v_lport, return);
if (v_lport->dirty_flag & UNF_LPORT_DIRTY_FLAG_XCHGMGR_DIRTY) {
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
list_for_each_safe(node, next_node,
&v_lport->list_dirty_xchg_mgr_head) {
exch_mgr = list_entry(node, struct unf_xchg_mgr_s,
xchg_mgr_entry);
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
if (exch_mgr) {
dirty_xchg =
(exch_mgr->free_pool.total_fcp_xchg +
exch_mgr->free_pool.total_sfs_xchg);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_REG_ATT, UNF_MAJOR,
"[info]Port(0x%x) has %u dirty exchange(s)",
v_lport->port_id, dirty_xchg);
unf_show_all_xchg(v_lport, exch_mgr);
if (v_show_only == UNF_FALSE) {
/* Delete Dirty Exchange Mgr entry */
spin_lock_irqsave(
&v_lport->xchg_mgr_lock,
flags);
list_del_init(
&exch_mgr->xchg_mgr_entry);
spin_unlock_irqrestore(
&v_lport->xchg_mgr_lock,
flags);
/* Free Dirty Exchange Mgr memory */
unf_free_xchg_mgr_mem(v_lport,
exch_mgr);
}
}
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
}
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
}
UNF_REFERNCE_VAR(dirty_xchg);
}
struct unf_xchg_mgr_s *unf_get_xchg_mgr_by_lport(struct unf_lport_s *v_lport,
unsigned int v_idx)
{
struct unf_xchg_mgr_s *xchg_mgr = NULL;
unsigned long flags = 0;
UNF_CHECK_VALID(0x909, UNF_TRUE, v_lport, return NULL);
UNF_CHECK_VALID(0x910, UNF_TRUE, v_idx < UNF_EXCHG_MGR_NUM,
return NULL);
spin_lock_irqsave(&v_lport->xchg_mgr_lock, flags);
xchg_mgr = v_lport->p_xchg_mgr[v_idx];
spin_unlock_irqrestore(&v_lport->xchg_mgr_lock, flags);
return xchg_mgr;
}
struct unf_xchg_hot_pool_s *unf_get_hot_pool_by_lport(
struct unf_lport_s *v_lport,
unsigned int v_mgr_idx)
{
struct unf_xchg_mgr_s *xchg_mgr = NULL;
struct unf_lport_s *lport = NULL;
UNF_CHECK_VALID(0x910, UNF_TRUE, (v_lport), return NULL);
lport = (struct unf_lport_s *)(v_lport->root_lport);
UNF_CHECK_VALID(0x910, UNF_TRUE, (lport), return NULL);
/* Get Xchg Manager */
xchg_mgr = unf_get_xchg_mgr_by_lport(lport, v_mgr_idx);
if (!xchg_mgr) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"Port(0x%x) Exchange Manager is NULL.",
lport->port_id);
return NULL;
}
/* Get Xchg Manager Hot Pool */
return xchg_mgr->hot_pool;
}
static inline void unf_hot_pool_slab_set(
struct unf_xchg_hot_pool_s *v_hot_pool,
unsigned short v_slab_index,
struct unf_xchg_s *v_xchg)
{
UNF_CHECK_VALID(0x911, UNF_TRUE, v_hot_pool, return);
v_hot_pool->xchg_slab[v_slab_index] = v_xchg;
}
static inline struct unf_xchg_s *unf_get_xchg_by_xchg_tag(
struct unf_xchg_hot_pool_s *v_hot_pool,
unsigned short v_slab_index)
{
UNF_CHECK_VALID(0x912, UNF_TRUE, v_hot_pool, return NULL);
return v_hot_pool->xchg_slab[v_slab_index];
}
static void *unf_lookup_xchg_by_tag(void *v_lport,
unsigned short v_hot_pool_tag)
{
struct unf_lport_s *lport = NULL;
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long flags = 0;
unsigned int exchg_mgr_idx = 0;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
UNF_CHECK_VALID(0x913, UNF_TRUE, v_lport, return NULL);
/* In the case of NPIV, v_pstLport is the Vport pointer,
* the share uses the ExchMgr of RootLport
*/
lport = ((struct unf_lport_s *)v_lport)->root_lport;
UNF_CHECK_VALID(0x914, UNF_TRUE, lport, return NULL);
exchg_mgr_idx = (v_hot_pool_tag * UNF_EXCHG_MGR_NUM) /
lport->low_level_func.support_max_xid_range;
if (unlikely(exchg_mgr_idx >= UNF_EXCHG_MGR_NUM)) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Port(0x%x) Get ExchgMgr %u err",
lport->port_id, exchg_mgr_idx);
return NULL;
}
xchg_mgr = lport->p_xchg_mgr[exchg_mgr_idx];
if (unlikely(!xchg_mgr)) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Port(0x%x) ExchgMgr %u is null",
lport->port_id, exchg_mgr_idx);
return NULL;
}
hot_pool = xchg_mgr->hot_pool;
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"Port(0x%x) Hot Pool is NULL.", lport->port_id);
return NULL;
}
if (unlikely(v_hot_pool_tag >=
(hot_pool->slab_total_sum + hot_pool->base))) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]LPort(0x%x) can't Input Tag(0x%x), Max(0x%x).",
lport->port_id, v_hot_pool_tag,
(hot_pool->slab_total_sum + hot_pool->base));
return NULL;
}
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
xchg = unf_get_xchg_by_xchg_tag(hot_pool,
v_hot_pool_tag - hot_pool->base);
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
return (void *)xchg;
}
static void *unf_find_xchg_by_oxid(void *v_lport, unsigned short v_oxid,
unsigned int v_oid)
{
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct unf_xchg_s *xchg = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
struct unf_lport_s *lport = NULL;
unsigned long flags = 0;
unsigned long xchg_flags = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x915, UNF_TRUE, (v_lport), return NULL);
/* In the case of NPIV, the v_lport is the Vport pointer,
* and the share uses the ExchMgr of the RootLport
*/
lport = ((struct unf_lport_s *)v_lport)->root_lport;
UNF_CHECK_VALID(0x916, UNF_TRUE, (lport), return NULL);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_INFO,
UNF_LOG_IO_ATT, UNF_MAJOR,
"Port(0x%x) MgrIdex %u Hot Pool is NULL.",
lport->port_id, i);
continue;
}
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
/* 1. Traverse sfs_busy list */
list_for_each_safe(node, next_node, &hot_pool->sfs_busylist) {
xchg = list_entry(node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock, xchg_flags);
if (UNF_CHECK_OXID_MATCHED(v_oxid, v_oid, xchg)) {
atomic_inc(&xchg->ref_cnt);
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_flags);
spin_unlock_irqrestore(
&hot_pool->xchg_hot_pool_lock, flags);
return xchg;
}
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_flags);
}
/* 2. Traverse INI_Busy List */
list_for_each_safe(node, next_node, &hot_pool->ini_busylist) {
xchg = list_entry(node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock, xchg_flags);
if (UNF_CHECK_OXID_MATCHED(v_oxid, v_oid, xchg)) {
atomic_inc(&xchg->ref_cnt);
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_flags);
spin_unlock_irqrestore(
&hot_pool->xchg_hot_pool_lock, flags);
return xchg;
}
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_flags);
}
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
}
return NULL;
}
static inline int unf_check_xchg_matched(struct unf_xchg_s *xchg,
unsigned long long v_command_sn,
unsigned int v_world_id)
{
int matched = 0;
matched = (v_command_sn == xchg->cmnd_sn);
if (matched && (atomic_read(&xchg->ref_cnt) > 0))
return UNF_TRUE;
else
return UNF_FALSE;
}
static void *unf_lookup_xchg_by_cmnd_sn(void *v_lport,
unsigned long long v_command_sn,
unsigned int v_world_id)
{
struct unf_lport_s *lport = NULL;
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long flags = 0;
unsigned int i;
UNF_CHECK_VALID(0x919, UNF_TRUE, v_lport, return NULL);
/* In NPIV, v_lport is a Vport pointer, and idle resources are
* shared by ExchMgr of RootLport.
* However, busy resources are mounted on each vport.
* Therefore, vport needs to be used.
*/
lport = (struct unf_lport_s *)v_lport;
UNF_CHECK_VALID(0x920, UNF_TRUE, lport, return NULL);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Port(0x%x) hot pool is NULL",
lport->port_id);
continue;
}
/* from busy_list */
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
list_for_each_safe(node, next_node, &hot_pool->ini_busylist) {
xchg = list_entry(node, struct unf_xchg_s,
list_xchg_entry);
if (unf_check_xchg_matched(xchg, v_command_sn,
v_world_id)) {
spin_unlock_irqrestore(
&hot_pool->xchg_hot_pool_lock, flags);
return xchg;
}
}
/* vport: from destroy_list */
if (lport != lport->root_lport) {
list_for_each_safe(node, next_node,
&hot_pool->list_destroy_xchg) {
xchg = list_entry(node, struct unf_xchg_s,
list_xchg_entry);
if (unf_check_xchg_matched(xchg, v_command_sn,
v_world_id)) {
spin_unlock_irqrestore(
&hot_pool->xchg_hot_pool_lock,
flags);
UNF_TRACE(UNF_EVTLOG_IO_INFO,
UNF_LOG_IO_ATT, UNF_MAJOR,
"[info]Port(0x%x) lookup exchange from destroy list",
lport->port_id);
return xchg;
}
}
}
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
}
return NULL;
}
static inline unsigned int unf_alloc_hot_pool_slab(
struct unf_xchg_hot_pool_s *v_hot_pool,
struct unf_xchg_s *v_xchg,
unsigned short v_rx_id)
{
unsigned short slab_index = 0;
UNF_CHECK_VALID(0x921, UNF_TRUE, v_hot_pool, return UNF_RETURN_ERROR);
UNF_CHECK_VALID(0x922, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
/* Check whether the hotpool tag is in the specified range sirt.
* If yes, set up the management relationship. If no,
* handle the problem according to the normal IO.
* If the sirt digitmap is used but the tag is occupied,
* it indicates that the I/O is discarded.
*/
v_hot_pool->slab_next_index =
(unsigned short)v_hot_pool->slab_next_index;
slab_index = v_hot_pool->slab_next_index;
while (unf_get_xchg_by_xchg_tag(v_hot_pool, slab_index)) {
slab_index++;
slab_index = slab_index % v_hot_pool->slab_total_sum;
/* Rewind occurs */
if (slab_index == v_hot_pool->slab_next_index) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_EQUIP_ATT, UNF_MAJOR,
"There is No Slab At Hot Pool(0x%p) for xchg(0x%p).",
v_hot_pool, v_xchg);
return UNF_RETURN_ERROR;
}
}
unf_hot_pool_slab_set(v_hot_pool, slab_index, v_xchg);
v_xchg->hot_pool_tag = slab_index + v_hot_pool->base;
slab_index++;
v_hot_pool->slab_next_index =
slab_index % v_hot_pool->slab_total_sum;
return RETURN_OK;
}
struct unf_esgl_page_s *unf_get_one_free_esgl_page(struct unf_lport_s *v_lport,
struct unf_xchg_s *v_xchg)
{
struct unf_lport_s *lport = NULL;
struct unf_esgl_s *esgl = NULL;
struct unf_xchg_s *xchg = NULL;
struct list_head *list_head = NULL;
unsigned long flag = 0;
UNF_CHECK_VALID(0x923, UNF_TRUE, v_lport, return NULL);
UNF_CHECK_VALID(0x924, UNF_TRUE, v_xchg, return NULL);
lport = v_lport;
xchg = v_xchg;
/* Obtain a new Esgl from the EsglPool and
* add it to the list_esgls of the Xchg
*/
spin_lock_irqsave(&lport->esgl_pool.esgl_pool_lock, flag);
if (!list_empty(&lport->esgl_pool.list_esgl_pool)) {
list_head = (&lport->esgl_pool.list_esgl_pool)->next;
list_del(list_head);
lport->esgl_pool.esgl_pool_count--;
list_add_tail(list_head, &xchg->list_esgls);
esgl = list_entry(list_head, struct unf_esgl_s, entry_esgl);
atomic_inc(&xchg->esgl_cnt);
spin_unlock_irqrestore(&lport->esgl_pool.esgl_pool_lock, flag);
} else {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) esgl pool is empty",
lport->nport_id);
spin_unlock_irqrestore(&lport->esgl_pool.esgl_pool_lock, flag);
return NULL;
}
return &esgl->page;
}
void unf_release_esgls(struct unf_xchg_s *v_xchg)
{
struct unf_lport_s *lport = NULL;
struct list_head *list = NULL;
struct list_head *list_tmp = NULL;
unsigned long flag = 0;
UNF_CHECK_VALID(0x925, UNF_TRUE, v_xchg, return);
UNF_CHECK_VALID(0x926, UNF_TRUE, v_xchg->lport, return);
if (atomic_read(&v_xchg->esgl_cnt) <= 0)
return;
/* In the case of NPIV, the Vport pointer is saved in v_pstExch,
* and the EsglPool of RootLport is shared.
*/
lport = (v_xchg->lport)->root_lport;
UNF_CHECK_VALID(0x927, UNF_TRUE, (lport), return);
spin_lock_irqsave(&lport->esgl_pool.esgl_pool_lock, flag);
if (!list_empty(&v_xchg->list_esgls)) {
list_for_each_safe(list, list_tmp, &v_xchg->list_esgls) {
list_del(list);
list_add_tail(list, &lport->esgl_pool.list_esgl_pool);
lport->esgl_pool.esgl_pool_count++;
atomic_dec(&v_xchg->esgl_cnt);
}
}
spin_unlock_irqrestore(&lport->esgl_pool.esgl_pool_lock, flag);
}
static void unf_init_xchg_attribute(struct unf_xchg_s *v_xchg)
{
unsigned long flags = 0;
UNF_CHECK_VALID(0x973, UNF_TRUE, (v_xchg), return);
spin_lock_irqsave(&v_xchg->xchg_state_lock, flags);
v_xchg->xchg_mgr = NULL;
v_xchg->free_pool = NULL;
v_xchg->hot_pool = NULL;
v_xchg->lport = NULL;
v_xchg->rport = NULL;
v_xchg->disc_rport = NULL;
v_xchg->io_state = UNF_IO_STATE_NEW;
v_xchg->io_send_stage = TGT_IO_SEND_STAGE_NONE;
v_xchg->io_send_result = TGT_IO_SEND_RESULT_INVALID;
v_xchg->io_send_abort = UNF_FALSE;
v_xchg->io_abort_result = UNF_FALSE;
v_xchg->abts_state = 0;
v_xchg->ox_id = INVALID_VALUE16;
v_xchg->abort_oxid = INVALID_VALUE16;
v_xchg->rx_id = INVALID_VALUE16;
v_xchg->sid = INVALID_VALUE32;
v_xchg->did = INVALID_VALUE32;
v_xchg->oid = INVALID_VALUE32;
v_xchg->disc_port_id = INVALID_VALUE32;
v_xchg->seq_id = INVALID_VALUE8;
v_xchg->cmnd_code = INVALID_VALUE32;
v_xchg->cmnd_sn = INVALID_VALUE64;
v_xchg->data_len = 0;
v_xchg->resid_len = 0;
v_xchg->data_direction = DMA_NONE;
v_xchg->hot_pool_tag = INVALID_VALUE16;
v_xchg->big_sfs_buf = NULL;
v_xchg->may_consume_res_cnt = 0;
v_xchg->fact_consume_res_cnt = 0;
v_xchg->io_front_jif = INVALID_VALUE64;
v_xchg->ob_callback_sts = UNF_IO_SUCCESS;
v_xchg->start_jif = 0;
v_xchg->rport_bind_jifs = INVALID_VALUE64;
v_xchg->scsi_id = INVALID_VALUE32;
v_xchg->world_id = INVALID_VALUE32;
memset(&v_xchg->seq, 0, sizeof(struct unf_seq_s));
memset(&v_xchg->fcp_cmnd, 0, sizeof(struct unf_fcp_cmnd_s));
memset(&v_xchg->scsi_cmnd_info, 0, sizeof(struct unf_scsi_cmd_info_s));
memset(&v_xchg->abts_rsps, 0, sizeof(struct unf_abts_rsps_s));
memset(&v_xchg->dif_info, 0, sizeof(struct dif_info_s));
memset(v_xchg->private, 0,
(PKG_MAX_PRIVATE_DATA_SIZE * sizeof(unsigned int)));
v_xchg->echo_info.echo_result = UNF_ELS_ECHO_RESULT_OK;
v_xchg->echo_info.response_time = 0;
if (v_xchg->xchg_type == UNF_XCHG_TYPE_INI) {
if (v_xchg->fcp_sfs_union.fcp_rsp_entry.fcp_rsp_iu)
memset(v_xchg->fcp_sfs_union.fcp_rsp_entry.fcp_rsp_iu,
0, sizeof(struct unf_fcprsp_iu_s));
} else if (v_xchg->xchg_type == UNF_XCHG_TYPE_SFS) {
if (v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr) {
memset(v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr,
0, sizeof(union unf_sfs_u));
v_xchg->fcp_sfs_union.sfs_entry.cur_offset = 0;
}
} else {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"Exchange Type(0x%x) SFS Union uninited.",
v_xchg->xchg_type);
}
v_xchg->xchg_type = UNF_XCHG_TYPE_INVALID;
v_xchg->pfn_ob_callback = NULL;
v_xchg->pfn_callback = NULL;
v_xchg->pfn_free_xchg = NULL;
atomic_set(&v_xchg->ref_cnt, 0);
atomic_set(&v_xchg->esgl_cnt, 0);
atomic_set(&v_xchg->delay_flag, 0);
if (delayed_work_pending(&v_xchg->timeout_work))
UNF_DEL_XCHG_TIMER_SAFE(v_xchg);
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flags);
}
static void unf_add_back_to_fcp_list(
struct unf_xchg_free_pool_s *v_free_pool,
struct unf_xchg_s *v_xchg)
{
unsigned long flags = 0;
UNF_CHECK_VALID(0x928, UNF_TRUE, v_free_pool, return);
UNF_CHECK_VALID(0x929, UNF_TRUE, v_xchg, return);
unf_init_xchg_attribute(v_xchg);
/* The released I/O resources are added to
* the queue tail to facilitate fault locating
*/
spin_lock_irqsave(&v_free_pool->xchg_free_pool_lock, flags);
list_add_tail(&v_xchg->list_xchg_entry,
&v_free_pool->list_free_xchg_list);
v_free_pool->total_fcp_xchg++;
spin_unlock_irqrestore(&v_free_pool->xchg_free_pool_lock, flags);
}
static void unf_check_xchg_mgr_status(struct unf_xchg_mgr_s *v_xchg_mgr)
{
unsigned long flags = 0;
unsigned int total_xchg = 0;
unsigned int total_xchg_sum = 0;
UNF_CHECK_VALID(0x930, UNF_TRUE, v_xchg_mgr, return);
spin_lock_irqsave(&v_xchg_mgr->free_pool.xchg_free_pool_lock, flags);
total_xchg = v_xchg_mgr->free_pool.total_fcp_xchg +
v_xchg_mgr->free_pool.total_sfs_xchg;
total_xchg_sum = v_xchg_mgr->free_pool.fcp_xchg_sum +
v_xchg_mgr->free_pool.sfs_xchg_sum;
if ((v_xchg_mgr->free_pool.xchg_mgr_completion) &&
(total_xchg == total_xchg_sum)) {
complete(v_xchg_mgr->free_pool.xchg_mgr_completion);
}
spin_unlock_irqrestore(&v_xchg_mgr->free_pool.xchg_free_pool_lock,
flags);
}
static void unf_free_fcp_xchg(struct unf_xchg_s *v_xchg)
{
struct unf_xchg_free_pool_s *free_pool = NULL;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
UNF_CHECK_VALID(0x932, UNF_TRUE, v_xchg, return);
/* Releasing a Specified INI I/O and Invoking the scsi_done Process */
unf_done_ini_xchg(v_xchg);
free_pool = v_xchg->free_pool;
xchg_mgr = v_xchg->xchg_mgr;
lport = v_xchg->lport;
rport = v_xchg->rport;
atomic_dec(&rport->pending_io_cnt);
/* Release the Esgls in the Xchg structure and
* return it to the EsglPool of the Lport
*/
unf_release_esgls(v_xchg);
/* Mount I/O resources to the FCP Free linked list */
unf_add_back_to_fcp_list(free_pool, v_xchg);
/* The Xchg is released synchronously and then forcibly released to
* prevent the Xchg from accessing the Xchg in the normal I/O process
*/
if (unlikely(lport->b_port_removing == UNF_TRUE))
unf_check_xchg_mgr_status(xchg_mgr);
}
static void unf_fc_abort_timeout_cmnd(struct unf_lport_s *v_lport,
struct unf_xchg_s *v_xchg)
{
struct unf_lport_s *lport = v_lport;
struct unf_xchg_s *xchg = v_xchg;
struct unf_scsi_cmd_s scsi_cmnd = { 0 };
unsigned long flag = 0;
unsigned int timeout_value = 2000;
unsigned int return_value = 0;
struct unf_rport_scsi_id_image_s *scsi_image_table = NULL;
UNF_CHECK_VALID(0x936, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x937, UNF_TRUE, v_xchg, return);
spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
if (v_xchg->io_state & INI_IO_STATE_UPABORT) {
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"LPort(0x%x) xchange(0x%p) OX_ID(0x%x), RX_ID(0x%x) Cmdsn(0x%lx) has been aborted.",
lport->port_id, v_xchg, v_xchg->ox_id,
v_xchg->rx_id, (unsigned long)v_xchg->cmnd_sn);
return;
}
v_xchg->io_state |= INI_IO_STATE_UPABORT;
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_NORMAL, UNF_KEVENT,
"LPort(0x%x) exchg(0x%p) OX_ID(0x%x) RX_ID(0x%x) Cmdsn(0x%lx) timeout abort it",
lport->port_id, v_xchg, v_xchg->ox_id,
v_xchg->rx_id, (unsigned long)v_xchg->cmnd_sn);
lport->xchg_mgr_temp.pfn_unf_xchg_add_timer(
(void *)v_xchg,
(unsigned long)UNF_WAIT_ABTS_RSP_TIMEOUT,
UNF_TIMER_TYPE_INI_ABTS);
sema_init(&v_xchg->task_sema, 0);
scsi_cmnd.scsi_id = xchg->scsi_cmnd_info.scsi_id;
scsi_cmnd.upper_cmnd = xchg->scsi_cmnd_info.scsi_cmnd;
scsi_cmnd.pfn_done = xchg->scsi_cmnd_info.pfn_done;
scsi_image_table = &lport->rport_scsi_table;
if (unf_send_abts(lport, v_xchg) != RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"LPort(0x%x) send ABTS, Send ABTS unsuccessful. Exchange OX_ID(0x%x), RX_ID(0x%x).",
lport->port_id, v_xchg->ox_id,
v_xchg->rx_id);
lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)v_xchg);
spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
v_xchg->io_state &= ~INI_IO_STATE_UPABORT;
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
/* The message fails to be sent.
* It is released internally and does not
* need to be released externally.
*/
return;
}
if (down_timeout(&v_xchg->task_sema,
(long long)msecs_to_jiffies(timeout_value))) {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) recv abts marker timeout,Exch(0x%p) OX_ID(0x%x) RX_ID(0x%x)",
lport->port_id, v_xchg,
v_xchg->ox_id, v_xchg->rx_id);
lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)v_xchg);
/* Cnacel the flag of INI_IO_STATE_UPABORT
* and process the io in TMF
*/
spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
v_xchg->io_state &= ~INI_IO_STATE_UPABORT;
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
return;
}
spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
if ((v_xchg->ucode_abts_state == UNF_IO_SUCCESS) ||
(v_xchg->scsi_cmnd_info.result == UNF_IO_ABORT_PORT_REMOVING)) {
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_MAJOR,
"[info]Port(0x%x) Send ABTS succeed and recv marker Exch(0x%p) OX_ID(0x%x) RX_ID(0x%x) marker status(0x%x)",
lport->port_id, v_xchg,
v_xchg->ox_id, v_xchg->rx_id,
v_xchg->ucode_abts_state);
return_value = DID_BUS_BUSY;
UNF_IO_RESULT_CNT(scsi_image_table, scsi_cmnd.scsi_id,
return_value);
unf_complete_cmnd(&scsi_cmnd, DID_BUS_BUSY << 16);
return;
}
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)v_xchg);
spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
v_xchg->io_state &= ~INI_IO_STATE_UPABORT;
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_REG_ATT, UNF_WARN,
"[warn]Port(0x%x) send ABTS failed. Exch(0x%p) hot_tag(0x%x) ret(0x%x) v_xchg->io_state (0x%x)",
lport->port_id, v_xchg, v_xchg->hot_pool_tag,
v_xchg->scsi_cmnd_info.result, v_xchg->io_state);
}
static void unf_fc_ini_send_abts_timeout(struct unf_lport_s *lport,
struct unf_rport_s *rport,
struct unf_xchg_s *xchg)
{
if (xchg->rport_bind_jifs == rport->rport_alloc_jifs &&
xchg->rport_bind_jifs != INVALID_VALUE64) {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%x) Exch(0x%p) first time to send abts timeout, retry again OX_ID(0x%x) RX_ID(0x%x) state(0x%x)",
lport->port_id, rport->nport_id,
xchg, xchg->ox_id, xchg->rx_id, xchg->io_state);
lport->xchg_mgr_temp.pfn_unf_xchg_add_timer(
(void *)xchg,
(unsigned long)UNF_WAIT_ABTS_RSP_TIMEOUT,
UNF_TIMER_TYPE_INI_ABTS);
if (unf_send_abts(lport, xchg) != RETURN_OK) {
lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer(
(void *)xchg);
unf_abts_timeout_recovery_default(rport, xchg);
unf_cm_free_xchg(lport, xchg);
}
} else {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%x) Exch(0x%p) rport is invalid, exchg rport jiff(0x%llx 0x%llx), free exchange OX_ID(0x%x) RX_ID(0x%x) state(0x%x)",
lport->port_id, rport->nport_id, xchg,
xchg->rport_bind_jifs, rport->rport_alloc_jifs,
xchg->ox_id, xchg->rx_id, xchg->io_state);
unf_cm_free_xchg(lport, xchg);
}
}
static void unf_fc_ini_io_rec_wait_timeout(struct unf_lport_s *lport,
struct unf_rport_s *rport,
struct unf_xchg_s *xchg)
{
unsigned long io_time_out = 0;
if (xchg->rport_bind_jifs == rport->rport_alloc_jifs) {
unf_send_rec(lport, rport, xchg);
if (xchg->scsi_cmnd_info.abort_timeout > 0) {
io_time_out =
(xchg->scsi_cmnd_info.abort_timeout >
UNF_REC_TOV) ?
(xchg->scsi_cmnd_info.abort_timeout -
UNF_REC_TOV) : 0;
if (io_time_out > 0) {
lport->xchg_mgr_temp.pfn_unf_xchg_add_timer(
(void *)xchg,
io_time_out,
UNF_TIMER_TYPE_REQ_IO);
} else {
unf_fc_abort_timeout_cmnd(lport, xchg);
}
}
} else {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%x) Exch(0x%p) Rec timeout exchange OX_ID(0x%x) RX_ID(0x%x) state(0x%x), bindjifs(0x%llx)no eqal Rport alloc jifs(0x%llx)",
lport->port_id, rport->nport_id,
xchg, xchg->ox_id, xchg->rx_id,
xchg->io_state, xchg->rport_bind_jifs,
rport->rport_alloc_jifs);
}
}
static void unf_fc_ini_io_xchg_timeout(struct work_struct *v_work)
{
struct unf_xchg_s *xchg = NULL;
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
unsigned long flags = 0;
unsigned int ret = UNF_RETURN_ERROR;
unsigned int port_valid_flag = 0;
UNF_REFERNCE_VAR(ret);
xchg = container_of(v_work, struct unf_xchg_s, timeout_work.work);
UNF_CHECK_VALID(0x939, UNF_TRUE, xchg, return);
ret = unf_xchg_ref_inc(xchg, INI_IO_TIMEOUT);
UNF_CHECK_VALID(0x940, UNF_TRUE, ret == RETURN_OK, return);
lport = xchg->lport;
rport = xchg->rport;
port_valid_flag = !lport || !rport;
if (port_valid_flag) {
unf_xchg_ref_dec(xchg, INI_IO_TIMEOUT);
unf_xchg_ref_dec(xchg, INI_IO_TIMEOUT);
return;
}
spin_lock_irqsave(&xchg->xchg_state_lock, flags);
/* 1. for Send RRQ failed Timer timeout */
if (INI_IO_STATE_RRQSEND_ERR & xchg->io_state) {
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[info]LPort(0x%x) RPort(0x%x) Exch(0x%p) had wait enough time for RRQ send failed OX_ID(0x%x) RX_ID(0x%x) state(0x%x)",
lport->port_id, rport->nport_id,
xchg, xchg->ox_id, xchg->rx_id, xchg->io_state);
unf_cm_free_xchg(lport, xchg);
}
/* Second ABTS timeout and enter LOGO process */
else if ((INI_IO_STATE_ABORT_TIMEOUT & xchg->io_state) &&
(!(ABTS_RESPONSE_RECEIVED & xchg->abts_state))) {
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%x) Exch(0x%p) had wait enough time for second abts send OX_ID(0x%x) RX_ID(0x%x) state(0x%x)",
lport->port_id, rport->nport_id,
xchg, xchg->ox_id, xchg->rx_id,
xchg->io_state);
unf_abts_timeout_recovery_default(rport, xchg);
unf_cm_free_xchg(lport, xchg);
}
/* First time to send ABTS, timeout and retry to send ABTS again */
else if ((xchg->io_state & INI_IO_STATE_UPABORT) &&
(!(xchg->abts_state & ABTS_RESPONSE_RECEIVED))) {
xchg->io_state |= INI_IO_STATE_ABORT_TIMEOUT;
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
unf_fc_ini_send_abts_timeout(lport, rport, xchg);
}
/* 3. IO_DONE */
else if ((xchg->io_state & INI_IO_STATE_DONE) &&
(xchg->abts_state & ABTS_RESPONSE_RECEIVED)) {
/*
* for IO_DONE:
* 1. INI ABTS first timer time out
* 2. INI RCVD ABTS Response
* 3. Normal case for I/O Done
*/
/* Send ABTS & RCVD RSP & no timeout */
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
/* Send RRQ */
if (unf_send_rrq(lport, rport, xchg) == RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT,
UNF_MAJOR,
"[info]LPort(0x%x) send RRQ succeed to RPort(0x%x) Exch(0x%p) OX_ID(0x%x) RX_ID(0x%x) state(0x%x)",
lport->port_id, rport->nport_id, xchg,
xchg->ox_id, xchg->rx_id, xchg->io_state);
} else {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT,
UNF_WARN,
"[warn]LPort(0x%x) can't send RRQ to RPort(0x%x) Exch(0x%p) OX_ID(0x%x) RX_ID(0x%x) state(0x%x)",
lport->port_id, rport->nport_id, xchg,
xchg->ox_id, xchg->rx_id, xchg->io_state);
spin_lock_irqsave(&xchg->xchg_state_lock, flags);
xchg->io_state |= INI_IO_STATE_RRQSEND_ERR;
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
lport->xchg_mgr_temp.pfn_unf_xchg_add_timer(
(void *)xchg,
(unsigned long)UNF_WRITE_RRQ_SENDERR_INTERVAL,
UNF_TIMER_TYPE_INI_IO);
}
} else if (xchg->io_state & INI_IO_STATE_REC_TIMEOUT_WAIT) {
xchg->io_state &= ~INI_IO_STATE_REC_TIMEOUT_WAIT;
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
unf_fc_ini_io_rec_wait_timeout(lport, rport, xchg);
} else {
/* 4. I/O Timer Timeout */
/* vmware */
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
unf_fc_abort_timeout_cmnd(lport, xchg);
}
unf_xchg_ref_dec(xchg, INI_IO_TIMEOUT);
unf_xchg_ref_dec(xchg, INI_IO_TIMEOUT);
UNF_REFERNCE_VAR(ret);
}
static inline struct unf_xchg_s *unf_alloc_io_xchg(
struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr,
unsigned int v_xchg_type,
unsigned short v_rx_id)
{
struct unf_xchg_s *xchg = NULL;
struct list_head *list_node = NULL;
struct unf_xchg_free_pool_s *free_pool = NULL;
struct unf_xchg_hot_pool_s *hot_pool = NULL;
unsigned long flags = 0;
static atomic64_t s_exhg_id;
void (*unf_fc_io_xchg_timeout)(struct work_struct *v_work) = NULL;
UNF_CHECK_VALID(0x941, UNF_TRUE, v_xchg_mgr, return NULL);
UNF_CHECK_VALID(0x942, UNF_TRUE, v_lport, return NULL);
free_pool = &v_xchg_mgr->free_pool;
hot_pool = v_xchg_mgr->hot_pool;
UNF_CHECK_VALID(0x943, UNF_TRUE, free_pool, return NULL);
UNF_CHECK_VALID(0x944, UNF_TRUE, hot_pool, return NULL);
/* 1. Free Pool */
spin_lock_irqsave(&free_pool->xchg_free_pool_lock, flags);
if (unlikely(list_empty(&free_pool->list_free_xchg_list))) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_INFO,
"Port(0x%x) have no Exchange anymore.",
v_lport->port_id);
spin_unlock_irqrestore(&free_pool->xchg_free_pool_lock, flags);
return NULL;
}
/* Select an idle node from free pool */
list_node = (&free_pool->list_free_xchg_list)->next;
list_del(list_node);
free_pool->total_fcp_xchg--;
spin_unlock_irqrestore(&free_pool->xchg_free_pool_lock, flags);
xchg = list_entry(list_node, struct unf_xchg_s, list_xchg_entry);
/*
* Hot Pool:
* When xchg is mounted to Hot Pool, the mount mode and release mode
* of Xchg must be specified and stored in the sfs linked list.
*/
flags = 0;
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
if (unf_alloc_hot_pool_slab(hot_pool, xchg, v_rx_id) != RETURN_OK) {
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
unf_add_back_to_fcp_list(free_pool, xchg);
if (unlikely(v_lport->b_port_removing == UNF_TRUE))
unf_check_xchg_mgr_status(v_xchg_mgr);
return NULL;
}
list_add_tail(&xchg->list_xchg_entry, &hot_pool->ini_busylist);
unf_fc_io_xchg_timeout = unf_fc_ini_io_xchg_timeout;
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
/* 3. Exchange State */
spin_lock_irqsave(&xchg->xchg_state_lock, flags);
xchg->start_jif = atomic64_inc_return(&s_exhg_id);
xchg->xchg_mgr = v_xchg_mgr;
xchg->free_pool = free_pool;
xchg->hot_pool = hot_pool;
xchg->lport = v_lport;
xchg->xchg_type = v_xchg_type;
xchg->pfn_free_xchg = unf_free_fcp_xchg;
xchg->io_state = UNF_IO_STATE_NEW;
xchg->io_send_stage = TGT_IO_SEND_STAGE_NONE;
xchg->io_send_result = TGT_IO_SEND_RESULT_INVALID;
xchg->io_send_abort = UNF_FALSE;
xchg->io_abort_result = UNF_FALSE;
xchg->ox_id = INVALID_VALUE16;
xchg->abort_oxid = INVALID_VALUE16;
xchg->rx_id = INVALID_VALUE16;
xchg->sid = INVALID_VALUE32;
xchg->did = INVALID_VALUE32;
xchg->oid = INVALID_VALUE32;
xchg->seq_id = INVALID_VALUE8;
xchg->cmnd_code = INVALID_VALUE32;
xchg->data_len = 0;
xchg->resid_len = 0;
xchg->data_direction = DMA_NONE;
xchg->may_consume_res_cnt = 0;
xchg->fact_consume_res_cnt = 0;
xchg->io_front_jif = 0;
xchg->tmf_state = 0;
xchg->ucode_abts_state = INVALID_VALUE32;
xchg->abts_state = 0;
xchg->rport_bind_jifs = INVALID_VALUE64;
xchg->scsi_id = INVALID_VALUE32;
xchg->world_id = INVALID_VALUE32;
memset(&xchg->dif_control, 0, sizeof(struct unf_dif_control_info_s));
memset(&xchg->req_sgl_info, 0, sizeof(struct unf_req_sgl_info_s));
memset(&xchg->dif_sgl_info, 0, sizeof(struct unf_req_sgl_info_s));
memset(&xchg->abts_rsps, 0, sizeof(struct unf_abts_rsps_s));
xchg->scsi_cmnd_info.result = 0;
xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] =
(unsigned int)atomic64_inc_return(&v_lport->exchg_index);
if (xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] == 0)
xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] =
(unsigned int)atomic64_inc_return(&v_lport->exchg_index);
atomic_set(&xchg->ref_cnt, 0);
atomic_set(&xchg->delay_flag, 0);
if (delayed_work_pending(&xchg->timeout_work))
UNF_DEL_XCHG_TIMER_SAFE(xchg);
INIT_DELAYED_WORK(&xchg->timeout_work, unf_fc_io_xchg_timeout);
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
return xchg;
}
static void unf_add_back_to_sfs_list(
struct unf_xchg_free_pool_s *v_free_pool,
struct unf_xchg_s *v_xchg)
{
unsigned long flags = 0;
UNF_CHECK_VALID(0x945, UNF_TRUE, v_free_pool, return);
UNF_CHECK_VALID(0x946, UNF_TRUE, v_xchg, return);
unf_init_xchg_attribute(v_xchg);
spin_lock_irqsave(&v_free_pool->xchg_free_pool_lock, flags);
list_add_tail(&v_xchg->list_xchg_entry,
&v_free_pool->list_sfs_xchg_list);
v_free_pool->total_sfs_xchg++;
spin_unlock_irqrestore(&v_free_pool->xchg_free_pool_lock, flags);
}
static void unf_free_sfs_xchg(struct unf_xchg_s *v_xchg)
{
struct unf_xchg_free_pool_s *free_pool = NULL;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
struct unf_lport_s *lport = NULL;
UNF_CHECK_VALID(0x947, UNF_TRUE, v_xchg, return);
free_pool = v_xchg->free_pool;
lport = v_xchg->lport;
xchg_mgr = v_xchg->xchg_mgr;
/* The memory is applied for when the GID_PT/GID_FT is sent.
* If no response is received, the GID_PT/GID_FT
* needs to be forcibly released.
*/
unf_free_one_big_sfs(v_xchg);
unf_add_back_to_sfs_list(free_pool, v_xchg);
if (unlikely(lport->b_port_removing == UNF_TRUE))
unf_check_xchg_mgr_status(xchg_mgr);
}
static void unf_fc_xchg_add_timer(void *v_xchg,
unsigned long v_time_ms,
enum unf_timer_type_e v_en_time_type)
{
unsigned long flag = 0;
struct unf_xchg_s *xchg = NULL;
unsigned long time_ms = v_time_ms;
struct unf_lport_s *lport;
UNF_CHECK_VALID(0x948, UNF_TRUE, v_xchg, return);
xchg = (struct unf_xchg_s *)v_xchg;
lport = xchg->lport;
UNF_CHECK_VALID(0x948, UNF_TRUE, lport, return);
/* update timeout */
switch (v_en_time_type) {
case UNF_TIMER_TYPE_INI_RRQ:
time_ms = time_ms - UNF_INI_RRQ_REDUNDANT_TIME;
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT,
UNF_INFO, "INI RRQ Timer set.");
break;
case UNF_TIMER_TYPE_SFS:
time_ms = time_ms + UNF_INI_ELS_REDUNDANT_TIME;
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT,
UNF_INFO, "INI ELS Timer set.");
break;
default:
break;
}
/* The xchg of the timer must be valid.
* If the reference count of xchg is 0,
* the timer must not be added
*/
if (atomic_read(&xchg->ref_cnt) <= 0) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_KEVENT,
"[warn]Abnormal Exchange(0x%p), Reference count(0x%x), Can't add timer.",
xchg, atomic_read(&xchg->ref_cnt));
return;
}
/* Delay Work: Hold for timer */
spin_lock_irqsave(&xchg->xchg_state_lock, flag);
if (queue_delayed_work(lport->xchg_wq,
&xchg->timeout_work,
(unsigned long)
msecs_to_jiffies((unsigned int)time_ms))) {
/* hold for timer */
atomic_inc(&xchg->ref_cnt);
}
spin_unlock_irqrestore(&xchg->xchg_state_lock, flag);
}
static void unf_sfs_xchg_timeout(struct work_struct *v_work)
{
struct unf_xchg_s *xchg = NULL;
unsigned int ret = UNF_RETURN_ERROR;
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
unsigned long flags = 0;
UNF_CHECK_VALID(0x949, UNF_TRUE, v_work, return);
xchg = container_of(v_work, struct unf_xchg_s, timeout_work.work);
UNF_CHECK_VALID(0x950, UNF_TRUE, xchg, return);
ret = unf_xchg_ref_inc(xchg, SFS_TIMEOUT);
UNF_REFERNCE_VAR(ret);
UNF_CHECK_VALID(0x951, UNF_TRUE, ret == RETURN_OK, return);
spin_lock_irqsave(&xchg->xchg_state_lock, flags);
lport = xchg->lport;
rport = xchg->rport;
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
unf_xchg_ref_dec(xchg, SFS_TIMEOUT);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]SFS Exch(%p) Cmnd(0x%x) IO Exch(0x%p) Sid_Did(0x%x:0x%x) HotTag(0x%x) State(0x%x) Timeout.",
xchg, xchg->cmnd_code, xchg->io_xchg, xchg->sid,
xchg->did, xchg->hot_pool_tag, xchg->io_state);
spin_lock_irqsave(&xchg->xchg_state_lock, flags);
if ((xchg->io_state & TGT_IO_STATE_ABORT) &&
(xchg->cmnd_code != ELS_RRQ) &&
(xchg->cmnd_code != ELS_LOGO)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
"SFS Exch(0x%p) Cmnd(0x%x) Hot Pool Tag(0x%x) timeout, but aborted, no need to handle.",
xchg, xchg->cmnd_code, xchg->hot_pool_tag);
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
unf_xchg_ref_dec(xchg, SFS_TIMEOUT);
unf_xchg_ref_dec(xchg, SFS_TIMEOUT);
return;
}
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
/* The sfs times out. If the sfs is ELS reply,
* go to unf_rport_error_recovery/unf_lport_error_recovery.
* Otherwise, go to the corresponding obCallback.
*/
if (UNF_XCHG_IS_ELS_REPLY(xchg) && (rport)) {
if (rport->nport_id >= UNF_FC_FID_DOM_MGR)
unf_lport_error_recovery(lport);
else
unf_rport_error_recovery(rport);
} else if (xchg->pfn_ob_callback) {
xchg->pfn_ob_callback(xchg);
} else {
/* Do nothing */
}
unf_xchg_ref_dec(xchg, SFS_TIMEOUT);
unf_xchg_ref_dec(xchg, SFS_TIMEOUT);
}
static struct unf_xchg_s *unf_alloc_sfs_xchg(struct unf_lport_s *v_lport,
struct unf_xchg_mgr_s *v_xchg_mgr,
unsigned int v_xchg_type,
unsigned short v_rx_id)
{
struct unf_xchg_s *xchg = NULL;
struct list_head *list_node = NULL;
struct unf_xchg_free_pool_s *free_pool = NULL;
struct unf_xchg_hot_pool_s *hot_pool = NULL;
unsigned long flags = 0;
UNF_CHECK_VALID(0x952, UNF_TRUE, v_lport, return NULL);
UNF_CHECK_VALID(0x953, UNF_TRUE, v_xchg_mgr, return NULL);
free_pool = &v_xchg_mgr->free_pool;
hot_pool = v_xchg_mgr->hot_pool;
UNF_CHECK_VALID(0x954, UNF_TRUE, free_pool, return NULL);
UNF_CHECK_VALID(0x955, UNF_TRUE, hot_pool, return NULL);
/* Select an idle node from free pool */
spin_lock_irqsave(&free_pool->xchg_free_pool_lock, flags);
if (list_empty(&free_pool->list_sfs_xchg_list)) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"Port(0x%x) have no Exchange anymore.",
v_lport->port_id);
spin_unlock_irqrestore(&free_pool->xchg_free_pool_lock, flags);
return NULL;
}
list_node = (&free_pool->list_sfs_xchg_list)->next;
list_del(list_node);
free_pool->total_sfs_xchg--;
spin_unlock_irqrestore(&free_pool->xchg_free_pool_lock, flags);
xchg = list_entry(list_node, struct unf_xchg_s, list_xchg_entry);
/*
* The xchg is mounted to the Hot Pool.
* The mount mode and release mode of the xchg must be specified
* and stored in the sfs linked list.
*/
flags = 0;
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
if (unf_alloc_hot_pool_slab(hot_pool, xchg, v_rx_id) != RETURN_OK) {
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
unf_add_back_to_sfs_list(free_pool, xchg);
if (unlikely(v_lport->b_port_removing == UNF_TRUE))
unf_check_xchg_mgr_status(v_xchg_mgr);
return NULL;
}
list_add_tail(&xchg->list_xchg_entry, &hot_pool->sfs_busylist);
hot_pool->total_xchges++;
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
spin_lock_irqsave(&xchg->xchg_state_lock, flags);
xchg->free_pool = free_pool;
xchg->hot_pool = hot_pool;
xchg->lport = v_lport;
xchg->xchg_mgr = v_xchg_mgr;
xchg->pfn_free_xchg = unf_free_sfs_xchg;
xchg->xchg_type = v_xchg_type;
xchg->io_state = UNF_IO_STATE_NEW;
xchg->scsi_cmnd_info.result = 0;
xchg->ob_callback_sts = UNF_IO_SUCCESS;
xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] =
(unsigned int)atomic64_inc_return(&v_lport->exchg_index);
if (xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] == 0)
xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] =
(unsigned int)
atomic64_inc_return(&v_lport->exchg_index);
if (delayed_work_pending(&xchg->timeout_work))
UNF_DEL_XCHG_TIMER_SAFE(xchg);
INIT_DELAYED_WORK(&xchg->timeout_work, unf_sfs_xchg_timeout);
spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
return xchg;
}
static void *unf_get_new_xchg(void *v_lport, unsigned int v_xchg_type,
unsigned short v_rx_id)
{
struct unf_lport_s *lport = NULL;
struct unf_xchg_mgr_s *xchg_mgr = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned int xchg_type = 0;
unsigned short xchg_mgr_type;
unsigned int rtry_cnt = 0;
unsigned int last_exchg_mgr_idx;
xchg_mgr_type = (v_xchg_type >> 16);
xchg_type = v_xchg_type & 0xFFFF;
UNF_CHECK_VALID(0x956, UNF_TRUE, v_lport, return NULL);
/* In the case of NPIV, the v_lport is the Vport pointer,
* and the share uses the ExchMgr of the RootLport.
*/
lport = ((struct unf_lport_s *)v_lport)->root_lport;
UNF_CHECK_VALID(0x957, UNF_TRUE, (lport), return NULL);
if (unlikely((atomic_read(&lport->port_no_operater_flag) ==
UNF_LPORT_NOP) ||
(atomic_read(&((struct unf_lport_s *)v_lport)->port_no_operater_flag) ==
UNF_LPORT_NOP)))
return NULL;
last_exchg_mgr_idx =
(unsigned int)atomic64_inc_return(&lport->last_exchg_mgr_idx);
try_next_mgr:
rtry_cnt++;
if (unlikely(rtry_cnt > UNF_EXCHG_MGR_NUM))
return NULL;
/* If Fixed mode,only use XchgMgr 0 */
if (unlikely(xchg_mgr_type == UNF_XCHG_MGR_TYPE_FIXED))
xchg_mgr = (struct unf_xchg_mgr_s *)lport->p_xchg_mgr[0];
else
xchg_mgr =
(struct unf_xchg_mgr_s *)
lport->p_xchg_mgr[last_exchg_mgr_idx % UNF_EXCHG_MGR_NUM];
if (unlikely(!xchg_mgr)) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Port(0x%x) get exchangemgr %u is null.",
lport->port_id,
last_exchg_mgr_idx % UNF_EXCHG_MGR_NUM);
return NULL;
}
last_exchg_mgr_idx++;
/* Allocate entries based on the Exchange type */
switch (xchg_type) {
case UNF_XCHG_TYPE_SFS:
xchg = unf_alloc_sfs_xchg(v_lport, xchg_mgr, xchg_type,
INVALID_VALUE16);
break;
case UNF_XCHG_TYPE_INI:
xchg = unf_alloc_io_xchg(v_lport, xchg_mgr, xchg_type,
INVALID_VALUE16);
break;
default:
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"Port(0x%x) unwonted, Exchange type(0x%x).",
lport->port_id, xchg_type);
break;
}
if (likely(xchg)) {
xchg->ox_id = INVALID_VALUE16;
xchg->abort_oxid = INVALID_VALUE16;
xchg->rx_id = INVALID_VALUE16;
xchg->debug_hook = UNF_FALSE;
xchg->alloc_jif = jiffies;
atomic_set(&xchg->ref_cnt, 1);
atomic_set(&xchg->esgl_cnt, 0);
} else {
goto try_next_mgr;
}
return xchg;
}
static void unf_free_xchg(void *v_lport, void *v_xchg)
{
struct unf_xchg_s *xchg = NULL;
UNF_REFERNCE_VAR(v_lport);
UNF_CHECK_VALID(0x958, UNF_TRUE, (v_xchg), return);
xchg = (struct unf_xchg_s *)v_xchg;
unf_xchg_ref_dec(xchg, XCHG_FREE_XCHG);
}
void unf_release_xchg_mgr_temp(struct unf_lport_s *v_lport)
{
UNF_CHECK_VALID(0x960, UNF_TRUE, v_lport, return);
if (v_lport->dirty_flag & UNF_LPORT_DIRTY_FLAG_XCHGMGR_DIRTY) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
"Port(0x%x) has dirty exchange, Don't release exchange manager template.",
v_lport->port_id);
return;
}
memset(&v_lport->xchg_mgr_temp, 0,
sizeof(struct unf_cm_xchg_mgr_template_s));
v_lport->destroy_step = UNF_LPORT_DESTROY_STEP_7_DESTROY_XCHG_MGR_TMP;
}
static void unf_xchg_abort_all_sfs_xchg(struct unf_lport_s *v_lport,
int v_clean)
{
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct list_head *xchg_node = NULL;
struct list_head *next_xchg_node = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long pool_lock_flags = 0;
unsigned long xchg_lock_flags = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x961, UNF_TRUE, v_lport, return);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(v_lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT,
UNF_MAJOR,
"Port(0x%x) Hot Pool is NULL.",
v_lport->port_id);
continue;
}
if (v_clean == UNF_FALSE) {
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
/* Clearing the SFS_Busy_list Exchange Resource */
list_for_each_safe(xchg_node, next_xchg_node,
&hot_pool->sfs_busylist) {
xchg = list_entry(xchg_node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock,
xchg_lock_flags);
if (atomic_read(&xchg->ref_cnt) > 0)
xchg->io_state |= TGT_IO_STATE_ABORT;
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_lock_flags);
}
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
} else {
continue;
}
}
}
static void unf_xchg_abort_ini_io_xchg(struct unf_lport_s *v_lport,
int v_clean)
{
/* Clean L_Port/V_Port Link Down I/O: Abort */
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct list_head *xchg_node = NULL;
struct list_head *next_xchg_node = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long pool_lock_flags = 0;
unsigned long xchg_lock_flags = 0;
unsigned int io_state = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x962, UNF_TRUE, (v_lport), return);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(v_lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT,
UNF_WARN,
"[warn]Port(0x%x) hot pool is NULL",
v_lport->port_id);
continue;
}
if (v_clean == UNF_FALSE) {
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
/* 1. Abort INI_Busy_List IO */
list_for_each_safe(xchg_node, next_xchg_node,
&hot_pool->ini_busylist) {
xchg = list_entry(xchg_node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock,
xchg_lock_flags);
if (atomic_read(&xchg->ref_cnt) > 0)
xchg->io_state |=
INI_IO_STATE_DRABORT | io_state;
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_lock_flags);
}
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
} else {
/* Do nothing, just return */
continue;
}
}
}
static void unf_xchg_abort_all_xchg(void *v_lport,
unsigned int v_xchg_type,
int v_clean)
{
struct unf_lport_s *lport = NULL;
UNF_CHECK_VALID(0x964, UNF_TRUE, v_lport, return);
lport = (struct unf_lport_s *)v_lport;
switch (v_xchg_type) {
case UNF_XCHG_TYPE_SFS:
unf_xchg_abort_all_sfs_xchg(lport, v_clean);
break;
/* Clean L_Port/V_Port Link Down I/O: Abort */
case UNF_XCHG_TYPE_INI:
unf_xchg_abort_ini_io_xchg(lport, v_clean);
break;
default:
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) unknown exch type(0x%x)",
lport->port_id, v_xchg_type);
break;
}
}
static void unf_xchg_abort_ini_send_tm_cmd(void *v_lport,
void *v_rport,
unsigned long long v_lun_id)
{
/*
* LUN Reset: set UP_ABORT tag, with:
* INI_Busy_list, IO_Wait_list,
* IO_Delay_list, IO_Delay_transfer_list
*/
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long flags = 0;
unsigned long xchg_flag = 0;
unsigned int i = 0;
unsigned long long raw_lunid = 0;
UNF_CHECK_VALID(0x981, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x981, UNF_TRUE, v_rport, return);
lport = ((struct unf_lport_s *)v_lport)->root_lport;
UNF_CHECK_VALID(0x982, UNF_TRUE, (lport), return);
rport = (struct unf_rport_s *)v_rport;
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Port(0x%x) hot pool is NULL",
lport->port_id);
continue;
}
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
/* 1. for each exchange from busy list */
list_for_each_safe(node, next_node,
&hot_pool->ini_busylist) {
xchg = list_entry(node, struct unf_xchg_s,
list_xchg_entry);
raw_lunid = *(unsigned long long *)
(xchg->fcp_cmnd.lun) >> 16 &
0x000000000000ffff;
if ((v_lun_id == raw_lunid) &&
(rport == xchg->rport)) {
spin_lock_irqsave(&xchg->xchg_state_lock,
xchg_flag);
xchg->io_state |= INI_IO_STATE_TMF_ABORT;
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_flag);
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT,
UNF_MAJOR,
"[info]Exchange(%p) state(0x%x) S_ID(0x%x) D_ID(0x%x) tag(0x%x) abort by TMF CMD",
xchg, xchg->io_state, lport->nport_id,
rport->nport_id, xchg->hot_pool_tag);
}
}
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
}
}
static void unf_xchg_abort_by_lun(void *v_lport,
void *v_rport,
unsigned long long v_lun_id,
void *v_tm_xchg,
int v_abort_all_lun_flag)
{
/* ABORT: set UP_ABORT tag for target LUN I/O */
struct unf_xchg_s *tm_xchg = (struct unf_xchg_s *)v_tm_xchg;
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"[event]Port(0x%x) LUN_ID(0x%llx) TM_EXCH(0x%p) flag(%d)",
((struct unf_lport_s *)v_lport)->port_id,
v_lun_id, v_tm_xchg, v_abort_all_lun_flag);
/* for INI Mode */
if (!tm_xchg) {
/*
* LUN Reset: set UP_ABORT tag, with:
* INI_Busy_list, IO_Wait_list,
* IO_Delay_list, IO_Delay_transfer_list
*/
unf_xchg_abort_ini_send_tm_cmd(v_lport, v_rport, v_lun_id);
return;
}
}
static void unf_xchg_abort_ini_tmf_target_reset(void *v_lport, void *v_rport)
{
/*
* LUN Reset: set UP_ABORT tag, with:
* INI_Busy_list, IO_Wait_list,
* IO_Delay_list, IO_Delay_transfer_list
*/
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
struct unf_xchg_s *xchg = NULL;
unsigned long flags = 0;
unsigned long xchg_flag = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x981, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x981, UNF_TRUE, v_rport, return);
lport = ((struct unf_lport_s *)v_lport)->root_lport;
UNF_CHECK_VALID(0x982, UNF_TRUE, (lport), return);
rport = (struct unf_rport_s *)v_rport;
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Port(0x%x) hot pool is NULL",
lport->port_id);
continue;
}
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
/* 1. for each exchange from busy_list */
list_for_each_safe(node, next_node,
&hot_pool->ini_busylist) {
xchg = list_entry(node, struct unf_xchg_s,
list_xchg_entry);
if (rport == xchg->rport) {
spin_lock_irqsave(&xchg->xchg_state_lock,
xchg_flag);
xchg->io_state |= INI_IO_STATE_TMF_ABORT;
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_flag);
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT,
UNF_MAJOR,
"[info]Exchange(%p) state(0x%x) S_ID(0x%x) D_ID(0x%x) tag(0x%x) abort by TMF CMD",
xchg, xchg->io_state,
lport->nport_id,
rport->nport_id, xchg->hot_pool_tag);
}
}
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
}
}
static void unf_xchg_abort_by_session(void *v_lport, void *v_rport)
{
/*
* LUN Reset: set UP_ABORT tag, with:
* INI_Busy_list, IO_Wait_list,
* IO_Delay_list, IO_Delay_transfer_list
*/
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"[event]Port(0x%x) Rport(0x%x) start session reset with TMF",
((struct unf_lport_s *)v_lport)->port_id,
((struct unf_rport_s *)v_rport)->nport_id);
unf_xchg_abort_ini_tmf_target_reset(v_lport, v_rport);
}
static void unf_ini_busy_io_xchg_abort(void *v_hot_pool, void *v_rport,
unsigned int v_sid, unsigned int v_did,
unsigned int v_extra_io_state)
{
/*
* for target session: Set (DRV) ABORT
* 1. R_Port remove
* 2. Send PLOGI_ACC callback
* 3. RCVD PLOGI
* 4. RCVD LOGO
*/
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct unf_xchg_s *xchg = NULL;
struct list_head *xchg_node = NULL;
struct list_head *next_xchg_node = NULL;
struct unf_rport_s *rport = NULL;
unsigned long xchg_lock_flags = 0;
rport = (struct unf_rport_s *)v_rport;
hot_pool = (struct unf_xchg_hot_pool_s *)v_hot_pool;
/* ABORT INI IO: INI_BUSY_LIST */
list_for_each_safe(xchg_node, next_xchg_node,
&hot_pool->ini_busylist) {
xchg = list_entry(xchg_node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock, xchg_lock_flags);
if ((v_did == xchg->did) && (v_sid == xchg->sid) &&
(rport == xchg->rport) &&
(atomic_read(&xchg->ref_cnt) > 0)) {
xchg->scsi_cmnd_info.result =
UNF_SCSI_HOST(DID_IMM_RETRY);
xchg->io_state |= INI_IO_STATE_DRABORT;
xchg->io_state |= v_extra_io_state;
UNF_TRACE(UNF_EVTLOG_IO_INFO,
UNF_LOG_IO_ATT, UNF_MAJOR,
"[info]Abort INI:0x%p, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, %llu.",
xchg,
(unsigned int)xchg->hot_pool_tag,
(unsigned int)xchg->xchg_type,
(unsigned int)xchg->ox_id,
(unsigned int)xchg->rx_id,
(unsigned int)xchg->sid,
(unsigned int)xchg->did,
(unsigned int)xchg->io_state,
atomic_read(&xchg->ref_cnt),
xchg->alloc_jif);
}
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_lock_flags);
}
}
static void unf_xchg_mgr_io_xchg_abort(void *v_lport, void *v_rport,
unsigned int v_sid, unsigned int v_did,
unsigned int v_extra_io_state)
{
/*
* for target session: set ABORT
* 1. R_Port remove
* 2. Send PLOGI_ACC callback
* 3. RCVD PLOGI
* 4. RCVD LOGO
*/
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct unf_lport_s *lport = NULL;
unsigned long pool_lock_flags = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x983, UNF_TRUE, v_lport, return);
lport = ((struct unf_lport_s *)v_lport)->root_lport;
UNF_CHECK_VALID(0x984, UNF_TRUE, lport, return);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_WARN,
UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) hot pool is NULL",
lport->port_id);
continue;
}
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
/* 1. Clear INI (session) IO: INI Mode */
unf_ini_busy_io_xchg_abort(hot_pool, v_rport, v_sid,
v_did, v_extra_io_state);
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
}
}
static void unf_xchg_mgr_sfs_xchg_abort(void *v_lport, void *v_rport,
unsigned int v_sid, unsigned int v_did)
{
struct unf_xchg_hot_pool_s *hot_pool = NULL;
struct list_head *xchg_node = NULL;
struct list_head *next_xchg_node = NULL;
struct unf_xchg_s *xchg = NULL;
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
unsigned long pool_lock_flags = 0;
unsigned long xchg_lock_flags = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x991, UNF_TRUE, (v_lport), return);
lport = ((struct unf_lport_s *)v_lport)->root_lport;
UNF_CHECK_VALID(0x992, UNF_TRUE, (lport), return);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(lport, i);
if (!hot_pool) {
UNF_TRACE(UNF_EVTLOG_IO_INFO,
UNF_LOG_IO_ATT, UNF_MAJOR,
"Port(0x%x) Hot Pool is NULL.",
lport->port_id);
continue;
}
rport = (struct unf_rport_s *)v_rport;
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
/* Clear the SFS exchange of the corresponding connection */
list_for_each_safe(xchg_node, next_xchg_node,
&hot_pool->sfs_busylist) {
xchg = list_entry(xchg_node, struct unf_xchg_s,
list_xchg_entry);
spin_lock_irqsave(&xchg->xchg_state_lock,
xchg_lock_flags);
if ((v_did == xchg->did) && (v_sid == xchg->sid) &&
(rport == xchg->rport) &&
(atomic_read(&xchg->ref_cnt) > 0)) {
xchg->io_state |= TGT_IO_STATE_ABORT;
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT,
UNF_MAJOR,
"Abort SFS:0x%p---0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----0x%x----%llu.",
xchg,
(unsigned int)xchg->hot_pool_tag,
(unsigned int)xchg->xchg_type,
(unsigned int)xchg->ox_id,
(unsigned int)xchg->rx_id,
(unsigned int)xchg->sid,
(unsigned int)xchg->did,
(unsigned int)xchg->io_state,
atomic_read(&xchg->ref_cnt),
xchg->alloc_jif);
}
spin_unlock_irqrestore(&xchg->xchg_state_lock,
xchg_lock_flags);
}
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
}
}
unsigned int unf_init_xchg_mgr_temp(struct unf_lport_s *v_lport)
{
UNF_CHECK_VALID(0x959, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
v_lport->xchg_mgr_temp.pfn_unf_xchg_get_free_and_init =
unf_get_new_xchg;
v_lport->xchg_mgr_temp.pfn_unf_xchg_release = unf_free_xchg;
v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag =
unf_lookup_xchg_by_tag;
v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_id =
unf_find_xchg_by_oxid;
v_lport->xchg_mgr_temp.pfn_unf_xchg_add_timer =
unf_fc_xchg_add_timer;
v_lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer =
unf_xchg_cancel_timer;
v_lport->xchg_mgr_temp.pfn_unf_xchg_abort_all_io =
unf_xchg_abort_all_xchg;
v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_cmnd_sn =
unf_lookup_xchg_by_cmnd_sn;
v_lport->xchg_mgr_temp.pfn_unf_xchg_abort_by_lun =
unf_xchg_abort_by_lun;
v_lport->xchg_mgr_temp.pfn_unf_xchg_abort_by_session =
unf_xchg_abort_by_session;
v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_io_xchg_abort =
unf_xchg_mgr_io_xchg_abort;
v_lport->xchg_mgr_temp.pfn_unf_xchg_mgr_sfs_xchg_abort =
unf_xchg_mgr_sfs_xchg_abort;
return RETURN_OK;
}
void unf_set_hot_pool_wait_state(struct unf_lport_s *v_lport,
enum int_e v_wait_state)
{
struct unf_xchg_hot_pool_s *hot_pool = NULL;
unsigned long pool_lock_flags = 0;
unsigned int i = 0;
UNF_CHECK_VALID(0x965, UNF_TRUE, v_lport, return);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
hot_pool = unf_get_hot_pool_by_lport(v_lport, i);
if (unlikely(!hot_pool)) {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT,
UNF_WARN,
"[warn]Port(0x%x) hot pool is NULL",
v_lport->port_id);
continue;
}
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
hot_pool->wait_state = v_wait_state;
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
}
}
unsigned int unf_xchg_ref_inc(struct unf_xchg_s *v_xchg,
enum unf_ioflow_id_e v_io_stage)
{
struct unf_xchg_hot_pool_s *hot_pool = NULL;
unsigned long flags = 0;
unsigned int ret = UNF_RETURN_ERROR;
UNF_CHECK_VALID(0x967, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
if (unlikely(v_xchg->debug_hook == UNF_TRUE)) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"[info]Xchg(0x%p) State(0x%x) SID_DID(0x%x_0x%x) OX_ID_RX_ID(0x%x_0x%x) AllocJiff(%llu) Refcnt(%d) Stage(%s)",
v_xchg, v_xchg->io_state, v_xchg->sid,
v_xchg->did, v_xchg->ox_id, v_xchg->rx_id,
v_xchg->alloc_jif, atomic_read(&v_xchg->ref_cnt),
io_stage[v_io_stage].stage);
}
hot_pool = v_xchg->hot_pool;
UNF_CHECK_VALID(0x968, UNF_TRUE, hot_pool, return UNF_RETURN_ERROR);
UNF_REFERNCE_VAR(v_io_stage);
/* Exchange -> Hot Pool Tag check */
if (unlikely((v_xchg->hot_pool_tag >=
(hot_pool->slab_total_sum + hot_pool->base)) ||
(v_xchg->hot_pool_tag < hot_pool->base))) {
UNF_TRACE(UNF_EVTLOG_IO_ERR, UNF_LOG_IO_ATT, UNF_ERR,
"[err]Xchg(0x%p) S_ID(%xh) D_ID(0x%x) hot_pool_tag(0x%x) is bigger than slab total num(0x%x) base(0x%x)",
v_xchg, v_xchg->sid, v_xchg->did,
v_xchg->hot_pool_tag,
hot_pool->slab_total_sum + hot_pool->base,
hot_pool->base);
return UNF_RETURN_ERROR;
}
/* atomic read & inc */
spin_lock_irqsave(&v_xchg->xchg_state_lock, flags);
if (unlikely(atomic_read(&v_xchg->ref_cnt) <= 0)) {
ret = UNF_RETURN_ERROR;
} else {
if (unf_get_xchg_by_xchg_tag(hot_pool,
v_xchg->hot_pool_tag -
hot_pool->base) ==
v_xchg) {
atomic_inc(&v_xchg->ref_cnt);
ret = RETURN_OK;
} else {
ret = UNF_RETURN_ERROR;
}
}
spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flags);
return ret;
}
void unf_xchg_ref_dec(struct unf_xchg_s *v_xchg,
enum unf_ioflow_id_e v_io_stage)
{
/* Atomic dec ref_cnt & test, free exchange
* if necessary (ref_cnt==0)
*/
struct unf_xchg_hot_pool_s *hot_pool = NULL;
void (*pfn_free_xchg)(struct unf_xchg_s *) = NULL;
unsigned long flags = 0;
unsigned long xchg_lock_flags = 0;
UNF_CHECK_VALID(0x969, UNF_TRUE, (v_xchg), return);
if (v_xchg->debug_hook == UNF_TRUE) {
UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
"[info]Xchg(0x%p) State(0x%x) SID_DID(0x%x_0x%x) OXID_RXID(0x%x_0x%x) AllocJiff(%llu) Refcnt(%d) Statge %s",
v_xchg, v_xchg->io_state, v_xchg->sid,
v_xchg->did, v_xchg->ox_id, v_xchg->rx_id,
v_xchg->alloc_jif, atomic_read(&v_xchg->ref_cnt),
io_stage[v_io_stage].stage);
}
hot_pool = v_xchg->hot_pool;
UNF_CHECK_VALID(0x970, UNF_TRUE, hot_pool, return);
UNF_CHECK_VALID(0x970, UNF_TRUE,
v_xchg->hot_pool_tag >= hot_pool->base, return);
UNF_REFERNCE_VAR(v_io_stage);
/*
* 1. Atomic dec & test
* 2. Free exchange if necessary (ref_cnt == 0)
*/
spin_lock_irqsave(&v_xchg->xchg_state_lock, xchg_lock_flags);
if (atomic_dec_and_test(&v_xchg->ref_cnt)) {
pfn_free_xchg = v_xchg->pfn_free_xchg;
spin_unlock_irqrestore(&v_xchg->xchg_state_lock,
xchg_lock_flags);
spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
unf_hot_pool_slab_set(hot_pool,
v_xchg->hot_pool_tag - hot_pool->base,
NULL);
/* Delete exchange list entry */
list_del_init(&v_xchg->list_xchg_entry);
hot_pool->total_xchges--;
spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);
// unf_free_fcp_xchg --->>> unf_done_ini_xchg
if (pfn_free_xchg)
pfn_free_xchg(v_xchg);
} else {
spin_unlock_irqrestore(&v_xchg->xchg_state_lock,
xchg_lock_flags);
}
}
bool unf_busy_io_completed(struct unf_lport_s *v_lport)
{
struct unf_xchg_mgr_s *xchg_mgr = NULL;
unsigned long pool_lock_flags = 0;
unsigned int i;
UNF_CHECK_VALID(0x5841, UNF_TRUE, v_lport, return UNF_TRUE);
for (i = 0; i < UNF_EXCHG_MGR_NUM; i++) {
xchg_mgr = unf_get_xchg_mgr_by_lport(v_lport, i);
if (unlikely(!xchg_mgr)) {
UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
"[warn]Port(0x%x) Exchange Manager is NULL",
v_lport->port_id);
continue;
}
spin_lock_irqsave(&xchg_mgr->hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
if (!list_empty(&xchg_mgr->hot_pool->ini_busylist)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT,
UNF_INFO, "[info]Port(0x%x) ini busylist is not empty.",
v_lport->port_id);
spin_unlock_irqrestore(
&xchg_mgr->hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
return UNF_FALSE;
}
spin_unlock_irqrestore(
&xchg_mgr->hot_pool->xchg_hot_pool_lock,
pool_lock_flags);
}
return UNF_TRUE;
}
Reference in New Issue View Git Blame Copy Permalink