Add support for unsolicited requests and responses.
Add support to accept and reject frames.
Reviewed-by: Sesidhar Baddela <sebaddel@cisco.com>
Signed-off-by: Gian Carlo Boffa <gcboffa@cisco.com>
Signed-off-by: Arulprabhu Ponnusamy <arulponn@cisco.com>
Signed-off-by: Arun Easi <aeasi@cisco.com>
Signed-off-by: Karan Tilak Kumar <kartilak@cisco.com>
---
Changes between v2 and v3:
Add fnic_std_ba_acc removed from previous patch.
Incorporate review comments from Hannes:
Replace redundant definitions with standard definitions.
Changes between v1 and v2:
Incorporate review comments from Hannes:
Replace fnic_del_tport_timer_sync macro calls with function
calls.
Fix indentation.
Replace definitions with standard definitions from fc_els.h.
---
drivers/scsi/fnic/fdls_disc.c | 578 +++++++++++++++++++++++++++++++++-
1 file changed, 576 insertions(+), 2 deletions(-)
diff --git a/drivers/scsi/fnic/fdls_disc.c b/drivers/scsi/fnic/fdls_disc.c
index 0757b9ab1a28..94f55e45ece9 100644
--- a/drivers/scsi/fnic/fdls_disc.c
+++ b/drivers/scsi/fnic/fdls_disc.c
@@ -142,6 +142,22 @@ struct fc_std_scr fnic_std_scr_req = {
.scr_reg_func = ELS_SCRF_FULL}
};
+/*
+ * Variables:
+ * did, ox_id, rx_id
+ */
+struct fc_std_els_rsp fnic_std_els_acc = {
+ .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REP, .fh_d_id = {0xFF, 0xFF, 0xFD},
+ .fh_type = FC_TYPE_ELS, .fh_f_ctl = {FNIC_ELS_REP_FCTL, 0, 0}},
+ .u.acc.la_cmd = ELS_LS_ACC,
+};
+
+struct fc_std_els_rsp fnic_std_els_rjt = {
+ .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REP, .fh_type = FC_TYPE_ELS,
+ .fh_f_ctl = {FNIC_ELS_REP_FCTL, 0, 0}},
+ .u.rej.er_cmd = ELS_LS_RJT,
+};
+
/*
* Variables:
* did, ox_id, rx_id, fcid, wwpn
@@ -169,6 +185,12 @@ struct fc_frame_header fc_std_tport_abts = {
.fh_parm_offset = 0x00000000, /* bit:0 = 0 Abort a exchange */
};
+static struct fc_std_abts_ba_acc fnic_std_ba_acc = {
+ .fchdr = {.fh_r_ctl = FC_RCTL_BA_ACC,
+ .fh_f_ctl = {FNIC_FCP_RSP_FCTL, 0, 0}},
+ .acc = {.ba_low_seq_cnt = 0, .ba_high_seq_cnt = 0xFFFF}
+};
+
#define RETRIES_EXHAUSTED(iport) \
(iport->fabric.retry_counter == FABRIC_LOGO_MAX_RETRY)
@@ -201,7 +223,6 @@ static void fdls_target_restart_nexus(struct fnic_tport_s *tport);
static void fdls_start_tport_timer(struct fnic_iport_s *iport,
struct fnic_tport_s *tport, int timeout);
static void fdls_tport_timer_callback(struct timer_list *t);
-
static void fdls_start_fabric_timer(struct fnic_iport_s *iport,
int timeout);
static void
@@ -506,6 +527,50 @@ fdls_start_tport_timer(struct fnic_iport_s *iport,
tport->timer_pending = 1;
}
+static void
+fdls_send_rscn_resp(struct fnic_iport_s *iport,
+ struct fc_frame_header *rscn_fchdr)
+{
+ struct fc_std_els_rsp els_acc;
+ uint16_t oxid;
+ uint8_t fcid[3];
+
+ memcpy(&els_acc, &fnic_std_els_acc, FC_ELS_RSP_ACC_SIZE);
+
+ hton24(fcid, iport->fcid);
+ FNIC_STD_SET_S_ID((&els_acc.fchdr), fcid);
+ FNIC_STD_SET_D_ID((&els_acc.fchdr), rscn_fchdr->fh_s_id);
+
+ oxid = FNIC_STD_GET_OX_ID(rscn_fchdr);
+ FNIC_STD_SET_OX_ID((&els_acc.fchdr), oxid);
+
+ FNIC_STD_SET_RX_ID((&els_acc.fchdr), FNIC_UNASSIGNED_RXID);
+
+ fnic_send_fcoe_frame(iport, &els_acc, FC_ELS_RSP_ACC_SIZE);
+}
+
+static void
+fdls_send_logo_resp(struct fnic_iport_s *iport,
+ struct fc_frame_header *req_fchdr)
+{
+ struct fc_std_els_rsp logo_resp;
+ uint16_t oxid;
+ uint8_t fcid[3];
+
+ memcpy(&logo_resp, &fnic_std_els_acc, sizeof(struct fc_std_els_rsp));
+
+ hton24(fcid, iport->fcid);
+ FNIC_STD_SET_S_ID((&logo_resp.fchdr), fcid);
+ FNIC_STD_SET_D_ID((&logo_resp.fchdr), req_fchdr->fh_s_id);
+
+ oxid = FNIC_STD_GET_OX_ID(req_fchdr);
+ FNIC_STD_SET_OX_ID((&logo_resp.fchdr), oxid);
+
+ FNIC_STD_SET_RX_ID((&logo_resp.fchdr), FNIC_UNASSIGNED_RXID);
+
+ fnic_send_fcoe_frame(iport, &logo_resp, FC_ELS_RSP_ACC_SIZE);
+}
+
void
fdls_send_tport_abts(struct fnic_iport_s *iport,
struct fnic_tport_s *tport)
@@ -2888,6 +2953,192 @@ fdls_process_fabric_abts_rsp(struct fnic_iport_s *iport,
}
}
+static void
+fdls_process_abts_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr)
+{
+ struct fc_std_abts_ba_acc ba_acc;
+ uint32_t nport_id;
+ uint16_t oxid;
+ struct fnic_tport_s *tport;
+ struct fnic *fnic = iport->fnic;
+ struct fnic_tgt_oxid_pool_s *oxid_pool;
+
+ nport_id = ntoh24(fchdr->fh_s_id);
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Received abort from SID %8x", nport_id);
+
+ tport = fnic_find_tport_by_fcid(iport, nport_id);
+ if (tport) {
+ oxid = FNIC_STD_GET_OX_ID(fchdr);
+ if (tport->oxid_used == oxid) {
+ tport->flags |= FNIC_FDLS_TGT_ABORT_ISSUED;
+ oxid_pool = fdls_get_tgt_oxid_pool(tport);
+ fdls_free_tgt_oxid(iport, oxid_pool, ntohs(oxid));
+ }
+ }
+
+ memcpy(&ba_acc, &fnic_std_ba_acc, sizeof(struct fc_std_abts_ba_acc));
+ FNIC_STD_SET_S_ID((&ba_acc.fchdr), fchdr->fh_d_id);
+ FNIC_STD_SET_D_ID((&ba_acc.fchdr), fchdr->fh_s_id);
+
+ ba_acc.fchdr.fh_rx_id = fchdr->fh_rx_id;
+ ba_acc.acc.ba_rx_id = ba_acc.fchdr.fh_rx_id;
+ ba_acc.fchdr.fh_ox_id = fchdr->fh_ox_id;
+ ba_acc.acc.ba_ox_id = ba_acc.fchdr.fh_ox_id;
+
+ fnic_send_fcoe_frame(iport, &ba_acc, sizeof(struct fc_std_abts_ba_acc));
+}
+
+static void
+fdls_process_unsupported_els_req(struct fnic_iport_s *iport,
+ struct fc_frame_header *fchdr)
+{
+ struct fc_std_els_rsp ls_rsp;
+ uint16_t oxid;
+ uint32_t d_id = ntoh24(fchdr->fh_d_id);
+ struct fnic *fnic = iport->fnic;
+
+ memcpy(&ls_rsp, &fnic_std_els_rjt, FC_ELS_RSP_REJ_SIZE);
+
+ if (iport->fcid != d_id) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Dropping unsupported ELS with illegal frame bits 0x%x\n",
+ d_id);
+ return;
+ }
+
+ if ((iport->state != FNIC_IPORT_STATE_READY)
+ && (iport->state != FNIC_IPORT_STATE_FABRIC_DISC)) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Dropping unsupported ELS request in iport state: %d",
+ iport->state);
+ return;
+ }
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Process unsupported ELS request from SID: 0x%x",
+ ntoh24(fchdr->fh_s_id));
+ /* We don't support this ELS request, send a reject */
+ ls_rsp.u.rej.er_reason = 0x0B;
+ ls_rsp.u.rej.er_explan = 0x0;
+ ls_rsp.u.rej.er_vendor = 0x0;
+
+ FNIC_STD_SET_S_ID((&ls_rsp.fchdr), fchdr->fh_d_id);
+ FNIC_STD_SET_D_ID((&ls_rsp.fchdr), fchdr->fh_s_id);
+ oxid = FNIC_STD_GET_OX_ID(fchdr);
+ FNIC_STD_SET_OX_ID((&ls_rsp.fchdr), oxid);
+
+ FNIC_STD_SET_RX_ID((&ls_rsp.fchdr), FNIC_UNSUPPORTED_RESP_OXID);
+
+ fnic_send_fcoe_frame(iport, &ls_rsp, FC_ELS_RSP_REJ_SIZE);
+}
+
+static void
+fdls_process_rls_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr)
+{
+ struct fc_std_rls_acc rls_acc_rsp;
+ uint16_t oxid;
+ struct fnic *fnic = iport->fnic;
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Process RLS request %d", iport->fnic->fnic_num);
+
+ if ((iport->state != FNIC_IPORT_STATE_READY)
+ && (iport->state != FNIC_IPORT_STATE_FABRIC_DISC)) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Received RLS req in iport state: %d. Dropping the frame.",
+ iport->state);
+ return;
+ }
+
+ memset(&rls_acc_rsp, 0, sizeof(struct fc_std_rls_acc));
+
+ FNIC_STD_SET_S_ID((&rls_acc_rsp.fchdr), fchdr->fh_d_id);
+ FNIC_STD_SET_D_ID((&rls_acc_rsp.fchdr), fchdr->fh_s_id);
+ oxid = FNIC_STD_GET_OX_ID(fchdr);
+ FNIC_STD_SET_OX_ID((&rls_acc_rsp.fchdr), oxid);
+ FNIC_STD_SET_RX_ID((&rls_acc_rsp.fchdr), 0xffff);
+ FNIC_STD_SET_F_CTL(&rls_acc_rsp.fchdr, FNIC_ELS_REP_FCTL << 16);
+ FNIC_STD_SET_R_CTL(&rls_acc_rsp.fchdr, FC_RCTL_ELS_REP);
+ FNIC_STD_SET_TYPE(&rls_acc_rsp.fchdr, FC_TYPE_ELS);
+ rls_acc_rsp.els.rls_cmd = ELS_LS_ACC;
+ rls_acc_rsp.els.rls_lesb.lesb_link_fail =
+ htonl(iport->fnic->link_down_cnt);
+
+ fnic_send_fcoe_frame(iport, &rls_acc_rsp,
+ sizeof(struct fc_std_rls_acc));
+}
+
+static void
+fdls_process_els_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr,
+ uint32_t len)
+{
+ struct fc_std_els_rsp *els_acc;
+ uint16_t oxid;
+ uint8_t fcid[3];
+ uint8_t *fc_payload;
+ uint8_t *dst_frame;
+ uint8_t type;
+ struct fnic *fnic = iport->fnic;
+
+ fc_payload = (uint8_t *) fchdr + sizeof(struct fc_frame_header);
+ type = *fc_payload;
+
+ if ((iport->state != FNIC_IPORT_STATE_READY)
+ && (iport->state != FNIC_IPORT_STATE_FABRIC_DISC)) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Dropping ELS frame type :%x in iport state: %d",
+ type, iport->state);
+ return;
+ }
+ switch (type) {
+ case ELS_ECHO:
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "sending LS_ACC for ECHO request %d\n",
+ iport->fnic->fnic_num);
+ break;
+
+ case ELS_RRQ:
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "sending LS_ACC for RRQ request %d\n",
+ iport->fnic->fnic_num);
+ break;
+
+ default:
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "sending LS_ACC for %x ELS frame\n", type);
+ break;
+ }
+ dst_frame = kzalloc(len, GFP_ATOMIC);
+ if (!dst_frame) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Failed to allocate ELS response for %x", type);
+ return;
+ }
+ if (type == ELS_ECHO) {
+ /* Brocade sends a longer payload, copy all frame back */
+ memcpy(dst_frame, fchdr, len);
+ }
+
+ els_acc = (struct fc_std_els_rsp *)dst_frame;
+ memcpy(els_acc, &fnic_std_els_acc, FC_ELS_RSP_ACC_SIZE);
+
+ hton24(fcid, iport->fcid);
+ FNIC_STD_SET_S_ID((&els_acc->fchdr), fcid);
+ FNIC_STD_SET_D_ID((&els_acc->fchdr), fchdr->fh_s_id);
+
+ oxid = FNIC_STD_GET_OX_ID(fchdr);
+ FNIC_STD_SET_OX_ID((&els_acc->fchdr), oxid);
+ FNIC_STD_SET_RX_ID((&els_acc->fchdr), 0xffff);
+
+ if (type == ELS_ECHO)
+ fnic_send_fcoe_frame(iport, els_acc, len);
+ else
+ fnic_send_fcoe_frame(iport, els_acc, FC_ELS_RSP_ACC_SIZE);
+
+ kfree(dst_frame);
+}
+
static void
fdls_process_tgt_abts_rsp(struct fnic_iport_s *iport,
struct fc_frame_header *fchdr)
@@ -3030,6 +3281,303 @@ fdls_process_tgt_abts_rsp(struct fnic_iport_s *iport,
"Received ABTS response for unknown frame %p", iport);
}
+static void
+fdls_process_plogi_req(struct fnic_iport_s *iport,
+ struct fc_frame_header *fchdr)
+{
+ struct fc_std_els_rsp plogi_rsp;
+ uint16_t oxid;
+ uint32_t d_id = ntoh24(fchdr->fh_d_id);
+ struct fnic *fnic = iport->fnic;
+
+ memcpy(&plogi_rsp, &fnic_std_els_rjt, sizeof(struct fc_std_els_rsp));
+
+ if (iport->fcid != d_id) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Received PLOGI with illegal frame bits. Dropping frame %p",
+ iport);
+ return;
+ }
+
+ if (iport->state != FNIC_IPORT_STATE_READY) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Received PLOGI request in iport state: %d Dropping frame",
+ iport->state);
+ return;
+ }
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Process PLOGI request from SID: 0x%x",
+ ntoh24(fchdr->fh_s_id));
+
+ /* We don't support PLOGI request, send a reject */
+ plogi_rsp.u.rej.er_reason = 0x0B;
+ plogi_rsp.u.rej.er_explan = 0x0;
+ plogi_rsp.u.rej.er_vendor = 0x0;
+
+ FNIC_STD_SET_S_ID((&plogi_rsp.fchdr), fchdr->fh_d_id);
+ FNIC_STD_SET_D_ID((&plogi_rsp.fchdr), fchdr->fh_s_id);
+
+ oxid = FNIC_STD_GET_OX_ID(fchdr);
+ FNIC_STD_SET_OX_ID((&plogi_rsp.fchdr), oxid);
+
+ FNIC_STD_SET_RX_ID((&plogi_rsp.fchdr), FNIC_UNASSIGNED_RXID);
+
+ fnic_send_fcoe_frame(iport, &plogi_rsp, FC_ELS_RSP_REJ_SIZE);
+}
+
+static void
+fdls_process_logo_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr)
+{
+ struct fc_std_logo *logo = (struct fc_std_logo *)fchdr;
+ uint32_t nport_id;
+ uint64_t nport_name;
+ struct fnic_tport_s *tport;
+ struct fnic *fnic = iport->fnic;
+ uint16_t oxid;
+
+ nport_id = ntoh24(logo->els.fl_n_port_id);
+ nport_name = logo->els.fl_n_port_wwn;
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Process LOGO request from fcid: 0x%x", nport_id);
+
+ if (iport->state != FNIC_IPORT_STATE_READY) {
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "Dropping LOGO req from 0x%x in iport state: %d",
+ nport_id, iport->state);
+ return;
+ }
+
+ tport = fnic_find_tport_by_fcid(iport, nport_id);
+
+ if (!tport) {
+ /* We are not logged in with the nport, log and drop... */
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "Received LOGO from an nport not logged in: 0x%x",
+ nport_id);
+ return;
+ }
+ if (tport->fcid != nport_id) {
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "Received LOGO with invalid target port fcid: 0x%x",
+ nport_id);
+ return;
+ }
+ if (tport->timer_pending) {
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "tport fcid 0x%x: Canceling disc timer\n",
+ tport->fcid);
+ fnic_del_tport_timer_sync(fnic, tport);
+ tport->timer_pending = 0;
+ }
+
+ /* got a logo in response to adisc to a target which has logged out */
+ if (tport->state == FDLS_TGT_STATE_ADISC) {
+ tport->retry_counter = 0;
+ oxid = ntohs(tport->oxid_used);
+ fdls_free_tgt_oxid(iport, &iport->adisc_oxid_pool, oxid);
+ fdls_delete_tport(iport, tport);
+ fdls_send_logo_resp(iport, &logo->fchdr);
+ if ((iport->state == FNIC_IPORT_STATE_READY)
+ && (fdls_get_state(&iport->fabric) != FDLS_STATE_SEND_GPNFT)
+ && (fdls_get_state(&iport->fabric) != FDLS_STATE_RSCN_GPN_FT)) {
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "Sending GPNFT in response to LOGO from Target:0x%x",
+ nport_id);
+ fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT);
+ return;
+ }
+ } else {
+ fdls_delete_tport(iport, tport);
+ }
+ if (iport->state == FNIC_IPORT_STATE_READY) {
+ fdls_send_logo_resp(iport, &logo->fchdr);
+ if ((fdls_get_state(&iport->fabric) != FDLS_STATE_SEND_GPNFT) &&
+ (fdls_get_state(&iport->fabric) != FDLS_STATE_RSCN_GPN_FT)) {
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "Sending GPNFT in response to LOGO from Target:0x%x",
+ nport_id);
+ fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT);
+ }
+ }
+}
+
+static void
+fdls_process_rscn(struct fnic_iport_s *iport, struct fc_frame_header *fchdr)
+{
+ struct fc_std_rscn *rscn;
+ struct fc_els_rscn_page *rscn_port = NULL;
+ int num_ports;
+ struct fnic_tport_s *tport, *next;
+ uint32_t nport_id;
+ uint8_t fcid[3];
+ int newports = 0;
+ struct fnic_fdls_fabric_s *fdls = &iport->fabric;
+ struct fnic *fnic = iport->fnic;
+ uint16_t rscn_payload_len;
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "FDLS process RSCN %p", iport);
+
+ if (iport->state != FNIC_IPORT_STATE_READY) {
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "FDLS RSCN received in state(%d). Dropping",
+ fdls_get_state(fdls));
+ return;
+ }
+
+ rscn = (struct fc_std_rscn *)fchdr;
+ rscn_payload_len = be16_to_cpu(rscn->els.rscn_plen);
+
+ /* frame validation */
+ if ((rscn_payload_len % 4 != 0) || (rscn_payload_len < 8)
+ || (rscn_payload_len > 1024)
+ || (rscn->els.rscn_page_len != 4)) {
+ num_ports = 0;
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "RSCN payload_len: 0x%x page_len: 0x%x",
+ rscn_payload_len, rscn->els.rscn_page_len);
+ /* if this happens then we need to send ADISC to all the tports. */
+ list_for_each_entry_safe(tport, next, &iport->tport_list, links) {
+ if (tport->state == FDLS_TGT_STATE_READY)
+ tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC;
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "RSCN for port id: 0x%x", tport->fcid);
+ }
+ } else {
+ num_ports = (rscn_payload_len - 4) / rscn->els.rscn_page_len;
+ rscn_port = (struct fc_els_rscn_page *)(rscn + 1);
+ }
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "RSCN received for num_ports: %d payload_len: %d page_len: %d ",
+ num_ports, rscn_payload_len, rscn->els.rscn_page_len);
+
+ /*
+ * RSCN have at least one Port_ID page , but may not have any port_id
+ * in it. If no port_id is specified in the Port_ID page , we send
+ * ADISC to all the tports
+ */
+
+ while (num_ports) {
+
+ memcpy(fcid, rscn_port->rscn_fid, 3);
+
+ nport_id = ntoh24(fcid);
+ rscn_port++;
+ num_ports--;
+ /* if this happens then we need to send ADISC to all the tports. */
+ if (nport_id == 0) {
+ list_for_each_entry_safe(tport, next, &iport->tport_list,
+ links) {
+ if (tport->state == FDLS_TGT_STATE_READY)
+ tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC;
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "RSCN for port id: 0x%x", tport->fcid);
+ }
+ break;
+ }
+ tport = fnic_find_tport_by_fcid(iport, nport_id);
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "RSCN port id list: 0x%x", nport_id);
+
+ if (!tport) {
+ newports++;
+ continue;
+ }
+ if (tport->state == FDLS_TGT_STATE_READY)
+ tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC;
+ }
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "FDLS process RSCN sending GPN_FT %p", iport);
+ fdls_send_gpn_ft(iport, FDLS_STATE_RSCN_GPN_FT);
+ fdls_send_rscn_resp(iport, fchdr);
+}
+
+static void
+fdls_process_adisc_req(struct fnic_iport_s *iport,
+ struct fc_frame_header *fchdr)
+{
+ struct fc_std_els_adisc adisc_acc;
+ struct fc_std_els_adisc *adisc_req = (struct fc_std_els_adisc *)fchdr;
+ uint64_t frame_wwnn;
+ uint64_t frame_wwpn;
+ uint32_t tgt_fcid;
+ struct fnic_tport_s *tport;
+ uint8_t *fcid;
+ struct fc_std_els_rsp rjts_rsp;
+ uint16_t oxid;
+ struct fnic *fnic = iport->fnic;
+
+ FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
+ "Process ADISC request %d", iport->fnic->fnic_num);
+
+ fcid = FNIC_STD_GET_S_ID(fchdr);
+ tgt_fcid = ntoh24(fcid);
+ tport = fnic_find_tport_by_fcid(iport, tgt_fcid);
+ if (!tport) {
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "tport for fcid: 0x%x not found. Dropping ADISC req.",
+ tgt_fcid);
+ return;
+ }
+ if (iport->state != FNIC_IPORT_STATE_READY) {
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "Dropping ADISC req from fcid: 0x%x in iport state: %d",
+ tgt_fcid, iport->state);
+ return;
+ }
+
+ frame_wwnn = ntohll(adisc_req->els.adisc_wwnn);
+ frame_wwpn = ntohll(adisc_req->els.adisc_wwpn);
+
+ if ((frame_wwnn != tport->wwnn) || (frame_wwpn != tport->wwpn)) {
+ /* send reject */
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "ADISC req from fcid: 0x%x mismatch wwpn: 0x%llx wwnn: 0x%llx",
+ tgt_fcid, frame_wwpn, frame_wwnn);
+ FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
+ "local tport wwpn: 0x%llx wwnn: 0x%llx. Sending RJT",
+ tport->wwpn, tport->wwnn);
+
+ memcpy(&rjts_rsp, &fnic_std_els_rjt,
+ sizeof(struct fc_std_els_rsp));
+
+ rjts_rsp.u.rej.er_reason = 0x03; /* logical error */
+ rjts_rsp.u.rej.er_explan = 0x1E; /* N_port login required */
+ rjts_rsp.u.rej.er_vendor = 0x0;
+ FNIC_STD_SET_S_ID((&rjts_rsp.fchdr), fchdr->fh_d_id);
+ FNIC_STD_SET_D_ID((&rjts_rsp.fchdr), fchdr->fh_s_id);
+ oxid = FNIC_STD_GET_OX_ID(fchdr);
+ FNIC_STD_SET_OX_ID((&rjts_rsp.fchdr), oxid);
+ FNIC_STD_SET_RX_ID((&rjts_rsp.fchdr), FNIC_UNASSIGNED_RXID);
+
+ fnic_send_fcoe_frame(iport, &rjts_rsp, FC_ELS_RSP_REJ_SIZE);
+ return;
+ }
+ memset(&adisc_acc.fchdr, 0, sizeof(struct fc_frame_header));
+ FNIC_STD_SET_S_ID(&adisc_acc.fchdr, fchdr->fh_d_id);
+ FNIC_STD_SET_D_ID(&adisc_acc.fchdr, fchdr->fh_s_id);
+ FNIC_STD_SET_F_CTL(&adisc_acc.fchdr, FNIC_ELS_REP_FCTL << 16);
+ FNIC_STD_SET_R_CTL(&adisc_acc.fchdr, FC_RCTL_ELS_REP);
+ FNIC_STD_SET_TYPE(&adisc_acc.fchdr, FC_TYPE_ELS);
+ oxid = FNIC_STD_GET_OX_ID(fchdr);
+ FNIC_STD_SET_OX_ID(&adisc_acc.fchdr, oxid);
+ FNIC_STD_SET_RX_ID(&adisc_acc.fchdr, FNIC_UNASSIGNED_RXID);
+ adisc_acc.els.adisc_cmd = ELS_LS_ACC;
+
+ FNIC_STD_SET_NPORT_NAME(&adisc_acc.els.adisc_wwpn,
+ le64_to_cpu(iport->wwpn));
+ FNIC_STD_SET_NODE_NAME(&adisc_acc.els.adisc_wwnn,
+ le64_to_cpu(iport->wwnn));
+ memcpy(adisc_acc.els.adisc_port_id, fchdr->fh_d_id, 3);
+
+ fnic_send_fcoe_frame(iport, &adisc_acc,
+ sizeof(struct fc_std_els_adisc));
+}
+
/*
* Performs a validation for all FCOE frames and return the frame type
*/
@@ -3312,8 +3860,34 @@ void fnic_fdls_recv_frame(struct fnic_iport_s *iport, void *rx_frame,
if (fdls_is_oxid_in_fabric_range(oxid) &&
(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) {
fdls_process_fabric_abts_rsp(iport, fchdr);
- } else
+ } else {
fdls_process_tgt_abts_rsp(iport, fchdr);
+ }
+ break;
+ case FNIC_BLS_ABTS_REQ:
+ fdls_process_abts_req(iport, fchdr);
+ break;
+ case FNIC_ELS_UNSUPPORTED_REQ:
+ fdls_process_unsupported_els_req(iport, fchdr);
+ break;
+ case FNIC_ELS_PLOGI_REQ:
+ fdls_process_plogi_req(iport, fchdr);
+ break;
+ case FNIC_ELS_RSCN_REQ:
+ fdls_process_rscn(iport, fchdr);
+ break;
+ case FNIC_ELS_LOGO_REQ:
+ fdls_process_logo_req(iport, fchdr);
+ break;
+ case FNIC_ELS_RRQ:
+ case FNIC_ELS_ECHO_REQ:
+ fdls_process_els_req(iport, fchdr, len);
+ break;
+ case FNIC_ELS_ADISC:
+ fdls_process_adisc_req(iport, fchdr);
+ break;
+ case FNIC_ELS_RLS:
+ fdls_process_rls_req(iport, fchdr);
break;
default:
FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
--
2.31.1Hi Karan,
kernel test robot noticed the following build warnings:
[auto build test WARNING on mkp-scsi/for-next]
[also build test WARNING on jejb-scsi/for-next linus/master v6.11 next-20240927]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Karan-Tilak-Kumar/scsi-fnic-Replace-shost_printk-with-dev_info-dev_err/20240928-025906
base: https://git.kernel.org/pub/scm/linux/kernel/git/mkp/scsi.git for-next
patch link: https://lore.kernel.org/r/20240927184613.52172-6-kartilak%40cisco.com
patch subject: [PATCH v3 05/14] scsi: fnic: Add support for unsolicited requests and responses
config: x86_64-kexec (https://download.01.org/0day-ci/archive/20240929/202409291705.MugERX98-lkp@intel.com/config)
compiler: clang version 18.1.8 (https://github.com/llvm/llvm-project 3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240929/202409291705.MugERX98-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202409291705.MugERX98-lkp@intel.com/
All warnings (new ones prefixed by >>):
>> drivers/scsi/fnic/fdls_disc.c:3333:11: warning: variable 'nport_name' set but not used [-Wunused-but-set-variable]
3333 | uint64_t nport_name;
| ^
>> drivers/scsi/fnic/fdls_disc.c:3414:6: warning: variable 'newports' set but not used [-Wunused-but-set-variable]
3414 | int newports = 0;
| ^
drivers/scsi/fnic/fdls_disc.c:1685:13: warning: unused function 'fnic_fdls_start_flogi' [-Wunused-function]
1685 | static void fnic_fdls_start_flogi(struct fnic_iport_s *iport)
| ^~~~~~~~~~~~~~~~~~~~~
3 warnings generated.
vim +/nport_name +3333 drivers/scsi/fnic/fdls_disc.c
3327
3328 static void
3329 fdls_process_logo_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr)
3330 {
3331 struct fc_std_logo *logo = (struct fc_std_logo *)fchdr;
3332 uint32_t nport_id;
> 3333 uint64_t nport_name;
3334 struct fnic_tport_s *tport;
3335 struct fnic *fnic = iport->fnic;
3336 uint16_t oxid;
3337
3338 nport_id = ntoh24(logo->els.fl_n_port_id);
3339 nport_name = logo->els.fl_n_port_wwn;
3340
3341 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3342 "Process LOGO request from fcid: 0x%x", nport_id);
3343
3344 if (iport->state != FNIC_IPORT_STATE_READY) {
3345 FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
3346 "Dropping LOGO req from 0x%x in iport state: %d",
3347 nport_id, iport->state);
3348 return;
3349 }
3350
3351 tport = fnic_find_tport_by_fcid(iport, nport_id);
3352
3353 if (!tport) {
3354 /* We are not logged in with the nport, log and drop... */
3355 FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
3356 "Received LOGO from an nport not logged in: 0x%x",
3357 nport_id);
3358 return;
3359 }
3360 if (tport->fcid != nport_id) {
3361 FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
3362 "Received LOGO with invalid target port fcid: 0x%x",
3363 nport_id);
3364 return;
3365 }
3366 if (tport->timer_pending) {
3367 FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
3368 "tport fcid 0x%x: Canceling disc timer\n",
3369 tport->fcid);
3370 fnic_del_tport_timer_sync(fnic, tport);
3371 tport->timer_pending = 0;
3372 }
3373
3374 /* got a logo in response to adisc to a target which has logged out */
3375 if (tport->state == FDLS_TGT_STATE_ADISC) {
3376 tport->retry_counter = 0;
3377 oxid = ntohs(tport->oxid_used);
3378 fdls_free_tgt_oxid(iport, &iport->adisc_oxid_pool, oxid);
3379 fdls_delete_tport(iport, tport);
3380 fdls_send_logo_resp(iport, &logo->fchdr);
3381 if ((iport->state == FNIC_IPORT_STATE_READY)
3382 && (fdls_get_state(&iport->fabric) != FDLS_STATE_SEND_GPNFT)
3383 && (fdls_get_state(&iport->fabric) != FDLS_STATE_RSCN_GPN_FT)) {
3384 FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
3385 "Sending GPNFT in response to LOGO from Target:0x%x",
3386 nport_id);
3387 fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT);
3388 return;
3389 }
3390 } else {
3391 fdls_delete_tport(iport, tport);
3392 }
3393 if (iport->state == FNIC_IPORT_STATE_READY) {
3394 fdls_send_logo_resp(iport, &logo->fchdr);
3395 if ((fdls_get_state(&iport->fabric) != FDLS_STATE_SEND_GPNFT) &&
3396 (fdls_get_state(&iport->fabric) != FDLS_STATE_RSCN_GPN_FT)) {
3397 FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
3398 "Sending GPNFT in response to LOGO from Target:0x%x",
3399 nport_id);
3400 fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT);
3401 }
3402 }
3403 }
3404
3405 static void
3406 fdls_process_rscn(struct fnic_iport_s *iport, struct fc_frame_header *fchdr)
3407 {
3408 struct fc_std_rscn *rscn;
3409 struct fc_els_rscn_page *rscn_port = NULL;
3410 int num_ports;
3411 struct fnic_tport_s *tport, *next;
3412 uint32_t nport_id;
3413 uint8_t fcid[3];
> 3414 int newports = 0;
3415 struct fnic_fdls_fabric_s *fdls = &iport->fabric;
3416 struct fnic *fnic = iport->fnic;
3417 uint16_t rscn_payload_len;
3418
3419 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3420 "FDLS process RSCN %p", iport);
3421
3422 if (iport->state != FNIC_IPORT_STATE_READY) {
3423 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3424 "FDLS RSCN received in state(%d). Dropping",
3425 fdls_get_state(fdls));
3426 return;
3427 }
3428
3429 rscn = (struct fc_std_rscn *)fchdr;
3430 rscn_payload_len = be16_to_cpu(rscn->els.rscn_plen);
3431
3432 /* frame validation */
3433 if ((rscn_payload_len % 4 != 0) || (rscn_payload_len < 8)
3434 || (rscn_payload_len > 1024)
3435 || (rscn->els.rscn_page_len != 4)) {
3436 num_ports = 0;
3437 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3438 "RSCN payload_len: 0x%x page_len: 0x%x",
3439 rscn_payload_len, rscn->els.rscn_page_len);
3440 /* if this happens then we need to send ADISC to all the tports. */
3441 list_for_each_entry_safe(tport, next, &iport->tport_list, links) {
3442 if (tport->state == FDLS_TGT_STATE_READY)
3443 tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC;
3444 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3445 "RSCN for port id: 0x%x", tport->fcid);
3446 }
3447 } else {
3448 num_ports = (rscn_payload_len - 4) / rscn->els.rscn_page_len;
3449 rscn_port = (struct fc_els_rscn_page *)(rscn + 1);
3450 }
3451 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3452 "RSCN received for num_ports: %d payload_len: %d page_len: %d ",
3453 num_ports, rscn_payload_len, rscn->els.rscn_page_len);
3454
3455 /*
3456 * RSCN have at least one Port_ID page , but may not have any port_id
3457 * in it. If no port_id is specified in the Port_ID page , we send
3458 * ADISC to all the tports
3459 */
3460
3461 while (num_ports) {
3462
3463 memcpy(fcid, rscn_port->rscn_fid, 3);
3464
3465 nport_id = ntoh24(fcid);
3466 rscn_port++;
3467 num_ports--;
3468 /* if this happens then we need to send ADISC to all the tports. */
3469 if (nport_id == 0) {
3470 list_for_each_entry_safe(tport, next, &iport->tport_list,
3471 links) {
3472 if (tport->state == FDLS_TGT_STATE_READY)
3473 tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC;
3474
3475 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3476 "RSCN for port id: 0x%x", tport->fcid);
3477 }
3478 break;
3479 }
3480 tport = fnic_find_tport_by_fcid(iport, nport_id);
3481
3482 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3483 "RSCN port id list: 0x%x", nport_id);
3484
3485 if (!tport) {
3486 newports++;
3487 continue;
3488 }
3489 if (tport->state == FDLS_TGT_STATE_READY)
3490 tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC;
3491 }
3492
3493 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
3494 "FDLS process RSCN sending GPN_FT %p", iport);
3495 fdls_send_gpn_ft(iport, FDLS_STATE_RSCN_GPN_FT);
3496 fdls_send_rscn_resp(iport, fchdr);
3497 }
3498
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
© 2016 - 2024 Red Hat, Inc.