scsi: qla2xxx: Move rport registration out of internal work_list

Currently, the rport registration is being called from a single work element
that is used to process QLA internal "work_list".  This work_list is meant for
quick and simple task (ie no sleep).  The Rport registration process sometime
can be delayed by upper layer.  This causes back pressure with the internal
queue where other jobs are unable to move forward.

This patch will schedule the registration process with a new work element
(fc_port.reg_work).  While the RPort is being registered, the current state of
the fcport will not move forward until the registration is done.  If the state
of the fabric has changed, a new field/next_disc_state will record the next
action on whether to 'DELETE' or 'Reverify the session/ADISC'.

Signed-off-by: Quinn Tran <quinn.tran@cavium.com>
Signed-off-by: Himanshu Madhani <himanshu.madhani@cavium.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index c41d0dbbbd797eb280f7c32c7aac2beb927d61f8..16dd59bcd60a94ec350e708ea6de72e869939eaf 100644 (file)
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -2375,11 +2375,13 @@ typedef struct fc_port {
        unsigned long expires;
        struct list_head del_list_entry;
        struct work_struct free_work;
-
+       struct work_struct reg_work;
+       uint64_t jiffies_at_registration;
        struct qlt_plogi_ack_t *plogi_link[QLT_PLOGI_LINK_MAX];
 
        uint16_t tgt_id;
        uint16_t old_tgt_id;
+       uint16_t sec_since_registration;
 
        uint8_t fcp_prio;
 
@@ -2412,6 +2414,7 @@ typedef struct fc_port {
        struct qla_tgt_sess *tgt_session;
        struct ct_sns_desc ct_desc;
        enum discovery_state disc_state;
+       enum discovery_state next_disc_state;
        enum login_state fw_login_state;
        unsigned long dm_login_expire;
        unsigned long plogi_nack_done_deadline;
@@ -3222,7 +3225,6 @@ enum qla_work_type {
        QLA_EVT_GPDB,
        QLA_EVT_PRLI,
        QLA_EVT_GPSC,
-       QLA_EVT_UPD_FCPORT,
        QLA_EVT_GNL,
        QLA_EVT_NACK,
        QLA_EVT_RELOGIN,

diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 178974896b5c71cb14d92ab1b9772ce3be2dada2..b8e4abe804d5d3df7fe9d069a59ff3e68aa9ea64 100644 (file)
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -54,7 +54,7 @@ extern void qla2x00_abort_isp_cleanup(scsi_qla_host_t *);
 extern void qla2x00_quiesce_io(scsi_qla_host_t *);
 
 extern void qla2x00_update_fcport(scsi_qla_host_t *, fc_port_t *);
-
+void qla_register_fcport_fn(struct work_struct *);
 extern void qla2x00_alloc_fw_dump(scsi_qla_host_t *);
 extern void qla2x00_try_to_stop_firmware(scsi_qla_host_t *);
 
@@ -109,6 +109,7 @@ int qla24xx_post_newsess_work(struct scsi_qla_host *, port_id_t *, u8 *, u8*,
 int qla24xx_fcport_handle_login(struct scsi_qla_host *, fc_port_t *);
 int qla24xx_detect_sfp(scsi_qla_host_t *vha);
 int qla24xx_post_gpdb_work(struct scsi_qla_host *, fc_port_t *, u8);
+
 void qla2x00_async_prlo_done(struct scsi_qla_host *, fc_port_t *,
     uint16_t *);
 extern int qla2x00_post_async_prlo_work(struct scsi_qla_host *, fc_port_t *,
@@ -208,7 +209,7 @@ extern void qla2x00_disable_board_on_pci_error(struct work_struct *);
 extern void qla2x00_sp_compl(void *, int);
 extern void qla2xxx_qpair_sp_free_dma(void *);
 extern void qla2xxx_qpair_sp_compl(void *, int);
-extern int qla24xx_post_upd_fcport_work(struct scsi_qla_host *, fc_port_t *);
+extern void qla24xx_sched_upd_fcport(fc_port_t *);
 void qla2x00_handle_login_done_event(struct scsi_qla_host *, fc_port_t *,
        uint16_t *);
 int qla24xx_post_gnl_work(struct scsi_qla_host *, fc_port_t *);

diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 6d9c8a017ae9537973fa3b6185a9e4e79c1f6628..39710ebd595070bec6681d8927f21e439f190a85 100644 (file)
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1182,11 +1182,7 @@ void __qla24xx_handle_gpdb_event(scsi_qla_host_t *vha, struct event_arg *ea)
                vha->fcport_count++;
                ea->fcport->login_succ = 1;
 
-               ql_dbg(ql_dbg_disc, vha, 0x20d6,
-                   "%s %d %8phC post upd_fcport fcp_cnt %d\n",
-                   __func__, __LINE__,  ea->fcport->port_name,
-                   vha->fcport_count);
-               qla24xx_post_upd_fcport_work(vha, ea->fcport);
+               qla24xx_sched_upd_fcport(ea->fcport);
        } else if (ea->fcport->login_succ) {
                /*
                 * We have an existing session. A late RSCN delivery
@@ -1304,6 +1300,7 @@ int qla24xx_fcport_handle_login(struct scsi_qla_host *vha, fc_port_t *fcport)
 {
        u16 data[2];
        u64 wwn;
+       u16 sec;
 
        ql_dbg(ql_dbg_disc, vha, 0x20d8,
            "%s %8phC DS %d LS %d P %d fl %x confl %p rscn %d|%d login %d retry %d lid %d scan %d\n",
@@ -1435,6 +1432,22 @@ int qla24xx_fcport_handle_login(struct scsi_qla_host *vha, fc_port_t *fcport)
                        qla24xx_post_prli_work(vha, fcport);
                break;
 
+       case DSC_UPD_FCPORT:
+               sec =  jiffies_to_msecs(jiffies -
+                   fcport->jiffies_at_registration)/1000;
+               if (fcport->sec_since_registration < sec && sec &&
+                   !(sec % 60)) {
+                       fcport->sec_since_registration = sec;
+                       ql_dbg(ql_dbg_disc, fcport->vha, 0xffff,
+                           "%s %8phC - Slow Rport registration(%d Sec)\n",
+                           __func__, fcport->port_name, sec);
+               }
+
+               if (fcport->next_disc_state != DSC_DELETE_PEND)
+                       fcport->next_disc_state = DSC_ADISC;
+               set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
+               break;
+
        default:
                break;
        }
@@ -1550,8 +1563,10 @@ void qla2x00_fcport_event_handler(scsi_qla_host_t *vha, struct event_arg *ea)
                case RSCN_PORT_ADDR:
                        fcport = qla2x00_find_fcport_by_nportid
                                (vha, &ea->id, 1);
-                       if (fcport)
+                       if (fcport) {
                                fcport->scan_needed = 1;
+                               fcport->rscn_gen++;
+                       }
 
                        spin_lock_irqsave(&vha->work_lock, flags);
                        if (vha->scan.scan_flags == 0) {
@@ -4723,6 +4738,7 @@ qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
                fcport = NULL;
        }
        INIT_WORK(&fcport->del_work, qla24xx_delete_sess_fn);
+       INIT_WORK(&fcport->reg_work, qla_register_fcport_fn);
        INIT_LIST_HEAD(&fcport->gnl_entry);
        INIT_LIST_HEAD(&fcport->list);
 
@@ -5218,13 +5234,15 @@ qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
 void
 qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
-       fcport->vha = vha;
-
        if (IS_SW_RESV_ADDR(fcport->d_id))
                return;
 
+       ql_dbg(ql_dbg_disc, vha, 0x20ef, "%s %8phC\n",
+           __func__, fcport->port_name);
+
+       fcport->disc_state = DSC_UPD_FCPORT;
+       fcport->login_retry = vha->hw->login_retry_count;
        fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
-       fcport->disc_state = DSC_LOGIN_COMPLETE;
        fcport->deleted = 0;
        fcport->logout_on_delete = 1;
        fcport->login_retry = vha->hw->login_retry_count;
@@ -5286,6 +5304,36 @@ qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
                }
        }
        qla2x00_set_fcport_state(fcport, FCS_ONLINE);
+
+       fcport->disc_state = DSC_LOGIN_COMPLETE;
+}
+
+void qla_register_fcport_fn(struct work_struct *work)
+{
+       fc_port_t *fcport = container_of(work, struct fc_port, reg_work);
+       u32 rscn_gen = fcport->rscn_gen;
+       u16 data[2];
+
+       if (IS_SW_RESV_ADDR(fcport->d_id))
+               return;
+
+       qla2x00_update_fcport(fcport->vha, fcport);
+
+       if (rscn_gen != fcport->rscn_gen) {
+               /* RSCN(s) came in while registration */
+               switch (fcport->next_disc_state) {
+               case DSC_DELETE_PEND:
+                       qlt_schedule_sess_for_deletion(fcport);
+                       break;
+               case DSC_ADISC:
+                       data[0] = data[1] = 0;
+                       qla2x00_post_async_adisc_work(fcport->vha, fcport,
+                           data);
+                       break;
+               default:
+                       break;
+               }
+       }
 }
 
 /*

diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 42b8f0d3e580da932237826d07c2c36e49bfa7f3..1ae31a119a37163831ac2209f81bb138b204b981 100644 (file)
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -4761,16 +4761,25 @@ qlafx00_post_aenfx_work(struct scsi_qla_host *vha,  uint32_t evtcode,
        return qla2x00_post_work(vha, e);
 }
 
-int qla24xx_post_upd_fcport_work(struct scsi_qla_host *vha, fc_port_t *fcport)
+void qla24xx_sched_upd_fcport(fc_port_t *fcport)
 {
-       struct qla_work_evt *e;
+       unsigned long flags;
 
-       e = qla2x00_alloc_work(vha, QLA_EVT_UPD_FCPORT);
-       if (!e)
-               return QLA_FUNCTION_FAILED;
+       if (IS_SW_RESV_ADDR(fcport->d_id))
+               return;
 
-       e->u.fcport.fcport = fcport;
-       return qla2x00_post_work(vha, e);
+       spin_lock_irqsave(&fcport->vha->work_lock, flags);
+       if (fcport->disc_state == DSC_UPD_FCPORT) {
+               spin_unlock_irqrestore(&fcport->vha->work_lock, flags);
+               return;
+       }
+       fcport->jiffies_at_registration = jiffies;
+       fcport->sec_since_registration = 0;
+       fcport->next_disc_state = DSC_DELETED;
+       fcport->disc_state = DSC_UPD_FCPORT;
+       spin_unlock_irqrestore(&fcport->vha->work_lock, flags);
+
+       queue_work(system_unbound_wq, &fcport->reg_work);
 }
 
 static
@@ -5025,9 +5034,6 @@ qla2x00_do_work(struct scsi_qla_host *vha)
                case QLA_EVT_GPSC:
                        qla24xx_async_gpsc(vha, e->u.fcport.fcport);
                        break;
-               case QLA_EVT_UPD_FCPORT:
-                       qla2x00_update_fcport(vha, e->u.fcport.fcport);
-                       break;
                case QLA_EVT_GNL:
                        qla24xx_async_gnl(vha, e->u.fcport.fcport);
                        break;

diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
index 8c811b251d4289c73bc4d2691f1a154e3187b7a8..34fadd320f5576c93b3c5cdeaa5a0040cc5676f1 100644 (file)
--- a/drivers/scsi/qla2xxx/qla_target.c
+++ b/drivers/scsi/qla2xxx/qla_target.c
@@ -600,14 +600,7 @@ void qla2x00_async_nack_sp_done(void *s, int res)
                        sp->fcport->login_succ = 1;
 
                        vha->fcport_count++;
-
-                       ql_dbg(ql_dbg_disc, vha, 0x20f3,
-                           "%s %d %8phC post upd_fcport fcp_cnt %d\n",
-                           __func__, __LINE__,
-                           sp->fcport->port_name,
-                           vha->fcport_count);
-                       sp->fcport->disc_state = DSC_UPD_FCPORT;
-                       qla24xx_post_upd_fcport_work(vha, sp->fcport);
+                       qla24xx_sched_upd_fcport(sp->fcport);
                } else {
                        sp->fcport->login_retry = 0;
                        sp->fcport->disc_state = DSC_LOGIN_COMPLETE;
@@ -1230,11 +1223,12 @@ void qlt_schedule_sess_for_deletion(struct fc_port *sess)
 {
        struct qla_tgt *tgt = sess->tgt;
        unsigned long flags;
+       u16 sec;
 
-       if (sess->disc_state == DSC_DELETE_PEND)
+       switch (sess->disc_state) {
+       case DSC_DELETE_PEND:
                return;
-
-       if (sess->disc_state == DSC_DELETED) {
+       case DSC_DELETED:
                if (tgt && tgt->tgt_stop && (tgt->sess_count == 0))
                        wake_up_all(&tgt->waitQ);
                if (sess->vha->fcport_count == 0)
@@ -1243,6 +1237,24 @@ void qlt_schedule_sess_for_deletion(struct fc_port *sess)
                if (!sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN] &&
                        !sess->plogi_link[QLT_PLOGI_LINK_CONFLICT])
                        return;
+               break;
+       case DSC_UPD_FCPORT:
+               /*
+                * This port is not done reporting to upper layer.
+                * let it finish
+                */
+               sess->next_disc_state = DSC_DELETE_PEND;
+               sec = jiffies_to_msecs(jiffies -
+                   sess->jiffies_at_registration)/1000;
+               if (sess->sec_since_registration < sec && sec && !(sec % 5)) {
+                       sess->sec_since_registration = sec;
+                       ql_dbg(ql_dbg_disc, sess->vha, 0xffff,
+                           "%s %8phC : Slow Rport registration(%d Sec)\n",
+                           __func__, sess->port_name, sec);
+               }
+               return;
+       default:
+               break;
        }
 
        if (sess->deleted == QLA_SESS_DELETED)
@@ -4752,6 +4764,32 @@ static int qlt_handle_login(struct scsi_qla_host *vha,
                goto out;
        }
 
+       if (sess->disc_state == DSC_UPD_FCPORT) {
+               u16 sec;
+
+               /*
+                * Remote port registration is still going on from
+                * previous login. Allow it to finish before we
+                * accept the new login.
+                */
+               sess->next_disc_state = DSC_DELETE_PEND;
+               sec = jiffies_to_msecs(jiffies -
+                   sess->jiffies_at_registration) / 1000;
+               if (sess->sec_since_registration < sec && sec &&
+                   !(sec % 5)) {
+                       sess->sec_since_registration = sec;
+                       ql_dbg(ql_dbg_disc, vha, 0xffff,
+                           "%s %8phC - Slow Rport registration (%d Sec)\n",
+                           __func__, sess->port_name, sec);
+               }
+
+               if (!conflict_sess)
+                       kmem_cache_free(qla_tgt_plogi_cachep, pla);
+
+               qlt_send_term_imm_notif(vha, iocb, 1);
+               goto out;
+       }
+
        qlt_plogi_ack_link(vha, pla, sess, QLT_PLOGI_LINK_SAME_WWN);
        sess->d_id = port_id;
        sess->login_gen++;
@@ -4910,6 +4948,7 @@ static int qlt_24xx_handle_els(struct scsi_qla_host *vha,
 
                if (sess != NULL) {
                        bool delete = false;
+                       int sec;
                        spin_lock_irqsave(&tgt->ha->tgt.sess_lock, flags);
                        switch (sess->fw_login_state) {
                        case DSC_LS_PLOGI_PEND:
@@ -4922,9 +4961,24 @@ static int qlt_24xx_handle_els(struct scsi_qla_host *vha,
                        }
 
                        switch (sess->disc_state) {
+                       case DSC_UPD_FCPORT:
+                               spin_unlock_irqrestore(&tgt->ha->tgt.sess_lock,
+                                   flags);
+
+                               sec = jiffies_to_msecs(jiffies -
+                                   sess->jiffies_at_registration)/1000;
+                               if (sess->sec_since_registration < sec && sec &&
+                                   !(sec % 5)) {
+                                       sess->sec_since_registration = sec;
+                                       ql_dbg(ql_dbg_disc, sess->vha, 0xffff,
+                                           "%s %8phC : Slow Rport registration(%d Sec)\n",
+                                           __func__, sess->port_name, sec);
+                               }
+                               qlt_send_term_imm_notif(vha, iocb, 1);
+                               return 0;
+
                        case DSC_LOGIN_PEND:
                        case DSC_GPDB:
-                       case DSC_UPD_FCPORT:
                        case DSC_LOGIN_COMPLETE:
                        case DSC_ADISC:
                                delete = false;
@@ -5964,10 +6018,7 @@ static fc_port_t *qlt_get_port_database(struct scsi_qla_host *vha,
        case MODE_DUAL:
                if (newfcport) {
                        if (!IS_IIDMA_CAPABLE(vha->hw) || !vha->hw->flags.gpsc_supported) {
-                               ql_dbg(ql_dbg_disc, vha, 0x20fe,
-                                  "%s %d %8phC post upd_fcport fcp_cnt %d\n",
-                                  __func__, __LINE__, fcport->port_name, vha->fcport_count);
-                               qla24xx_post_upd_fcport_work(vha, fcport);
+                               qla24xx_sched_upd_fcport(fcport);
                        } else {
                                ql_dbg(ql_dbg_disc, vha, 0x20ff,
                                   "%s %d %8phC post gpsc fcp_cnt %d\n",