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_rport.c
ardu a3d3d6db49 new
2026-01-21 18:59:54 +08:00

2431 lines
72 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_lport.h"
#include "unf_rport.h"
#include "unf_exchg.h"
#include "unf_service.h"
#include <scsi/scsi_transport_fc.h>
#include "unf_portman.h"
/* rport state: */
/* ready --->>> link_down --->>> cloing --->>> timeout --->>> delete */
struct unf_rport_feature_pool_s *port_fea_pool;
/*
* Function Name : unf_sesion_loss_timeout
* Function Description: session loss timeout
* Input Parameters : struct work_struct *v_work
* Output Parameters : N/A
* Return Type : unsigned int
*/
void unf_sesion_loss_timeout(struct work_struct *v_work)
{
struct unf_wwpn_rport_info_s *wwpn_rport_info = NULL;
UNF_CHECK_VALID(0x3040, UNF_TRUE, v_work, return);
wwpn_rport_info = container_of(v_work, struct unf_wwpn_rport_info_s,
loss_tmo_work.work);
if (unlikely(!wwpn_rport_info)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]wwpn_rport_info is NULL");
return;
}
atomic_set(&wwpn_rport_info->en_scsi_state, UNF_SCSI_ST_DEAD);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
"[info]Port(0x%x) wwpn(0x%llx) set target(0x%x) scsi state to dead",
((struct unf_lport_s *)(wwpn_rport_info->lport))->port_id,
wwpn_rport_info->wwpn,
wwpn_rport_info->target_id);
}
/*
* Function Name : unf_alloc_scsi_id
* Function Description: alloc r_port scsi id
* Input Parameters : struct unf_lport_s *v_lport
* : struct unf_rport_s *v_rport
* Output Parameters : N/A
* Return Type : unsigned int
*/
static unsigned int unf_alloc_scsi_id(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
struct unf_rport_scsi_id_image_s *rport_scsi_table = NULL;
struct unf_wwpn_rport_info_s *wwn_rport_info = NULL;
unsigned long flags = 0;
unsigned int index = 0;
unsigned int ret = UNF_RETURN_ERROR;
rport_scsi_table = &v_lport->rport_scsi_table;
UNF_REFERNCE_VAR(ret);
spin_lock_irqsave(&rport_scsi_table->scsi_image_table_lock, flags);
/* 1. At first, existence check */
for (index = 0; index < rport_scsi_table->max_scsi_id; index++) {
wwn_rport_info =
&rport_scsi_table->wwn_rport_info_table[index];
if (v_rport->port_name == wwn_rport_info->wwpn) {
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_DELAYED_WORK_SYNC(ret, (v_lport->port_id),
(&wwn_rport_info->loss_tmo_work),
"loss tmo Timer work");
/* Plug case: reuse again */
spin_lock_irqsave(
&rport_scsi_table->scsi_image_table_lock,
flags);
wwn_rport_info->rport = v_rport;
wwn_rport_info->last_en_scis_state =
atomic_read(&wwn_rport_info->en_scsi_state);
atomic_set(&wwn_rport_info->en_scsi_state,
UNF_SCSI_ST_ONLINE);
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]port(0x%x) find the same scsi_id(0x%x) by wwpn(0x%llx) rport(%p) n_port_id(0x%x)",
v_lport->port_id, index,
wwn_rport_info->wwpn,
v_rport, v_rport->nport_id);
atomic_inc(&v_lport->resume_scsi_id);
goto find;
}
}
/* 2. Alloc new SCSI ID */
for (index = 0; index < rport_scsi_table->max_scsi_id; index++) {
wwn_rport_info =
&rport_scsi_table->wwn_rport_info_table[index];
if (wwn_rport_info->wwpn == INVALID_WWPN) {
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_DELAYED_WORK_SYNC(ret, (v_lport->port_id),
(&wwn_rport_info->loss_tmo_work),
"loss tmo Timer work");
/* Use the free space */
spin_lock_irqsave(
&rport_scsi_table->scsi_image_table_lock,
flags);
wwn_rport_info->rport = v_rport;
wwn_rport_info->wwpn = v_rport->port_name;
wwn_rport_info->last_en_scis_state =
atomic_read(&wwn_rport_info->en_scsi_state);
atomic_set(&wwn_rport_info->en_scsi_state,
UNF_SCSI_ST_ONLINE);
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]port(0x%x) allco new scsi_id(0x%x) by wwpn(0x%llx) rport(%p) n_port_id(0x%x)",
v_lport->port_id, index,
wwn_rport_info->wwpn,
v_rport, v_rport->nport_id);
atomic_inc(&v_lport->alloc_scsi_id);
goto find;
}
}
/* 3. Reuse space has been used */
for (index = 0; index < rport_scsi_table->max_scsi_id; index++) {
wwn_rport_info =
&rport_scsi_table->wwn_rport_info_table[index];
if (atomic_read(&wwn_rport_info->en_scsi_state) ==
UNF_SCSI_ST_DEAD) {
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_DELAYED_WORK_SYNC(ret, (v_lport->port_id),
(&wwn_rport_info->loss_tmo_work),
"loss tmo Timer work");
spin_lock_irqsave(
&rport_scsi_table->scsi_image_table_lock,
flags);
if (wwn_rport_info->dfx_counter) {
memset(wwn_rport_info->dfx_counter, 0,
sizeof(struct unf_wwpn_dfx_counter_info_s));
}
wwn_rport_info->rport = v_rport;
wwn_rport_info->wwpn = v_rport->port_name;
wwn_rport_info->last_en_scis_state =
atomic_read(&wwn_rport_info->en_scsi_state);
atomic_set(&wwn_rport_info->en_scsi_state,
UNF_SCSI_ST_ONLINE);
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
UNF_WARN,
"[info]port(0x%x) reuse a dead scsi_id(0x%x) by wwpn(0x%llx) rport(%p) n_port_id(0x%x)",
v_lport->port_id, index,
wwn_rport_info->wwpn,
v_rport, v_rport->nport_id);
atomic_inc(&v_lport->reuse_scsi_id);
goto find;
}
}
spin_unlock_irqrestore(&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]port(0x%x) there is not enough scsi_id with max_value(0x%x)",
v_lport->port_id, index);
return INVALID_VALUE32;
find:
if (!wwn_rport_info->dfx_counter) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_INFO,
"[info]Port(0x%x) allocate Rport(0x%x) DFX buffer",
v_lport->port_id, wwn_rport_info->rport->nport_id);
wwn_rport_info->dfx_counter =
vmalloc(sizeof(struct unf_wwpn_dfx_counter_info_s));
if (!wwn_rport_info->dfx_counter) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_REG_ATT,
UNF_ERR,
"[err]Port(0x%x) allocate DFX buffer fail",
v_lport->port_id);
return INVALID_VALUE32;
}
memset(wwn_rport_info->dfx_counter, 0,
sizeof(struct unf_wwpn_dfx_counter_info_s));
}
UNF_REFERNCE_VAR(ret);
return index;
}
static unsigned int unf_get_scsi_id_by_wwpn(struct unf_lport_s *v_lport,
unsigned long long v_wwpn)
{
struct unf_rport_scsi_id_image_s *rport_scsi_table = NULL;
struct unf_wwpn_rport_info_s *wwn_rport_info = NULL;
unsigned long flags = 0;
unsigned int index = 0;
UNF_CHECK_VALID(0x3015, UNF_TRUE,
v_lport, return INVALID_VALUE32);
rport_scsi_table = &v_lport->rport_scsi_table;
if (!v_wwpn)
return INVALID_VALUE32;
spin_lock_irqsave(&rport_scsi_table->scsi_image_table_lock, flags);
for (index = 0; index < rport_scsi_table->max_scsi_id; index++) {
wwn_rport_info =
&rport_scsi_table->wwn_rport_info_table[index];
if (v_wwpn == wwn_rport_info->wwpn) {
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
return index;
}
}
spin_unlock_irqrestore(&rport_scsi_table->scsi_image_table_lock,
flags);
return INVALID_VALUE32;
}
static void unf_set_device_state(struct unf_lport_s *v_lport,
unsigned int v_scsi_id,
int en_scsi_state)
{
struct unf_rport_scsi_id_image_s *scsi_image_table = NULL;
struct unf_wwpn_rport_info_s *wwpn_rport_info = NULL;
if (unlikely(v_scsi_id >= UNF_MAX_SCSI_ID)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]Port(0x%x) RPort scsi_id(0x%x) is max than 0x%x",
v_lport->port_id, v_scsi_id, UNF_MAX_SCSI_ID);
return;
}
scsi_image_table = &v_lport->rport_scsi_table;
wwpn_rport_info = &scsi_image_table->wwn_rport_info_table[v_scsi_id];
atomic_set(&wwpn_rport_info->en_scsi_state, en_scsi_state);
}
static void unf_set_rport_state(struct unf_rport_s *v_rport,
enum unf_rport_login_state_e v_states)
{
UNF_CHECK_VALID(0x3055, UNF_TRUE, v_rport, return);
if (v_states != v_rport->rp_state) {
/* Reset R_Port retry count */
v_rport->retries = 0;
}
v_rport->rp_state = v_states;
}
void unf_rport_linkdown(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
/*
* 1. port_logout
* 2. rcvd_rscn_port_not_in_disc
* 3. each_rport_after_rscn
* 4. rcvd_gpnid_rjt
* 5. rport_after_logout(rport is fabric port)
*/
unsigned long flag = 0;
UNF_CHECK_VALID(0x3000, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x3001, UNF_TRUE, v_rport, return);
UNF_REFERNCE_VAR(v_lport);
/* 1. Update R_Port state: Link Down Event --->>> closing state */
spin_lock_irqsave(&v_rport->rport_state_lock, flag);
unf_rport_state_ma(v_rport, UNF_EVENT_RPORT_LINK_DOWN);
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
/* 3. Port enter closing (then enter to Delete) process */
unf_rport_enter_closing(v_rport);
}
static struct unf_rport_s *unf_rport_is_changed(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport,
unsigned int v_sid)
{
if (v_rport) {
/* S_ID or D_ID has been changed */
if ((v_rport->nport_id != v_sid) ||
(v_rport->local_nport_id != v_lport->nport_id)) {
/*
* 1. Swap case: (SID or DID changed):
* Report link down & delete immediately
*/
unf_rport_immediate_linkdown(v_lport, v_rport);
return NULL;
}
}
return v_rport;
}
struct unf_rport_s *unf_rport_set_qualifier_key_reuse(
struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport_by_nport_id,
struct unf_rport_s *v_rport_by_wwpn,
unsigned long long v_wwpn,
unsigned int v_sid)
{
/* Used for HIFC Chip */
struct unf_rport_s *rport = NULL;
struct unf_rport_s *rporta = NULL;
struct unf_rport_s *rportb = NULL;
int bwwpn_flag = 0;
UNF_CHECK_VALID(0x3002, UNF_TRUE, v_lport, return NULL);
/* About R_Port by N_Port_ID */
rporta = unf_rport_is_changed(v_lport, v_rport_by_nport_id, v_sid);
/* About R_Port by WWpn */
rportb = unf_rport_is_changed(v_lport, v_rport_by_wwpn, v_sid);
if (!rporta && !rportb) {
return NULL;
} else if (!rporta && rportb) {
/* 3. Plug case: reuse again */
rport = rportb;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]Port(0x%x) RPort(0x%p) WWPN(0x%llx) S_ID(0x%x) D_ID(0x%x) reused by wwpn",
v_lport->port_id, rport, rport->port_name,
rport->nport_id, rport->local_nport_id);
return rport; /* Get by WWPN */
} else if (rporta && !rportb) {
bwwpn_flag = ((rporta->port_name != v_wwpn) &&
(rporta->port_name != 0) &&
(rporta->port_name != INVALID_VALUE64));
if (bwwpn_flag) {
/* 4. WWPN changed: Report link down
* & delete immediately
*/
unf_rport_immediate_linkdown(v_lport, rporta);
return NULL;
}
/* Updtae WWPN */
rporta->port_name = v_wwpn;
rport = rporta;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]Port(0x%x) RPort(0x%p) WWPN(0x%llx) S_ID(0x%x) D_ID(0x%x) reused by N_Port_ID",
v_lport->port_id,
rport, rport->port_name,
rport->nport_id, rport->local_nport_id);
return rport; /* Get by N_Port_ID */
}
/* 5. Case for A == B && A && B */
if (rporta == rportb) {
rport = rporta;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]Port(0x%x) find the same RPort(0x%p) WWPN(0x%llx) S_ID(0x%x) D_ID(0x%x)",
v_lport->port_id,
rport, rport->port_name,
rport->nport_id, rport->local_nport_id);
return rport;
}
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]port(0x%x) find two duplicate login. rport(A:0x%p, WWPN:0x%llx, S_ID:0x%x, D_ID:0x%x) rport(B:0x%p, WWPN:0x%llx, S_ID:0x%x, D_ID:0x%x)",
v_lport->port_id,
rporta, rporta->port_name,
rporta->nport_id, rporta->local_nport_id,
rportb, rportb->port_name,
rportb->nport_id, rportb->local_nport_id);
/* 6. Case for A != B && A && B */
unf_rport_immediate_linkdown(v_lport, rporta);
unf_rport_immediate_linkdown(v_lport, rportb);
return NULL;
}
struct unf_rport_s *unf_get_rport_by_wwn(struct unf_lport_s *v_lport,
unsigned long long v_wwpn)
{
struct unf_lport_s *lport = NULL;
struct unf_disc_s *disc = NULL;
struct unf_rport_s *rport = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
unsigned long flag = 0;
struct unf_rport_s *find_rport = NULL;
UNF_CHECK_VALID(0x3049, UNF_TRUE, v_lport, return NULL);
lport = (struct unf_lport_s *)v_lport;
disc = &lport->disc;
/* for each r_port from busy_list: compare wwpn(port name) */
spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
list_for_each_safe(node, next_node, &disc->list_busy_rports) {
rport = list_entry(node, struct unf_rport_s, entry_rport);
if (rport && rport->port_name == v_wwpn) {
find_rport = rport;
break;
}
}
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);
return find_rport;
}
struct unf_rport_s *unf_find_valid_rport(struct unf_lport_s *v_lport,
unsigned long long v_wwpn,
unsigned int v_sid)
{
struct unf_rport_s *rport = NULL;
struct unf_rport_s *rport_by_nport_id = NULL;
struct unf_rport_s *rport_by_wwpn = NULL;
unsigned long flags = 0;
UNF_CHECK_VALID(0x3005, UNF_TRUE, v_lport, return NULL);
UNF_CHECK_VALID(0x3006, UNF_TRUE,
v_lport->pfn_unf_qualify_rport, return NULL);
/* Get R_Port by WWN & N_Port_ID */
rport_by_nport_id = unf_get_rport_by_nport_id(v_lport, v_sid);
rport_by_wwpn = unf_get_rport_by_wwn(v_lport, v_wwpn);
/* R_Port check: by WWPN */
if (rport_by_wwpn) {
spin_lock_irqsave(&rport_by_wwpn->rport_state_lock, flags);
if (rport_by_wwpn->nport_id == UNF_FC_FID_FLOGI) {
spin_unlock_irqrestore(
&rport_by_wwpn->rport_state_lock,
flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR,
UNF_LOG_LOGIN_ATT, UNF_INFO,
"[err]Port(0x%x) RPort(0x%p) find by WWPN(0x%llx) is invalid",
v_lport->port_id, rport_by_wwpn, v_wwpn);
rport_by_wwpn = NULL;
} else {
spin_unlock_irqrestore(
&rport_by_wwpn->rport_state_lock,
flags);
}
}
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]Port(0x%x_0x%x) RPort(0x%p) find by N_Port_ID(0x%x) and RPort(0x%p) by WWPN(0x%llx)",
v_lport->port_id, v_lport->nport_id,
rport_by_nport_id, v_sid, rport_by_wwpn, v_wwpn);
/* R_Port validity check: get by WWPN & N_Port_ID */
rport = v_lport->pfn_unf_qualify_rport(v_lport, rport_by_nport_id,
rport_by_wwpn,
v_wwpn, v_sid);
return rport;
}
void unf_rport_delay_login(struct unf_rport_s *v_rport)
{
UNF_CHECK_VALID(0x3009, UNF_TRUE, v_rport, return);
/* Do R_Port recovery: PLOGI or PRLI or LOGO */
unf_rport_error_recovery(v_rport);
}
unsigned int unf_rport_ref_inc(struct unf_rport_s *v_rport)
{
UNF_CHECK_VALID(0x3010, UNF_TRUE,
v_rport, return UNF_RETURN_ERROR);
if (atomic_read(&v_rport->rport_ref_cnt) <= 0) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]Rport(0x%x) reference count is wrong %d",
v_rport->nport_id,
atomic_read(&v_rport->rport_ref_cnt));
return UNF_RETURN_ERROR;
}
atomic_inc(&v_rport->rport_ref_cnt);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
"[info]Rport(0x%x) reference count is %d",
v_rport->nport_id, atomic_read(&v_rport->rport_ref_cnt));
return RETURN_OK;
}
void unf_rport_enter_logo(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
/*
* 1. TMF/ABTS timeout recovery :Y
* 2. L_Port error recovery --->>> larger than retry_count :Y
* 3. R_Port error recovery --->>> larger than retry_count :Y
* 4. Check PLOGI parameters --->>> parameter is error :Y
* 5. PRLI handler --->>> R_Port state is error :Y
* 6. PDISC handler --->>> R_Port state is not PRLI_WAIT :Y
* 7. ADISC handler --->>> R_Port state is not PRLI_WAIT :Y
* 8. PLOGI wait timeout with R_PORT is INI mode :Y
* 9. RCVD GFFID_RJT --->>> R_Port state is INIT :Y
* 10. RCVD GPNID_ACC --->>> R_Port state is error :Y
* 11. Private Loop mode with LOGO case :Y
* 12. P2P mode with LOGO case :Y
* 13. Fabric mode with LOGO case :Y
* 14. RCVD PRLI_ACC with R_Port is INI :Y
* 15. TGT RCVD BLS_REQ with session is error :Y
*/
unsigned long flags = 0;
UNF_CHECK_VALID(0x3013, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x3014, UNF_TRUE, v_rport, return);
spin_lock_irqsave(&v_rport->rport_state_lock, flags);
if ((v_rport->rp_state == UNF_RPORT_ST_CLOSING) ||
(v_rport->rp_state == UNF_RPORT_ST_DELETE)) {
/* 1. Already within Closing or Delete: Do nothing */
spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);
return;
} else if (v_rport->rp_state == UNF_RPORT_ST_LOGO) {
/* 2. Update R_Port state:
* Normal Enter Event --->>> closing state
*/
unf_rport_state_ma(v_rport, UNF_EVENT_RPORT_NORMAL_ENTER);
spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);
/* Send Logo if necessary */
if (unf_send_logo(v_lport, v_rport) != RETURN_OK)
unf_rport_enter_closing(v_rport);
} else {
/*
* 3. Update R_Port state: Link Down Event --->>> closing state
* enter closing state
*/
unf_rport_state_ma(v_rport, UNF_EVENT_RPORT_LINK_DOWN);
spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);
unf_rport_enter_closing(v_rport);
}
}
unsigned int unf_free_scsi_id(struct unf_lport_s *v_lport,
unsigned int v_scsi_id)
{
unsigned long flags = 0;
struct unf_rport_scsi_id_image_s *rport_scsi_table = NULL;
struct unf_wwpn_rport_info_s *wwn_rport_info = NULL;
UNF_CHECK_VALID(0x3016, UNF_TRUE,
v_lport, return UNF_RETURN_ERROR);
if (unlikely(v_lport->b_port_removing == UNF_TRUE)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x_0x%x) is removing and do nothing",
v_lport->port_id, v_lport->nport_id);
return UNF_RETURN_ERROR;
}
if (unlikely(v_scsi_id >= UNF_MAX_SCSI_ID)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]Port(0x%x_0x%x) scsi_id(0x%x) is bigger than %d",
v_lport->port_id, v_lport->nport_id,
v_scsi_id, UNF_MAX_SCSI_ID);
return UNF_RETURN_ERROR;
}
rport_scsi_table = &v_lport->rport_scsi_table;
if (rport_scsi_table->wwn_rport_info_table) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_INFO,
"[warn]Port(0x%x_0x%x) RPort(0x%p) free scsi_id(0x%x) wwpn(0x%llx) target_id(0x%x) succeed",
v_lport->port_id, v_lport->nport_id,
rport_scsi_table->wwn_rport_info_table[v_scsi_id].rport,
v_scsi_id,
rport_scsi_table->wwn_rport_info_table[v_scsi_id].wwpn,
rport_scsi_table->wwn_rport_info_table[v_scsi_id].target_id);
spin_lock_irqsave(&rport_scsi_table->scsi_image_table_lock,
flags);
wwn_rport_info =
&rport_scsi_table->wwn_rport_info_table[v_scsi_id];
if (wwn_rport_info->rport) {
wwn_rport_info->rport->rport = NULL;
wwn_rport_info->rport = NULL;
}
wwn_rport_info->target_id = INVALID_VALUE32;
atomic_set(&wwn_rport_info->en_scsi_state, UNF_SCSI_ST_DEAD);
/* NOTE: remain WWPN/Port_Name unchanged(un-cleared) */
spin_unlock_irqrestore(
&rport_scsi_table->scsi_image_table_lock,
flags);
return RETURN_OK;
}
return UNF_RETURN_ERROR;
}
static void unf_report_ini_linkup_event(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
UNF_CHECK_VALID(0x3031, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x3032, UNF_TRUE, v_rport, return);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_NORMAL, UNF_MAJOR,
"[event]Port(0x%x) RPort(0x%x_0x%p) put INI link up work(%p) to work_queue",
v_lport->port_id, v_rport->nport_id, v_rport,
&v_rport->start_work);
if (unlikely(!queue_work(v_lport->link_event_wq,
&v_rport->start_work))) {
atomic_inc(&v_lport->add_start_work_failed);
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_NORMAL, UNF_ERR,
"[err]Port(0x%x) RPort(0x%x_0x%p) put INI link up to work_queue failed",
v_lport->port_id, v_rport->nport_id, v_rport);
}
}
static void unf_report_ini_linkdown_event(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
unsigned int scsi_id = 0;
struct fc_rport *rport = NULL;
unsigned long flag = 0;
UNF_CHECK_VALID(0x3033, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x3034, UNF_TRUE, v_rport, return);
/*
* 1. set local device(rport/rport_info_table) state
* -------------------------------------------------OFF_LINE
**
* about rport->scsi_id
* valid during rport link up to link down
*/
spin_lock_irqsave(&v_rport->rport_state_lock, flag);
scsi_id = v_rport->scsi_id;
unf_set_device_state(v_lport, scsi_id, UNF_SCSI_ST_OFFLINE);
/* 2. delete scsi's rport */
rport = (struct fc_rport *)v_rport->rport;
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
if (rport) {
fc_remote_port_delete(rport);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_LOGIN_ATT, UNF_KEVENT,
"[event]port(0x%x_0x%x) delete rport(0x%x) wwpn(0x%llx) scsi_id(0x%x) succeed",
v_lport->port_id, v_lport->nport_id,
v_rport->nport_id,
v_rport->port_name, scsi_id);
atomic_inc(&v_lport->scsi_session_del_success);
} else {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
"[info]Port(0x%x_0x%x) delete RPort(0x%x_0x%p) failed",
v_lport->port_id, v_lport->nport_id,
v_rport->nport_id, v_rport);
atomic_inc(&v_lport->scsi_session_del_failed);
}
}
void unf_update_lport_state_by_linkup_event(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport,
unsigned int rport_att)
{
/* Report R_Port Link Up/Down Event */
unsigned long flag = 0;
enum unf_port_state_e en_lport_state = 0;
UNF_CHECK_VALID(0x3019, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x3020, UNF_TRUE, v_rport, return);
spin_lock_irqsave(&v_rport->rport_state_lock, flag);
/* 1. R_Port does not has TGT mode any more */
if (!(rport_att & UNF_FC4_FRAME_PARM_3_TGT) &&
(v_rport->lport_ini_state == UNF_PORT_STATE_LINKUP)) {
v_rport->last_lport_ini_state = v_rport->lport_ini_state;
// L_Port INI mode: Down
v_rport->lport_ini_state = UNF_PORT_STATE_LINKDOWN;
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%x) does not have TGT attribute(0x%x) any more",
v_lport->port_id, v_rport->nport_id, rport_att);
}
/* 2. R_Port with TGT mode, L_Port with INI mode */
if ((rport_att & UNF_FC4_FRAME_PARM_3_TGT) &&
(v_lport->options & UNF_FC4_FRAME_PARM_3_INI)) {
v_rport->last_lport_ini_state = v_rport->lport_ini_state;
// L_Port INI mode: Up
v_rport->lport_ini_state = UNF_PORT_STATE_LINKUP;
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_INFO,
"[warn]Port(0x%x) update INI state with last(0x%x) and now(0x%x)",
v_lport->port_id, v_rport->last_lport_ini_state,
v_rport->lport_ini_state);
}
/* 3. Report L_Port INI/TGT Down/Up event to SCSI */
if (v_rport->last_lport_ini_state == v_rport->lport_ini_state) {
if (v_rport->nport_id < UNF_FC_FID_DOM_MGR) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%x %p) INI state(0x%x) has not been changed",
v_lport->port_id, v_rport->nport_id, v_rport,
v_rport->lport_ini_state);
}
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
return;
}
en_lport_state = v_rport->lport_ini_state;
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
switch (en_lport_state) {
/* Link Down */
case UNF_PORT_STATE_LINKDOWN:
unf_report_ini_linkdown_event(v_lport, v_rport);
break;
/* Link Up */
case UNF_PORT_STATE_LINKUP:
unf_report_ini_linkup_event(v_lport, v_rport);
break;
default:
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x) with unknown link status(0x%x)",
v_lport->port_id, v_rport->lport_ini_state);
break;
}
}
static void unf_rport_call_back(void *v_rport,
void *v_lport,
unsigned int v_result)
{
/* Report R_Port link down event */
struct unf_rport_s *rport = NULL;
struct unf_lport_s *lport = NULL;
unsigned long flag = 0;
UNF_REFERNCE_VAR(lport);
UNF_REFERNCE_VAR(v_result);
UNF_CHECK_VALID(0x3037, UNF_TRUE, v_rport, return);
UNF_CHECK_VALID(0x3038, UNF_TRUE, v_lport, return);
rport = (struct unf_rport_s *)v_rport;
lport = (struct unf_lport_s *)v_lport;
spin_lock_irqsave(&rport->rport_state_lock, flag);
rport->last_lport_ini_state = rport->lport_ini_state;
rport->lport_ini_state = UNF_PORT_STATE_LINKDOWN;
rport->last_lport_tgt_state = rport->lport_tgt_state;
rport->lport_tgt_state = UNF_PORT_STATE_LINKDOWN;
/* Report R_Port Link Down Event to scsi */
if (rport->last_lport_ini_state == rport->lport_ini_state) {
if (rport->nport_id < UNF_FC_FID_DOM_MGR) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%x %p) INI state(0x%x) has not been changed",
lport->port_id, rport->nport_id, rport,
rport->lport_ini_state);
}
spin_unlock_irqrestore(&rport->rport_state_lock, flag);
return;
}
spin_unlock_irqrestore(&rport->rport_state_lock, flag);
unf_report_ini_linkdown_event(lport, rport);
}
static void unf_rport_recovery_timeout(struct work_struct *v_work)
{
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
unsigned int ret = RETURN_OK;
unsigned long flag = 0;
enum unf_rport_login_state_e en_rp_state = UNF_RPORT_ST_INIT;
UNF_CHECK_VALID(0x3039, UNF_TRUE, v_work, return);
rport = container_of(v_work, struct unf_rport_s, recovery_work.work);
if (unlikely(!rport)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT,
UNF_ERR, "[err]RPort is NULL");
return;
}
lport = rport->lport;
if (unlikely(!lport)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]RPort(0x%x) Port is NULL",
rport->nport_id);
/* for timer */
unf_rport_ref_dec(rport);
return;
}
spin_lock_irqsave(&rport->rport_state_lock, flag);
en_rp_state = rport->rp_state;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]Port(0x%x_0x%x) RPort(0x%x) state(0x%x) recovery timer timeout",
lport->port_id, lport->nport_id,
rport->nport_id, en_rp_state);
spin_unlock_irqrestore(&rport->rport_state_lock, flag);
switch (en_rp_state) {
case UNF_RPORT_ST_PLOGI_WAIT:
if (((lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT) &&
(lport->port_name > rport->port_name)) ||
lport->en_act_topo != UNF_ACT_TOP_P2P_DIRECT) {
/* P2P: Name is master with P2P_D or has INI Mode */
ret = unf_send_plogi(rport->lport, rport);
}
break;
case UNF_RPORT_ST_PRLI_WAIT:
ret = unf_send_prli(rport->lport, rport);
break;
default:
break;
}
if (ret != RETURN_OK)
unf_rport_error_recovery(rport);
/* company with timer */
unf_rport_ref_dec(rport);
}
static unsigned int unf_get_dev_loss_tmo_by_rport(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
struct fc_rport *rport = (struct fc_rport *)v_rport->rport;
if (rport)
return rport->dev_loss_tmo;
else
return (unsigned int)unf_get_link_lose_tmo(v_lport);
}
void unf_schedule_closing_work(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
unsigned long flags = 0;
struct unf_rport_scsi_id_image_s *rport_scsi_table = NULL;
struct unf_wwpn_rport_info_s *wwn_rport_info = NULL;
unsigned int scsi_id = 0;
unsigned int ret = 0;
unsigned int delay = 0;
UNF_CHECK_VALID(0x3561, UNF_TRUE, v_lport, return);
UNF_CHECK_VALID(0x3562, UNF_TRUE, v_rport, return);
delay = unf_get_dev_loss_tmo_by_rport(v_lport, v_rport);
rport_scsi_table = &v_lport->rport_scsi_table;
scsi_id = v_rport->scsi_id;
spin_lock_irqsave(&v_rport->rport_state_lock, flags);
/* 1. Cancel recovery_work */
if (cancel_delayed_work(&v_rport->recovery_work)) {
atomic_dec(&v_rport->rport_ref_cnt);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]Port(0x%x_0x%x) RPort(0x%x_0x%p) cancel recovery work succeed",
v_lport->port_id, v_lport->nport_id,
v_rport->nport_id, v_rport);
}
/* 2. Cancel Open_work */
if (cancel_delayed_work(&v_rport->open_work)) {
atomic_dec(&v_rport->rport_ref_cnt);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]Port(0x%x_0x%x) RPort(0x%x_0x%p) cancel open work succeed",
v_lport->port_id, v_lport->nport_id,
v_rport->nport_id, v_rport);
}
spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);
/* 3. Work in-queue (switch to thread context) */
if (!queue_work(v_lport->link_event_wq, &v_rport->closing_work)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_NORMAL, UNF_ERR,
"[warn]Port(0x%x) RPort(0x%x_0x%p) add link down to work queue failed",
v_lport->port_id, v_rport->nport_id, v_rport);
atomic_inc(&v_lport->add_closing_work_failed);
} else {
spin_lock_irqsave(&v_rport->rport_state_lock, flags);
(void)unf_rport_ref_inc(v_rport);
spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_NORMAL, UNF_MAJOR,
"[info]Port(0x%x) RPort(0x%x_0x%p) add link down to work(%p) queue succeed",
v_lport->port_id, v_rport->nport_id, v_rport,
&v_rport->closing_work);
}
if (v_rport->nport_id > UNF_FC_FID_DOM_MGR)
return;
if (scsi_id >= UNF_MAX_SCSI_ID) {
scsi_id = unf_get_scsi_id_by_wwpn(v_lport, v_rport->port_name);
if (scsi_id >= UNF_MAX_SCSI_ID) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
UNF_LOG_NORMAL, UNF_WARN,
"[warn]Port(0x%x) RPort(0x%p) NPortId(0x%x) wwpn(0x%llx) option(0x%x) scsi_id(0x%x) is max than(0x%x)",
v_lport->port_id, v_rport, v_rport->nport_id,
v_rport->port_name,
v_rport->options, scsi_id,
UNF_MAX_SCSI_ID);
return;
}
}
wwn_rport_info = &rport_scsi_table->wwn_rport_info_table[scsi_id];
ret = queue_delayed_work(
unf_work_queue,
&wwn_rport_info->loss_tmo_work,
(unsigned long)delay * msecs_to_jiffies(1000));
if (!ret) {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_NORMAL, UNF_MAJOR,
"[info] Port(0x%x) add RPort(0x%p) NPortId(0x%x) scsi_id(0x%x) wwpn(0x%llx) loss timeout work failed",
v_lport->port_id, v_rport,
v_rport->nport_id, scsi_id,
v_rport->port_name);
}
}
static void unf_rport_closing_timeout(struct work_struct *v_work)
{
/* closing --->>>(timeout)--->>> delete */
struct unf_rport_s *rport = NULL;
struct unf_lport_s *lport = NULL;
struct unf_disc_s *disc = NULL;
unsigned long rport_flag = 0;
unsigned long disc_flag = 0;
void (*pfn_unf_rport_call_back)(void *, void *, unsigned int) = NULL;
UNF_CHECK_VALID(0x3040, UNF_TRUE, v_work, return);
/* Get R_Port & L_Port & Disc */
rport = container_of(v_work, struct unf_rport_s, closing_work);
if (unlikely(!rport)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT,
UNF_ERR, "[err]RPort is NULL");
return;
}
lport = rport->lport;
if (unlikely(!lport)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]RPort(0x%x_0x%p) Port is NULL",
rport->nport_id, rport);
/* Release directly (for timer) */
unf_rport_ref_dec(rport);
return;
}
disc = &lport->disc;
spin_lock_irqsave(&rport->rport_state_lock, rport_flag);
/* 1. Update R_Port state: event_timeout --->>> state_delete */
unf_rport_state_ma(rport, UNF_EVENT_RPORT_CLS_TIMEOUT);
/* Check R_Port state */
if (rport->rp_state != UNF_RPORT_ST_DELETE) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]Port(0x%x_0x%x) RPort(0x%x) closing timeout with error state(0x%x)",
lport->port_id, lport->nport_id,
rport->nport_id, rport->rp_state);
spin_unlock_irqrestore(&rport->rport_state_lock, rport_flag);
/* Dec ref_cnt for timer */
unf_rport_ref_dec(rport);
return;
}
pfn_unf_rport_call_back = rport->pfn_unf_rport_call_back;
spin_unlock_irqrestore(&rport->rport_state_lock, rport_flag);
/* 2. Put R_Port to delete list */
spin_lock_irqsave(&disc->rport_busy_pool_lock, disc_flag);
list_del_init(&rport->entry_rport);
list_add_tail(&rport->entry_rport, &disc->list_delete_rports);
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, disc_flag);
/* 3. Report rport link down event to scsi */
if (pfn_unf_rport_call_back) { /* unf_rport_call_back */
pfn_unf_rport_call_back((void *)rport, (void *)rport->lport,
RETURN_OK);
} else {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]RPort(0x%x) callback is NULL",
rport->nport_id);
}
/* 4. Remove/delete R_Port */
unf_rport_ref_dec(rport);
unf_rport_ref_dec(rport);
}
static void unf_rport_linkup_to_scsi(struct work_struct *v_work)
{
struct fc_rport_identifiers rport_ids;
struct fc_rport *rport = NULL;
unsigned long flags = RETURN_OK;
struct unf_wwpn_rport_info_s *wwn_rport_info = NULL;
struct unf_rport_scsi_id_image_s *rport_scsi_table = NULL;
unsigned int scsi_id = 0;
struct unf_lport_s *lport = NULL;
struct unf_rport_s *unf_rport = NULL;
UNF_CHECK_VALID(0x3040, UNF_TRUE, v_work, return);
unf_rport = container_of(v_work, struct unf_rport_s, start_work);
if (unlikely(!unf_rport)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]RPort is NULL for work(%p)", v_work);
return;
}
lport = unf_rport->lport;
if (unlikely(!lport)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]RPort(0x%x_0x%p) Port is NULL",
unf_rport->nport_id, unf_rport);
return;
}
/* 1. Alloc R_Port SCSI_ID (image table) */
unf_rport->scsi_id = unf_alloc_scsi_id(lport, unf_rport);
if (unlikely(unf_rport->scsi_id == INVALID_VALUE32)) {
atomic_inc(&lport->scsi_session_add_failed);
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[err]Port(0x%x_0x%x) RPort(0x%x_0x%p) wwpn(0x%llx) scsi_id(0x%x) is invalid",
lport->port_id, lport->nport_id,
unf_rport->nport_id, unf_rport,
unf_rport->port_name, unf_rport->scsi_id);
/* NOTE: return */
return;
}
/* 2. Add rport to scsi */
scsi_id = unf_rport->scsi_id;
rport_ids.node_name = unf_rport->node_name;
rport_ids.port_name = unf_rport->port_name;
rport_ids.port_id = unf_rport->nport_id;
rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
rport = fc_remote_port_add(lport->host_info.p_scsi_host,
0, &rport_ids);
if (unlikely(!rport)) {
atomic_inc(&lport->scsi_session_add_failed);
UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
"[err]Port(0x%x_0x%x) RPort(0x%x_0x%p) wwpn(0x%llx) report link up to scsi failed",
lport->port_id, lport->nport_id,
unf_rport->nport_id, unf_rport,
unf_rport->port_name);
unf_free_scsi_id(lport, scsi_id);
return;
}
/* 3. Change rport role save local SCSI_ID to scsi rport */
*((unsigned int *)rport->dd_data) = scsi_id;
rport->supported_classes = FC_COS_CLASS3;
rport_ids.roles |= FC_PORT_ROLE_FCP_TARGET;
fc_remote_port_rolechg(rport, rport_ids.roles);
/* 4. Save scsi rport info to local R_Port */
spin_lock_irqsave(&unf_rport->rport_state_lock, flags);
unf_rport->rport = rport;
spin_unlock_irqrestore(&unf_rport->rport_state_lock, flags);
rport_scsi_table = &lport->rport_scsi_table;
spin_lock_irqsave(&rport_scsi_table->scsi_image_table_lock, flags);
wwn_rport_info = &rport_scsi_table->wwn_rport_info_table[scsi_id];
wwn_rport_info->target_id = rport->scsi_target_id;
wwn_rport_info->rport = unf_rport;
atomic_set(&wwn_rport_info->en_scsi_state, UNF_SCSI_ST_ONLINE);
spin_unlock_irqrestore(&rport_scsi_table->scsi_image_table_lock,
flags);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
"[event]port(0x%x_0x%x) rport(0x%x) wwpn(0x%llx) scsi_id(0x%x) link up to scsi succeed",
lport->port_id, lport->nport_id,
unf_rport->nport_id, unf_rport->port_name,
scsi_id);
atomic_inc(&lport->scsi_session_add_success);
}
static void unf_rport_open_timeout(struct work_struct *v_work)
{
struct unf_rport_s *rport = NULL;
struct unf_lport_s *lport = NULL;
unsigned long flags = 0;
UNF_CHECK_VALID(0x3041, UNF_TRUE, v_work, return);
rport = container_of(v_work, struct unf_rport_s, open_work.work);
if (!rport) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort is NULL");
return;
}
spin_lock_irqsave(&rport->rport_state_lock, flags);
lport = rport->lport;
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x_0x%x) RPort(0x%x) open work timeout with state(0x%x)",
lport->port_id, lport->nport_id,
rport->nport_id, rport->rp_state);
/* NOTE: R_Port state check */
if (rport->rp_state != UNF_RPORT_ST_PRLI_WAIT) {
spin_unlock_irqrestore(&rport->rport_state_lock, flags);
/* Dec ref_cnt for timer case */
unf_rport_ref_dec(rport);
return;
}
/* Report R_Port Link Down event */
unf_rport_state_ma(rport, UNF_EVENT_RPORT_LINK_DOWN);
spin_unlock_irqrestore(&rport->rport_state_lock, flags);
unf_rport_enter_closing(rport);
/* Dec ref_cnt for timer case */
unf_rport_ref_dec(rport);
UNF_REFERNCE_VAR(lport);
}
static unsigned int unf_alloc_index_for_rport(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport)
{
unsigned long rport_flag = 0;
unsigned long pool_flag = 0;
unsigned int alloc_indx = 0;
unsigned int max_rport = 0;
struct unf_rport_pool_s *rport_pool = NULL;
rport_pool = &v_lport->rport_pool;
max_rport = v_lport->low_level_func.lport_cfg_items.max_login;
spin_lock_irqsave(&rport_pool->rport_free_pool_lock, pool_flag);
while (alloc_indx < max_rport) {
if (!test_bit((int)alloc_indx, rport_pool->pul_rpi_bitmap)) {
/* Case for HIFC */
if (unlikely(atomic_read(
&v_lport->port_no_operater_flag) ==
UNF_LPORT_NOP)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x) is within NOP",
v_lport->port_id);
spin_unlock_irqrestore(
&rport_pool->rport_free_pool_lock,
pool_flag);
return UNF_RETURN_ERROR;
}
spin_lock_irqsave(&v_rport->rport_state_lock,
rport_flag);
/* set R_Port index */
v_rport->rport_index = alloc_indx;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
UNF_LOG_LOGIN_ATT, UNF_INFO,
"[info]Port(0x%x) RPort(0x%x) alloc index(0x%x) succeed",
v_lport->port_id, alloc_indx,
v_rport->nport_id);
spin_unlock_irqrestore(&v_rport->rport_state_lock,
rport_flag);
/* Set (index) bit */
set_bit((int)alloc_indx, rport_pool->pul_rpi_bitmap);
/* Break here */
break;
}
alloc_indx++;
}
spin_unlock_irqrestore(&rport_pool->rport_free_pool_lock, pool_flag);
if (alloc_indx == max_rport)
return UNF_RETURN_ERROR;
else
return RETURN_OK;
}
static void unf_check_rport_pool_status(struct unf_lport_s *v_lport)
{
struct unf_lport_s *lport = v_lport;
struct unf_rport_pool_s *rport_pool = NULL;
unsigned long flags = 0;
unsigned int max_rport = 0;
UNF_CHECK_VALID(0x3045, UNF_TRUE, v_lport, return);
rport_pool = &lport->rport_pool;
spin_lock_irqsave(&rport_pool->rport_free_pool_lock, flags);
max_rport = lport->low_level_func.lport_cfg_items.max_login;
if ((rport_pool->rport_pool_completion) &&
(max_rport == rport_pool->rport_pool_count)) {
complete(rport_pool->rport_pool_completion);
}
spin_unlock_irqrestore(&rport_pool->rport_free_pool_lock, flags);
}
void unf_init_rport_params(struct unf_rport_s *v_rport,
struct unf_lport_s *v_lport)
{
struct unf_rport_s *rport = v_rport;
unsigned long flag = 0;
UNF_CHECK_VALID(0x3046, UNF_TRUE, rport, return);
UNF_CHECK_VALID(0x3046, UNF_TRUE, v_lport, return);
spin_lock_irqsave(&rport->rport_state_lock, flag);
unf_set_rport_state(rport, UNF_RPORT_ST_INIT);
/* set callback function */
rport->pfn_unf_rport_call_back = unf_rport_call_back;
rport->lport = v_lport;
rport->fcp_conf_needed = UNF_FALSE;
rport->tape_support_needed = UNF_FALSE;
rport->mas_retries = UNF_MAX_RETRY_COUNT;
rport->logo_retries = 0;
rport->retries = 0;
rport->rscn_position = UNF_RPORT_NOT_NEED_PROCESS;
rport->last_lport_ini_state = UNF_PORT_STATE_LINKDOWN;
rport->lport_ini_state = UNF_PORT_STATE_LINKDOWN;
rport->last_lport_tgt_state = UNF_PORT_STATE_LINKDOWN;
rport->lport_tgt_state = UNF_PORT_STATE_LINKDOWN;
rport->node_name = 0;
rport->port_name = INVALID_WWPN;
rport->disc_done = 0;
rport->scsi_id = INVALID_VALUE32;
rport->data_thread = NULL;
sema_init(&rport->task_sema, 0);
atomic_set(&rport->rport_ref_cnt, 0);
atomic_set(&rport->pending_io_cnt, 0);
rport->rport_alloc_jifs = jiffies;
rport->ed_tov = UNF_DEFAULT_EDTOV + 500;
rport->ra_tov = UNF_DEFAULT_RATOV;
INIT_WORK(&rport->closing_work, unf_rport_closing_timeout);
INIT_WORK(&rport->start_work, unf_rport_linkup_to_scsi);
INIT_DELAYED_WORK(&rport->recovery_work, unf_rport_recovery_timeout);
INIT_DELAYED_WORK(&rport->open_work, unf_rport_open_timeout);
atomic_inc(&rport->rport_ref_cnt);
spin_unlock_irqrestore(&rport->rport_state_lock, flag);
}
static unsigned int unf_alloc_llrport_resource(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport,
unsigned int v_nport_id)
{
unsigned int ret = RETURN_OK;
struct unf_rport_info_s rport_info = { 0 };
struct unf_lport_s *lport = NULL;
lport = v_lport->root_lport;
if (lport->low_level_func.service_op.pfn_unf_alloc_rport_res) {
rport_info.nport_id = v_nport_id;
rport_info.rport_index = v_rport->rport_index;
rport_info.local_nport_id = v_lport->nport_id; /* sid */
rport_info.port_name = 0;
ret = lport->low_level_func.service_op.pfn_unf_alloc_rport_res(
lport->fc_port,
&rport_info);
} else {
ret = RETURN_OK;
}
return ret;
}
static void *unf_add_rport_to_busy_list(struct unf_lport_s *v_lport,
struct unf_rport_s *v_new_rport,
unsigned int v_nport_id)
{
struct unf_rport_pool_s *rport_pool = NULL;
struct unf_lport_s *lport = NULL;
struct unf_disc_s *disc = NULL;
struct unf_rport_s *new_rport = v_new_rport;
struct unf_rport_s *old_rport = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
unsigned long flag = 0;
UNF_CHECK_VALID(0x3046, UNF_TRUE, v_lport, return NULL);
UNF_CHECK_VALID(0x3046, UNF_TRUE, v_new_rport, return NULL);
lport = v_lport->root_lport;
disc = &v_lport->disc;
UNF_CHECK_VALID(0x3046, UNF_TRUE, lport, return NULL);
rport_pool = &lport->rport_pool;
spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
list_for_each_safe(node, next_node, &disc->list_busy_rports) {
/* According to N_Port_ID */
old_rport = list_entry(node, struct unf_rport_s, entry_rport);
if (old_rport->nport_id == v_nport_id)
break; /* find by N_Port_ID */
old_rport = NULL;
}
if (old_rport) {
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);
/* Use old R_Port & Add new R_Port back to R_Port Pool */
spin_lock_irqsave(&rport_pool->rport_free_pool_lock, flag);
clear_bit((int)new_rport->rport_index,
rport_pool->pul_rpi_bitmap);
list_add_tail(&new_rport->entry_rport,
&rport_pool->list_rports_pool);
rport_pool->rport_pool_count++;
spin_unlock_irqrestore(&rport_pool->rport_free_pool_lock,
flag);
unf_check_rport_pool_status(lport);
return (void *)old_rport;
}
if (unf_alloc_llrport_resource(v_lport, new_rport,
v_nport_id != RETURN_OK)) {
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);
/* Add new R_Port back to R_Port Pool */
spin_lock_irqsave(&rport_pool->rport_free_pool_lock, flag);
clear_bit((int)new_rport->rport_index,
rport_pool->pul_rpi_bitmap);
list_add_tail(&new_rport->entry_rport,
&rport_pool->list_rports_pool);
rport_pool->rport_pool_count++;
spin_unlock_irqrestore(
&rport_pool->rport_free_pool_lock, flag);
unf_check_rport_pool_status(lport);
return NULL;
}
/* Add new R_Port to busy list */
list_add_tail(&new_rport->entry_rport,
&disc->list_busy_rports);
new_rport->nport_id = v_nport_id; /* set R_Port N_Port_ID */
/* set L_Port N_Port_ID */
new_rport->local_nport_id = v_lport->nport_id;
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);
unf_init_rport_params(new_rport, v_lport);
return (void *)new_rport;
}
void *unf_rport_get_free_and_init(void *v_lport,
unsigned int v_rport_type,
unsigned int v_nport_id)
{
struct unf_lport_s *lport = NULL;
struct unf_rport_pool_s *rport_pool = NULL;
struct unf_disc_s *disc = NULL;
struct unf_disc_s *v_port_disc = NULL;
struct unf_rport_s *rport = NULL;
struct list_head *list_head = NULL;
unsigned long flag = 0;
struct unf_disc_rport_s *disc_rport = NULL;
UNF_REFERNCE_VAR(v_rport_type);
UNF_REFERNCE_VAR(rport);
UNF_CHECK_VALID(0x3046, UNF_TRUE, v_lport, return NULL);
lport = ((struct unf_lport_s *)v_lport)->root_lport; /* ROOT L_Port */
UNF_CHECK_VALID(0x3047, UNF_TRUE, lport, return NULL);
/* Check L_Port state: NOP */
if (unlikely(atomic_read(&lport->port_no_operater_flag) ==
UNF_LPORT_NOP)) {
return NULL;
}
rport_pool = &lport->rport_pool;
disc = &lport->disc;
/* 1. UNF_PORT_TYPE_DISC: Get from disc_rport_pool */
if (v_rport_type == UNF_PORT_TYPE_DISC) {
v_port_disc = &(((struct unf_lport_s *)v_lport)->disc);
/* NOTE: list_disc_rports_pool used
* with list_disc_rport_busy
*/
spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
if (!list_empty(&disc->disc_rport_mgr.list_disc_rports_pool)) {
/* Get & delete from Disc R_Port Pool &
* Add it to Busy list
*/
list_head =
(&disc->disc_rport_mgr.list_disc_rports_pool)->next;
list_del_init(list_head);
disc_rport = list_entry(list_head,
struct unf_disc_rport_s,
entry_rport);
/* Set R_Port N_Port_ID */
disc_rport->nport_id = v_nport_id;
spin_unlock_irqrestore(&disc->rport_busy_pool_lock,
flag);
/* Add to list_disc_rport_busy */
spin_lock_irqsave(&v_port_disc->rport_busy_pool_lock,
flag);
list_add_tail(
list_head,
&v_port_disc->disc_rport_mgr.list_disc_rport_busy);
spin_unlock_irqrestore(
&v_port_disc->rport_busy_pool_lock, flag);
} else {
disc_rport = NULL;
spin_unlock_irqrestore(&disc->rport_busy_pool_lock,
flag);
}
/* NOTE: return */
return disc_rport;
}
/* 2. UNF_PORT_TYPE_FC (rport_pool): Get from list_rports_pool */
spin_lock_irqsave(&rport_pool->rport_free_pool_lock, flag);
if (!list_empty(&rport_pool->list_rports_pool)) {
/* Get & delete from R_Port free Pool */
list_head = (&rport_pool->list_rports_pool)->next;
list_del_init(list_head);
rport_pool->rport_pool_count--;
rport = list_entry(list_head, struct unf_rport_s, entry_rport);
} else {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x_0x%x) RPort pool is empty",
lport->port_id, lport->nport_id);
spin_unlock_irqrestore(&rport_pool->rport_free_pool_lock,
flag);
/* NOTE: return */
return NULL;
}
spin_unlock_irqrestore(&rport_pool->rport_free_pool_lock, flag);
/* 3. Alloc (& set bit) R_Port index */
if (unf_alloc_index_for_rport(lport, rport) != RETURN_OK) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]Port(0x%x) allocate index for new RPort failed",
lport->nport_id);
/* Alloc failed: Add R_Port back to R_Port Pool */
spin_lock_irqsave(&rport_pool->rport_free_pool_lock, flag);
list_add_tail(&rport->entry_rport,
&rport_pool->list_rports_pool);
rport_pool->rport_pool_count++;
spin_unlock_irqrestore(&rport_pool->rport_free_pool_lock,
flag);
unf_check_rport_pool_status(lport);
return NULL;
}
/* 4. Add R_Port to busy list */
rport = unf_add_rport_to_busy_list(v_lport, rport, v_nport_id);
UNF_REFERNCE_VAR(rport);
return (void *)rport;
}
static void unf_reset_rport_attribute(struct unf_rport_s *v_rport)
{
unsigned long flag = 0;
UNF_CHECK_VALID(0x3070, 1, v_rport, return);
spin_lock_irqsave(&v_rport->rport_state_lock, flag);
v_rport->pfn_unf_rport_call_back = NULL;
v_rport->lport = NULL;
v_rport->node_name = INVALID_VALUE64;
v_rport->port_name = INVALID_WWPN;
v_rport->nport_id = INVALID_VALUE32;
v_rport->local_nport_id = INVALID_VALUE32;
v_rport->max_frame_size = UNF_MAX_FRAME_SIZE;
v_rport->ed_tov = UNF_DEFAULT_EDTOV;
v_rport->ra_tov = UNF_DEFAULT_RATOV;
v_rport->rport_index = INVALID_VALUE32;
v_rport->scsi_id = INVALID_VALUE32;
v_rport->rport_alloc_jifs = INVALID_VALUE64;
/* ini or tgt */
v_rport->options = 0;
/* fcp conf */
v_rport->fcp_conf_needed = UNF_FALSE;
/* special req retry times */
v_rport->retries = 0;
v_rport->logo_retries = 0;
/* special req retry times */
v_rport->mas_retries = UNF_MAX_RETRY_COUNT;
/* for target mode */
v_rport->session = NULL;
v_rport->last_lport_ini_state = UNF_PORT_STATE_LINKDOWN;
v_rport->lport_ini_state = UNF_PORT_STATE_LINKDOWN;
v_rport->rp_state = UNF_RPORT_ST_INIT;
v_rport->last_lport_tgt_state = UNF_PORT_STATE_LINKDOWN;
v_rport->lport_tgt_state = UNF_PORT_STATE_LINKDOWN;
v_rport->rscn_position = UNF_RPORT_NOT_NEED_PROCESS;
v_rport->disc_done = 0;
/* for scsi */
v_rport->data_thread = NULL;
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
}
static unsigned int unf_rport_remove(void *v_rport)
{
/* remove_old_rport/... --->>> rport_ref_dec --->>> rport_remove */
struct unf_lport_s *lport = NULL;
struct unf_rport_s *rport = NULL;
struct unf_rport_pool_s *rport_pool = NULL;
unsigned long flag = 0;
unsigned int rport_index = 0;
UNF_CHECK_VALID(0x3050, UNF_TRUE,
v_rport, return UNF_RETURN_ERROR);
rport = (struct unf_rport_s *)v_rport;
lport = rport->lport;
UNF_CHECK_VALID(0x3051, UNF_TRUE,
lport, return UNF_RETURN_ERROR);
rport_pool = &((struct unf_lport_s *)lport->root_lport)->rport_pool;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
"[info]Remove RPort(0x%p) with remote_nport_id(0x%x) local_nport_id(0x%x)",
rport, rport->nport_id, rport->local_nport_id);
/* 1. Terminate open exchange before rport remove: set ABORT tag */
unf_cm_xchg_mgr_abort_io_by_id(lport, rport,
rport->nport_id, lport->nport_id, 0);
/* 2. Abort sfp exchange before rport remove */
unf_cm_xchg_mgr_abort_sfs_by_id(lport, rport,
rport->nport_id, lport->nport_id);
/* 3. Release R_Port resource: session reset/delete */
(void)unf_release_rport_res(lport, rport);
/* 4.1 Delete R_Port from disc destroy/delete list */
spin_lock_irqsave(&lport->disc.rport_busy_pool_lock, flag);
list_del_init(&rport->entry_rport);
spin_unlock_irqrestore(&lport->disc.rport_busy_pool_lock, flag);
rport_index = rport->rport_index; /* according to bitmap */
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
"[event]Port(0x%x) release RPort(0x%x_%p) with index(0x%x)",
lport->port_id, rport->nport_id, rport, rport->rport_index);
unf_reset_rport_attribute(rport);
/* 4.2 Add rport to --->>> rport_pool (free pool) & clear bitmap */
spin_lock_irqsave(&rport_pool->rport_free_pool_lock, flag);
if (lport->low_level_func.rport_release_type ==
UNF_LOW_LEVEL_RELEASE_RPORT_SYNC) {
clear_bit((int)rport_index, rport_pool->pul_rpi_bitmap);
}
list_add_tail(&rport->entry_rport, &rport_pool->list_rports_pool);
rport_pool->rport_pool_count++;
spin_unlock_irqrestore(&rport_pool->rport_free_pool_lock, flag);
unf_check_rport_pool_status((struct unf_lport_s *)lport->root_lport);
up(&rport->task_sema);
return RETURN_OK;
}
void unf_rport_ref_dec(struct unf_rport_s *v_rport)
{
unsigned long flag = 0;
UNF_CHECK_VALID(0x3011, UNF_TRUE, v_rport, return);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
"[info]Rport(0x%x) reference count is %d",
v_rport->nport_id, atomic_read(&v_rport->rport_ref_cnt));
spin_lock_irqsave(&v_rport->rport_state_lock, flag);
if (atomic_dec_and_test(&v_rport->rport_ref_cnt)) {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
(void)unf_rport_remove(v_rport);
} else {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
}
}
static enum unf_rport_login_state_e unf_rport_stat_init(
enum unf_rport_login_state_e v_old_state,
enum unf_rport_event_e v_event)
{
enum unf_rport_login_state_e en_next_state = UNF_RPORT_ST_INIT;
switch (v_event) {
case UNF_EVENT_RPORT_LOGO: /* LOGO --->>> LOGO */
en_next_state = UNF_RPORT_ST_LOGO;
break;
case UNF_EVENT_RPORT_ENTER_PLOGI: /* PLOGI --->>> PLOGI_WAIT */
en_next_state = UNF_RPORT_ST_PLOGI_WAIT;
break;
case UNF_EVENT_RPORT_LINK_DOWN: /* Link Down --->>> Closing */
en_next_state = UNF_RPORT_ST_CLOSING;
break;
default:
en_next_state = v_old_state;
break;
}
return en_next_state;
}
static enum unf_rport_login_state_e unf_rport_stat_plogi_wait(
enum unf_rport_login_state_e v_old_state,
enum unf_rport_event_e v_event)
{
enum unf_rport_login_state_e en_next_state = UNF_RPORT_ST_INIT;
switch (v_event) {
case UNF_EVENT_RPORT_ENTER_PRLI: /* PRLI --->>> PRLI_WAIT */
en_next_state = UNF_RPORT_ST_PRLI_WAIT;
break;
case UNF_EVENT_RPORT_LINK_DOWN: /* Link Down --->>> closing */
en_next_state = UNF_RPORT_ST_CLOSING;
break;
case UNF_EVENT_RPORT_LOGO: /* LOGO --->>> LOGO */
en_next_state = UNF_RPORT_ST_LOGO;
break;
case UNF_EVENT_RPORT_RECOVERY: /* Recovery --->>> Ready */
en_next_state = UNF_RPORT_ST_READY;
break;
default:
en_next_state = v_old_state;
break;
}
return en_next_state;
}
static enum unf_rport_login_state_e unf_rport_stat_prli_wait(
enum unf_rport_login_state_e v_old_state,
enum unf_rport_event_e v_event)
{
enum unf_rport_login_state_e en_next_state = UNF_RPORT_ST_INIT;
switch (v_event) {
case UNF_EVENT_RPORT_READY: /* Ready --->>> Ready */
en_next_state = UNF_RPORT_ST_READY;
break;
case UNF_EVENT_RPORT_LOGO: /* LOGO --->>> LOGO */
en_next_state = UNF_RPORT_ST_LOGO;
break;
case UNF_EVENT_RPORT_LINK_DOWN: /* Link Down --->>> Closing */
en_next_state = UNF_RPORT_ST_CLOSING;
break;
case UNF_EVENT_RPORT_RECOVERY: /* Recovery --->>> Ready */
en_next_state = UNF_RPORT_ST_READY;
break;
default:
en_next_state = v_old_state;
break;
}
return en_next_state;
}
static enum unf_rport_login_state_e unf_rport_stat_ready(
enum unf_rport_login_state_e v_old_state,
enum unf_rport_event_e v_event)
{
enum unf_rport_login_state_e en_next_state = UNF_RPORT_ST_INIT;
switch (v_event) {
case UNF_EVENT_RPORT_LOGO: /* LOGO --->>> LOGO */
en_next_state = UNF_RPORT_ST_LOGO;
break;
case UNF_EVENT_RPORT_LINK_DOWN: /* Link Down --->>> closing */
en_next_state = UNF_RPORT_ST_CLOSING;
break;
case UNF_EVENT_RPORT_ENTER_PLOGI: /* ready --->>> plogi_wait */
en_next_state = UNF_RPORT_ST_PLOGI_WAIT;
break;
default:
en_next_state = v_old_state;
break;
}
return en_next_state;
}
static enum unf_rport_login_state_e unf_rport_stat_closing(
enum unf_rport_login_state_e v_old_state,
enum unf_rport_event_e v_event)
{
enum unf_rport_login_state_e en_next_state = UNF_RPORT_ST_INIT;
switch (v_event) {
case UNF_EVENT_RPORT_CLS_TIMEOUT: /* timeout --->>> delete */
en_next_state = UNF_RPORT_ST_DELETE;
break;
case UNF_EVENT_RPORT_RELOGIN: /* relogin --->>> INIT */
en_next_state = UNF_RPORT_ST_INIT;
break;
case UNF_EVENT_RPORT_RECOVERY: /* recovery --->>> ready */
en_next_state = UNF_RPORT_ST_READY;
break;
default:
en_next_state = v_old_state;
break;
}
return en_next_state;
}
static enum unf_rport_login_state_e unf_rport_stat_logo(
enum unf_rport_login_state_e v_old_state,
enum unf_rport_event_e v_event)
{
enum unf_rport_login_state_e en_next_state = UNF_RPORT_ST_INIT;
switch (v_event) {
case UNF_EVENT_RPORT_NORMAL_ENTER: /* normal enter --->>> closing */
en_next_state = UNF_RPORT_ST_CLOSING;
break;
case UNF_EVENT_RPORT_RECOVERY: /* recovery --->>> ready */
en_next_state = UNF_RPORT_ST_READY;
break;
default:
en_next_state = v_old_state;
break;
}
return en_next_state;
}
void unf_rport_state_ma(struct unf_rport_s *v_rport,
enum unf_rport_event_e v_event)
{
enum unf_rport_login_state_e en_old_state = UNF_RPORT_ST_INIT;
enum unf_rport_login_state_e en_next_state = UNF_RPORT_ST_INIT;
UNF_CHECK_VALID(0x3056, UNF_TRUE, v_rport, return);
en_old_state = v_rport->rp_state;
switch (v_rport->rp_state) {
/* State INIT */
case UNF_RPORT_ST_INIT:
en_next_state = unf_rport_stat_init(en_old_state, v_event);
break;
/* State PLOGI Wait */
case UNF_RPORT_ST_PLOGI_WAIT:
en_next_state = unf_rport_stat_plogi_wait(en_old_state,
v_event);
break;
/* State PRLI Wait */
case UNF_RPORT_ST_PRLI_WAIT:
en_next_state = unf_rport_stat_prli_wait(en_old_state,
v_event);
break;
/* State LOGO */
case UNF_RPORT_ST_LOGO:
en_next_state = unf_rport_stat_logo(en_old_state, v_event);
break;
/* State CLOSING */
case UNF_RPORT_ST_CLOSING:
en_next_state = unf_rport_stat_closing(en_old_state, v_event);
break;
/* State READY */
case UNF_RPORT_ST_READY:
en_next_state = unf_rport_stat_ready(en_old_state, v_event);
break;
/* State DELETE */
case UNF_RPORT_ST_DELETE:
default:
en_next_state = UNF_RPORT_ST_INIT;
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]RPort(0x%x) hold state(0x%x)",
v_rport->nport_id, v_rport->rp_state);
break;
}
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MINOR,
"[info]RPort(0x%x) with oldstate(0x%x) event(0x%x) nextstate(0x%x)",
v_rport->nport_id, en_old_state, v_event, en_next_state);
unf_set_rport_state(v_rport, en_next_state);
}
void unf_clean_linkdown_rport(struct unf_lport_s *v_lport)
{
/* for L_Port's R_Port(s) */
struct unf_disc_s *disc = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
struct unf_rport_s *rport = NULL;
struct unf_lport_s *lport = NULL;
unsigned long disc_lock_flag = 0;
unsigned long rport_lock_flag = 0;
UNF_CHECK_VALID(0x3058, UNF_TRUE, v_lport, return);
disc = &v_lport->disc;
/* for each busy R_Port */
spin_lock_irqsave(&disc->rport_busy_pool_lock, disc_lock_flag);
/* --->>> busy_rports */
list_for_each_safe(node, next_node, &disc->list_busy_rports) {
rport = list_entry(node, struct unf_rport_s, entry_rport);
/* 1. Prevent process Repeatly: Closing */
spin_lock_irqsave(&rport->rport_state_lock, rport_lock_flag);
if (rport->rp_state == UNF_RPORT_ST_CLOSING) {
spin_unlock_irqrestore(&rport->rport_state_lock,
rport_lock_flag);
continue;
}
/* 2. Increase ref_cnt to protect R_Port */
if (unf_rport_ref_inc(rport) != RETURN_OK) {
spin_unlock_irqrestore(&rport->rport_state_lock,
rport_lock_flag);
continue;
}
/* 3. Update R_Port state:
* Link Down Event --->>> closing state
*/
unf_rport_state_ma(rport, UNF_EVENT_RPORT_LINK_DOWN);
/* 4. Put R_Port from busy to destroy list */
list_del_init(&rport->entry_rport);
list_add_tail(&rport->entry_rport, &disc->list_destroy_rports);
lport = rport->lport;
spin_unlock_irqrestore(&rport->rport_state_lock,
rport_lock_flag);
/* 5. Schedule Closing work (Enqueuing workqueue) */
unf_schedule_closing_work(lport, rport);
/* 6. decrease R_Port ref_cnt (company with 2) */
unf_rport_ref_dec(rport);
}
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, disc_lock_flag);
}
void unf_rport_enter_closing(struct unf_rport_s *v_rport)
{
/*
* call by
* 1. with RSCN processer
* 2. with LOGOUT processer
**
* from
* 1. R_Port Link Down
* 2. R_Port enter LOGO
*/
unsigned long rport_lock_flag = 0;
unsigned int ret = UNF_RETURN_ERROR;
struct unf_lport_s *lport = NULL;
struct unf_disc_s *disc = NULL;
UNF_CHECK_VALID(0x3059, UNF_TRUE, v_rport, return);
/* 1. Increase ref_cnt to protect R_Port */
spin_lock_irqsave(&v_rport->rport_state_lock, rport_lock_flag);
ret = unf_rport_ref_inc(v_rport);
if (ret != RETURN_OK) {
spin_unlock_irqrestore(&v_rport->rport_state_lock,
rport_lock_flag);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort(0x%x_0x%p) is removing and no need process",
v_rport->nport_id, v_rport);
return;
}
/* NOTE: R_Port state has been set(with closing) */
lport = v_rport->lport;
spin_unlock_irqrestore(&v_rport->rport_state_lock, rport_lock_flag);
/* 2. Put R_Port from busy to destroy list */
disc = &lport->disc;
spin_lock_irqsave(&disc->rport_busy_pool_lock, rport_lock_flag);
list_del_init(&v_rport->entry_rport);
list_add_tail(&v_rport->entry_rport, &disc->list_destroy_rports);
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, rport_lock_flag);
/* 3. Schedule Closing work (Enqueuing workqueue) */
unf_schedule_closing_work(lport, v_rport);
/* 4. dec R_Port ref_cnt */
unf_rport_ref_dec(v_rport);
}
void unf_rport_error_recovery(struct unf_rport_s *v_rport)
{
unsigned long delay = 0;
unsigned long flag = 0;
unsigned int ret = UNF_RETURN_ERROR;
UNF_CHECK_VALID(0x3060, UNF_TRUE, v_rport, return);
spin_lock_irqsave(&v_rport->rport_state_lock, flag);
ret = unf_rport_ref_inc(v_rport);
if (ret != RETURN_OK) {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort(0x%x_0x%p) is removing and no need process",
v_rport->nport_id, v_rport);
return;
}
/* Check R_Port state */
if ((v_rport->rp_state == UNF_RPORT_ST_CLOSING) ||
(v_rport->rp_state == UNF_RPORT_ST_DELETE)) {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]RPort(0x%x_0x%p) offline and no need process",
v_rport->nport_id, v_rport);
unf_rport_ref_dec(v_rport);
return;
}
/* Check repeatability with recovery work */
if (delayed_work_pending(&v_rport->recovery_work)) {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
"[info]RPort(0x%x_0x%p) recovery work is running and no need process",
v_rport->nport_id, v_rport);
unf_rport_ref_dec(v_rport);
return;
}
/* NOTE: Re-login or Logout directly (recovery work) */
if (v_rport->retries < v_rport->mas_retries) {
v_rport->retries++;
delay = (unsigned long)v_rport->ed_tov;
if (queue_delayed_work(unf_work_queue,
&v_rport->recovery_work,
(unsigned long)msecs_to_jiffies(
(unsigned int)delay))) {
/* Inc ref_cnt: corresponding to this work timer */
(void)unf_rport_ref_inc(v_rport);
}
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
} else {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort(0x%x_0x%p) state(0x%x) retry login failed",
v_rport->nport_id, v_rport, v_rport->rp_state);
/* Update R_Port state: LOGO event --->>> ST_LOGO */
unf_rport_state_ma(v_rport, UNF_EVENT_RPORT_LOGO);
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
/* Enter LOGO processer */
unf_rport_enter_logo(v_rport->lport, v_rport);
}
unf_rport_ref_dec(v_rport);
}
static unsigned int unf_rport_reuse_only(struct unf_rport_s *v_rport)
{
unsigned long flag = 0;
unsigned int ret = UNF_RETURN_ERROR;
UNF_CHECK_VALID(0x3061, UNF_TRUE,
v_rport, return UNF_RETURN_ERROR);
spin_lock_irqsave(&v_rport->rport_state_lock, flag);
ret = unf_rport_ref_inc(v_rport);
if (ret != RETURN_OK) {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
/* R_Port with delete state */
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort(0x%x_0x%p) is removing and no need process",
v_rport->nport_id, v_rport);
return UNF_RETURN_ERROR;
}
/* R_Port State check: delete */
if ((v_rport->rp_state == UNF_RPORT_ST_DELETE) ||
(v_rport->rp_state == UNF_RPORT_ST_CLOSING)) {
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort(0x%x_0x%p) state(0x%x) is delete or closing no need process",
v_rport->nport_id, v_rport, v_rport->rp_state);
ret = UNF_RETURN_ERROR;
}
spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);
unf_rport_ref_dec(v_rport);
return ret;
}
static unsigned int unf_rport_reuse_recover(struct unf_rport_s *v_rport)
{
unsigned long flags = 0;
unsigned int ret = UNF_RETURN_ERROR;
UNF_CHECK_VALID(0x3062, UNF_TRUE,
v_rport, return UNF_RETURN_ERROR);
spin_lock_irqsave(&v_rport->rport_state_lock, flags);
ret = unf_rport_ref_inc(v_rport);
if (ret != RETURN_OK) {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);
/* R_Port with delete state */
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort(0x%x_0x%p) is removing and no need process",
v_rport->nport_id, v_rport);
return UNF_RETURN_ERROR;
}
/* R_Port state check: delete */
if ((v_rport->rp_state == UNF_RPORT_ST_DELETE) ||
(v_rport->rp_state == UNF_RPORT_ST_CLOSING)) {
ret = UNF_RETURN_ERROR;
}
/* Update R_Port state: recovery --->>> ready */
unf_rport_state_ma(v_rport, UNF_EVENT_RPORT_RECOVERY);
spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);
unf_rport_ref_dec(v_rport);
return ret;
}
static unsigned int unf_rport_reuse_init(struct unf_rport_s *v_rport)
{
unsigned long flage = 0;
unsigned int ret = UNF_RETURN_ERROR;
UNF_CHECK_VALID(0x3063, UNF_TRUE,
v_rport, return UNF_RETURN_ERROR);
spin_lock_irqsave(&v_rport->rport_state_lock, flage);
ret = unf_rport_ref_inc(v_rport);
if (ret != RETURN_OK) {
spin_unlock_irqrestore(&v_rport->rport_state_lock, flage);
/* R_Port with delete state */
UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
"[warn]RPort(0x%x_0x%p) is removing and no need process",
v_rport->nport_id, v_rport);
return UNF_RETURN_ERROR;
}
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
"[info]RPort(0x%x)'s state is 0x%x with use_init flag",
v_rport->nport_id, v_rport->rp_state);
/* R_Port State check: delete */
if ((v_rport->rp_state == UNF_RPORT_ST_DELETE) ||
(v_rport->rp_state == UNF_RPORT_ST_CLOSING)) {
ret = UNF_RETURN_ERROR;
} else {
/* Update R_Port state: re-enter Init state */
unf_set_rport_state(v_rport, UNF_RPORT_ST_INIT);
}
spin_unlock_irqrestore(&v_rport->rport_state_lock, flage);
unf_rport_ref_dec(v_rport);
return ret;
}
struct unf_rport_s *unf_get_rport_by_nport_id(struct unf_lport_s *v_lport,
unsigned int nport_id)
{
struct unf_lport_s *lport = NULL;
struct unf_disc_s *disc = NULL;
struct unf_rport_s *rport = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
unsigned long flag = 0;
struct unf_rport_s *find_rport = NULL;
UNF_CHECK_VALID(0x3048, UNF_TRUE, v_lport, return NULL);
lport = (struct unf_lport_s *)v_lport;
disc = &lport->disc;
/* for each r_port from rport_busy_list: compare N_Port_ID */
spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
list_for_each_safe(node, next_node, &disc->list_busy_rports) {
rport = list_entry(node, struct unf_rport_s, entry_rport);
if (rport && rport->nport_id == nport_id) {
find_rport = rport;
break;
}
}
spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);
return find_rport;
}
struct unf_rport_s *unf_get_safe_rport(struct unf_lport_s *v_lport,
struct unf_rport_s *v_rport,
enum unf_rport_reuse_flag_e v_reuse_flag,
unsigned int v_nport_id)
{
/*
* New add or plug
*
* retry_flogi --->>> reuse_only
* name_server_register --->>> reuse_only
* SNS_plogi --->>> reuse_only
* enter_flogi --->>> reuse_only
* logout --->>> reuse_only
* flogi_handler --->>> reuse_only
* plogi_handler --->>> reuse_only
* adisc_handler --->>> reuse_recovery
* logout_handler --->>> reuse_init
* prlo_handler --->>> reuse_init
* login_with_loop --->>> reuse_only
* gffid_callback --->>> reuse_only
* delay_plogi --->>> reuse_only
* gffid_rjt --->>> reuse_only
* gffid_rsp_unknown --->>> reuse_only
* gpnid_acc --->>> reuse_init
* fdisc_callback --->>> reuse_only
* flogi_acc --->>> reuse_only
* plogi_acc --->>> reuse_only
* logo_callback --->>> reuse_init
* rffid_callback --->>> reuse_only
*/
#define UNF_AVOID_LINK_FLASH_TIME 3000
struct unf_rport_s *rport = v_rport;
unsigned int ret = UNF_RETURN_ERROR;
UNF_CHECK_VALID(0x3075, UNF_TRUE, v_lport, return NULL);
/* 1. Alloc New R_Port or Update R_Port Property */
if (!rport) {
/* If NULL, get/Alloc new node
* (R_Port from R_Port pool) directly
*/
rport = unf_rport_get_free_and_init(v_lport, UNF_PORT_TYPE_FC,
v_nport_id);
} else {
UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
"[info]Port(0x%x) get exist RPort(0x%x) with state(0x%x) and reuse_flag(0x%x)",
v_lport->port_id, rport->nport_id,
rport->rp_state, v_reuse_flag);
switch (v_reuse_flag) {
case UNF_RPORT_REUSE_ONLY:
ret = unf_rport_reuse_only(rport);
if (ret != RETURN_OK) {
/* R_Port within delete list: need get new */
rport = unf_rport_get_free_and_init(
v_lport,
UNF_PORT_TYPE_FC,
v_nport_id);
}
break;
case UNF_RPORT_REUSE_INIT:
ret = unf_rport_reuse_init(rport);
if (ret != RETURN_OK) {
/* R_Port within delete list: need get new */
rport = unf_rport_get_free_and_init(
v_lport,
UNF_PORT_TYPE_FC,
v_nport_id);
}
break;
case UNF_RPORT_REUSE_RECOVER:
ret = unf_rport_reuse_recover(rport);
if (ret != RETURN_OK) {
/* R_Port within delete list,
* NOTE: do nothing
*/
rport = NULL;
}
break;
default:
break;
}
}
return rport;
}
unsigned int unf_get_port_feature(unsigned long long v_wwpn)
{
struct unf_rport_feature_recard_s *port_fea = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
unsigned long flags = 0;
struct list_head list_temp_node;
spin_lock_irqsave(&port_fea_pool->port_fea_pool_lock, flags);
list_for_each_safe(node, next_node, &port_fea_pool->list_busy_head) {
port_fea = list_entry(node, struct unf_rport_feature_recard_s,
entry_feature);
if (v_wwpn == port_fea->wwpn) {
list_del(&port_fea->entry_feature);
list_add(&port_fea->entry_feature,
&port_fea_pool->list_busy_head);
spin_unlock_irqrestore(
&port_fea_pool->port_fea_pool_lock, flags);
return port_fea->port_feature;
}
}
list_for_each_safe(node, next_node, &port_fea_pool->list_free_head) {
port_fea = list_entry(node, struct unf_rport_feature_recard_s,
entry_feature);
if (v_wwpn == port_fea->wwpn) {
list_del(&port_fea->entry_feature);
list_add(&port_fea->entry_feature,
&port_fea_pool->list_busy_head);
spin_unlock_irqrestore(
&port_fea_pool->port_fea_pool_lock, flags);
return port_fea->port_feature;
}
}
/* can't find wwpn */
if (list_empty(&port_fea_pool->list_free_head)) {
/* free is empty, transport busy to free */
list_temp_node = port_fea_pool->list_free_head;
port_fea_pool->list_free_head = port_fea_pool->list_busy_head;
port_fea_pool->list_busy_head = list_temp_node;
}
port_fea = list_entry((&port_fea_pool->list_free_head)->prev,
struct unf_rport_feature_recard_s,
entry_feature);
list_del(&port_fea->entry_feature);
list_add(&port_fea->entry_feature, &port_fea_pool->list_busy_head);
port_fea->wwpn = v_wwpn;
port_fea->port_feature = UNF_PORT_MODE_UNKNOWN;
spin_unlock_irqrestore(&port_fea_pool->port_fea_pool_lock, flags);
return UNF_PORT_MODE_UNKNOWN;
}
void unf_update_port_feature(unsigned long long v_wwpn,
unsigned int v_port_feature)
{
struct unf_rport_feature_recard_s *port_fea = NULL;
struct list_head *node = NULL;
struct list_head *next_node = NULL;
unsigned long flags = 0;
spin_lock_irqsave(&port_fea_pool->port_fea_pool_lock, flags);
list_for_each_safe(node, next_node, &port_fea_pool->list_busy_head) {
port_fea = list_entry(node,
struct unf_rport_feature_recard_s,
entry_feature);
if (v_wwpn == port_fea->wwpn) {
port_fea->port_feature = v_port_feature;
list_del(&port_fea->entry_feature);
list_add(&port_fea->entry_feature,
&port_fea_pool->list_busy_head);
spin_unlock_irqrestore(
&port_fea_pool->port_fea_pool_lock, flags);
return;
}
}
list_for_each_safe(node, next_node, &port_fea_pool->list_free_head) {
port_fea = list_entry(node, struct unf_rport_feature_recard_s,
entry_feature);
if (v_wwpn == port_fea->wwpn) {
port_fea->port_feature = v_port_feature;
list_del(&port_fea->entry_feature);
list_add(&port_fea->entry_feature,
&port_fea_pool->list_busy_head);
spin_unlock_irqrestore(
&port_fea_pool->port_fea_pool_lock, flags);
return;
}
}
spin_unlock_irqrestore(&port_fea_pool->port_fea_pool_lock, flags);
}
Reference in New Issue View Git Blame Copy Permalink