Disable build of xen kernel.

[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.25 / patches.drivers / open-fcoe-beta3-update

Subject: Open-FCoE update for Beta3
From: John Fastabend <john.r.fastabend@intel.com>
Date: Thu Nov 6 13:01:32 2008 +0100:
Git: 2d8ac46f55c5f06ac3fe9830c899386789aa8900
References: bnc#438954

Incremental Open-FCoE update for Beta3.

Signed-off-by: John Fastabend <john.r.fastabend@intel.com>
Acked-by: Hannes Reinecke <hare@suse.de>

diff --git a/drivers/scsi/fcoe/fcoe_if.c b/drivers/scsi/fcoe/fcoe_if.c
index 7f983e2..73b83ce 100644
--- a/drivers/scsi/fcoe/fcoe_if.c
+++ b/drivers/scsi/fcoe/fcoe_if.c
@@ -155,18 +155,18 @@ int fcoe_destroy_interface(const char *ifname)
        list_del(&fc->list);
        write_unlock_bh(&fci->fcoe_hostlist_lock);
 
-       /* Cleanup the fc_lport */
-       fc_lport_destroy(lp);
-       fc_fcp_destroy(lp);
-       if (lp->emp)
-               fc_exch_mgr_free(lp->emp);
+       /* Don't listen for Ethernet packets anymore */
+       dev_remove_pack(&fc->fcoe_packet_type);
 
        /* Detach from the scsi-ml */
        fc_remove_host(lp->host);
        scsi_remove_host(lp->host);
 
-       /* Don't listen for Ethernet packets anymore */
-       dev_remove_pack(&fc->fcoe_packet_type);
+       /* Cleanup the fc_lport */
+       fc_lport_destroy(lp);
+       fc_fcp_destroy(lp);
+       if (lp->emp)
+               fc_exch_mgr_free(lp->emp);
 
        /* Delete secondary MAC addresses */
        rtnl_lock();
@@ -388,8 +388,7 @@ static int libfc_config(struct fc_lport *lp)
        fc_exch_init(lp);
        fc_lport_init(lp);
        fc_rport_init(lp);
-       fc_ns_init(lp);
-       fc_attr_init(lp);
+       fc_disc_init(lp);
 
        return 0;
 }
diff --git a/drivers/scsi/fcoe/fcoeinit.c b/drivers/scsi/fcoe/fcoeinit.c
index e069835..7d52ed5 100644
--- a/drivers/scsi/fcoe/fcoeinit.c
+++ b/drivers/scsi/fcoe/fcoeinit.c
@@ -53,8 +53,8 @@ struct scsi_transport_template *fcoe_transport_template;
 
 static int fcoe_reset(struct Scsi_Host *shost)
 {
-       struct fc_lport *lp = shost_priv(shost);
-       fc_lport_enter_reset(lp);
+       struct fc_lport *lport = shost_priv(shost);
+       fc_lport_reset(lport);
        return 0;
 }
 
@@ -66,11 +66,10 @@ struct fc_function_template fcoe_transport_function = {
        .show_host_active_fc4s = 1,
        .show_host_maxframe_size = 1,
 
-       .get_host_port_id = fc_get_host_port_id,
        .show_host_port_id = 1,
+       .show_host_supported_speeds = 1,
        .get_host_speed = fc_get_host_speed,
        .show_host_speed = 1,
-       .get_host_port_type = fc_get_host_port_type,
        .show_host_port_type = 1,
        .get_host_port_state = fc_get_host_port_state,
        .show_host_port_state = 1,
@@ -80,7 +79,6 @@ struct fc_function_template fcoe_transport_function = {
        .show_rport_maxframe_size = 1,
        .show_rport_supported_classes = 1,
 
-       .get_host_fabric_name = fc_get_host_fabric_name,
        .show_host_fabric_name = 1,
        .show_starget_node_name = 1,
        .show_starget_port_name = 1,
@@ -89,6 +87,8 @@ struct fc_function_template fcoe_transport_function = {
        .show_rport_dev_loss_tmo = 1,
        .get_fc_host_stats = fc_get_host_stats,
        .issue_fc_host_lip = fcoe_reset,
+
+       .terminate_rport_io = fc_rport_terminate_io,
 };
 
 struct fcoe_percpu_s *fcoe_percpu[NR_CPUS];
diff --git a/drivers/scsi/libfc/Makefile b/drivers/scsi/libfc/Makefile
index 0a31ca2..e6d4086 100644
--- a/drivers/scsi/libfc/Makefile
+++ b/drivers/scsi/libfc/Makefile
@@ -3,10 +3,9 @@
 obj-$(CONFIG_LIBFC) += libfc.o
 
 libfc-objs := \
-       fc_ns.o \
+       fc_disc.o \
        fc_exch.o \
        fc_frame.o \
        fc_lport.o \
        fc_rport.o \
-       fc_attr.o \
        fc_fcp.o
diff --git a/drivers/scsi/libfc/fc_attr.c b/drivers/scsi/libfc/fc_attr.c
deleted file mode 100644
index d73f39e..0000000
--- a/drivers/scsi/libfc/fc_attr.c
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright(c) 2007 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Maintained at www.Open-FCoE.org
- */
-
-#include <linux/kernel.h>
-#include <linux/types.h>
-
-#include <scsi/scsi_host.h>
-
-#include <scsi/libfc/libfc.h>
-
-MODULE_AUTHOR("Open-FCoE.org");
-MODULE_DESCRIPTION("libfc");
-MODULE_LICENSE("GPL");
-
-void fc_get_host_port_id(struct Scsi_Host *shost)
-{
-       struct fc_lport *lp = shost_priv(shost);
-
-       fc_host_port_id(shost) = fc_lport_get_fid(lp);
-}
-EXPORT_SYMBOL(fc_get_host_port_id);
-
-void fc_get_host_speed(struct Scsi_Host *shost)
-{
-       /*
-        * should be obtain from DEC or Enet Driver
-        */
-       fc_host_speed(shost) = 1;       /* for now it is 1g */
-}
-EXPORT_SYMBOL(fc_get_host_speed);
-
-void fc_get_host_port_type(struct Scsi_Host *shost)
-{
-       fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
-}
-EXPORT_SYMBOL(fc_get_host_port_type);
-
-void fc_get_host_fabric_name(struct Scsi_Host *shost)
-{
-       struct fc_lport *lp = shost_priv(shost);
-
-       fc_host_fabric_name(shost) = lp->wwnn;
-}
-EXPORT_SYMBOL(fc_get_host_fabric_name);
-
-void fc_attr_init(struct fc_lport *lp)
-{
-       fc_host_node_name(lp->host) = lp->wwnn;
-       fc_host_port_name(lp->host) = lp->wwpn;
-       fc_host_supported_classes(lp->host) = FC_COS_CLASS3;
-       memset(fc_host_supported_fc4s(lp->host), 0,
-              sizeof(fc_host_supported_fc4s(lp->host)));
-       fc_host_supported_fc4s(lp->host)[2] = 1;
-       fc_host_supported_fc4s(lp->host)[7] = 1;
-       /* This value is also unchanging */
-       memset(fc_host_active_fc4s(lp->host), 0,
-              sizeof(fc_host_active_fc4s(lp->host)));
-       fc_host_active_fc4s(lp->host)[2] = 1;
-       fc_host_active_fc4s(lp->host)[7] = 1;
-       fc_host_maxframe_size(lp->host) = lp->mfs;
-}
-EXPORT_SYMBOL(fc_attr_init);
-
-void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
-{
-       if (timeout)
-               rport->dev_loss_tmo = timeout + 5;
-       else
-               rport->dev_loss_tmo = 30;
-
-}
-EXPORT_SYMBOL(fc_set_rport_loss_tmo);
-
-struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
-{
-       int i;
-       struct fc_host_statistics *fcoe_stats;
-       struct fc_lport *lp = shost_priv(shost);
-       struct timespec v0, v1;
-
-       fcoe_stats = &lp->host_stats;
-       memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
-
-       jiffies_to_timespec(jiffies, &v0);
-       jiffies_to_timespec(lp->boot_time, &v1);
-       fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
-
-       for_each_online_cpu(i) {
-               struct fcoe_dev_stats *stats = lp->dev_stats[i];
-               if (stats == NULL)
-                       continue;
-               fcoe_stats->tx_frames += stats->TxFrames;
-               fcoe_stats->tx_words += stats->TxWords;
-               fcoe_stats->rx_frames += stats->RxFrames;
-               fcoe_stats->rx_words += stats->RxWords;
-               fcoe_stats->error_frames += stats->ErrorFrames;
-               fcoe_stats->invalid_crc_count += stats->InvalidCRCCount;
-               fcoe_stats->fcp_input_requests += stats->InputRequests;
-               fcoe_stats->fcp_output_requests += stats->OutputRequests;
-               fcoe_stats->fcp_control_requests += stats->ControlRequests;
-               fcoe_stats->fcp_input_megabytes += stats->InputMegabytes;
-               fcoe_stats->fcp_output_megabytes += stats->OutputMegabytes;
-               fcoe_stats->link_failure_count += stats->LinkFailureCount;
-       }
-       fcoe_stats->lip_count = -1;
-       fcoe_stats->nos_count = -1;
-       fcoe_stats->loss_of_sync_count = -1;
-       fcoe_stats->loss_of_signal_count = -1;
-       fcoe_stats->prim_seq_protocol_err_count = -1;
-       fcoe_stats->dumped_frames = -1;
-       return fcoe_stats;
-}
-EXPORT_SYMBOL(fc_get_host_stats);
diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c
new file mode 100644
index 0000000..30403aa
--- /dev/null
+++ b/drivers/scsi/libfc/fc_disc.c
@@ -0,0 +1,599 @@
+/*
+ * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Maintained at www.Open-FCoE.org
+ */
+
+/*
+ * Target Discovery
+ * Actually, this discovers all FC-4 remote ports, including FCP initiators.
+ */
+
+#include <linux/timer.h>
+#include <linux/err.h>
+#include <asm/unaligned.h>
+
+#include <scsi/fc/fc_gs.h>
+
+#include <scsi/libfc/libfc.h>
+
+#define FC_DISC_RETRY_LIMIT    3       /* max retries */
+#define FC_DISC_RETRY_DELAY    500UL   /* (msecs) delay */
+
+int fc_disc_debug;
+
+static void fc_disc_gpn_ft_req(struct fc_lport *);
+static void fc_disc_gpn_ft_resp(struct fc_seq *, struct fc_frame *, void *);
+static int fc_disc_new_target(struct fc_lport *, struct fc_rport *,
+                           struct fc_rport_identifiers *);
+static void fc_disc_del_target(struct fc_lport *, struct fc_rport *);
+static void fc_disc_done(struct fc_lport *);
+static void fc_disc_error(struct fc_lport *, struct fc_frame *);
+static void fc_disc_timeout(struct work_struct *);
+static void fc_disc_single(struct fc_lport *, struct fc_disc_port *);
+static int fc_disc_restart(struct fc_lport *);
+
+/**
+ * fc_disc_rscn_req - Handle Registered State Change Notification (RSCN)
+ * @sp: Current sequence of the RSCN exchange
+ * @fp: RSCN Frame
+ * @lp: Fibre Channel host port instance
+ */
+static void fc_disc_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
+                          struct fc_lport *lp)
+{
+       struct fc_els_rscn *rp;
+       struct fc_els_rscn_page *pp;
+       struct fc_seq_els_data rjt_data;
+       unsigned int len;
+       int redisc = 0;
+       enum fc_els_rscn_ev_qual ev_qual;
+       enum fc_els_rscn_addr_fmt fmt;
+       LIST_HEAD(disc_list);
+       struct fc_disc_port *dp, *next;
+
+       rp = fc_frame_payload_get(fp, sizeof(*rp));
+
+       if (!rp || rp->rscn_page_len != sizeof(*pp))
+               goto reject;
+
+       len = ntohs(rp->rscn_plen);
+       if (len < sizeof(*rp))
+               goto reject;
+       len -= sizeof(*rp);
+
+       for (pp = (void *)(rp + 1); len; len -= sizeof(*pp), pp++) {
+               ev_qual = pp->rscn_page_flags >> ELS_RSCN_EV_QUAL_BIT;
+               ev_qual &= ELS_RSCN_EV_QUAL_MASK;
+               fmt = pp->rscn_page_flags >> ELS_RSCN_ADDR_FMT_BIT;
+               fmt &= ELS_RSCN_ADDR_FMT_MASK;
+               /*
+                * if we get an address format other than port
+                * (area, domain, fabric), then do a full discovery
+                */
+               switch (fmt) {
+               case ELS_ADDR_FMT_PORT:
+                       dp = kzalloc(sizeof(*dp), GFP_KERNEL);
+                       if (!dp) {
+                               redisc = 1;
+                               break;
+                       }
+                       dp->lp = lp;
+                       dp->ids.port_id = ntoh24(pp->rscn_fid);
+                       dp->ids.port_name = -1;
+                       dp->ids.node_name = -1;
+                       dp->ids.roles = FC_RPORT_ROLE_UNKNOWN;
+                       list_add_tail(&dp->peers, &disc_list);
+                       break;
+               case ELS_ADDR_FMT_AREA:
+               case ELS_ADDR_FMT_DOM:
+               case ELS_ADDR_FMT_FAB:
+               default:
+                       redisc = 1;
+                       break;
+               }
+       }
+       lp->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
+       if (redisc) {
+               if (fc_disc_debug)
+                       FC_DBG("RSCN received: rediscovering\n");
+               list_for_each_entry_safe(dp, next, &disc_list, peers) {
+                       list_del(&dp->peers);
+                       kfree(dp);
+               }
+               fc_disc_restart(lp);
+       } else {
+               if (fc_disc_debug)
+                       FC_DBG("RSCN received: not rediscovering. "
+                               "redisc %d state %d in_prog %d\n",
+                               redisc, lp->state, lp->disc_pending);
+               list_for_each_entry_safe(dp, next, &disc_list, peers) {
+                       list_del(&dp->peers);
+                       fc_disc_single(lp, dp);
+               }
+       }
+       fc_frame_free(fp);
+       return;
+reject:
+       rjt_data.fp = NULL;
+       rjt_data.reason = ELS_RJT_LOGIC;
+       rjt_data.explan = ELS_EXPL_NONE;
+       lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
+       fc_frame_free(fp);
+}
+
+static void fc_disc_recv_req(struct fc_seq *sp, struct fc_frame *fp,
+                          struct fc_lport *lp)
+{
+       switch (fc_frame_payload_op(fp)) {
+       case ELS_RSCN:
+               fc_disc_rscn_req(sp, fp, lp);
+               break;
+       default:
+               FC_DBG("fc_disc recieved an unexpected request\n");
+               break;
+       }
+}
+
+/*
+ * Refresh target discovery, perhaps due to an RSCN.
+ * A configurable delay is introduced to collect any subsequent RSCNs.
+ */
+static int fc_disc_restart(struct fc_lport *lp)
+{
+       if (!lp->disc_requested && !lp->disc_pending) {
+               schedule_delayed_work(&lp->disc_work,
+                               msecs_to_jiffies(lp->disc_delay * 1000));
+       }
+       lp->disc_requested = 1;
+       return 0;
+}
+
+/*
+ * Fibre Channel Target discovery.
+ *
+ * Returns non-zero if discovery cannot be started.
+ *
+ * Callback is called for each target remote port found in discovery.
+ * When discovery is complete, the callback is called with a NULL remote port.
+ * Discovery may be restarted after an RSCN is received, causing the
+ * callback to be called after discovery complete is indicated.
+ */
+int fc_disc_start(struct fc_lport *lp)
+{
+       struct fc_rport *rport;
+       int error;
+       struct fc_rport_identifiers ids;
+
+       /*
+        * If not ready, or already running discovery, just set request flag.
+        */
+       if (!fc_lport_test_ready(lp) || lp->disc_pending) {
+               lp->disc_requested = 1;
+
+               return 0;
+       }
+       lp->disc_pending = 1;
+       lp->disc_requested = 0;
+       lp->disc_retry_count = 0;
+
+       /*
+        * Handle point-to-point mode as a simple discovery
+        * of the remote port.
+        */
+       rport = lp->ptp_rp;
+       if (rport) {
+               ids.port_id = rport->port_id;
+               ids.port_name = rport->port_name;
+               ids.node_name = rport->node_name;
+               ids.roles = FC_RPORT_ROLE_UNKNOWN;
+               get_device(&rport->dev);
+
+               error = fc_disc_new_target(lp, rport, &ids);
+               put_device(&rport->dev);
+               if (!error)
+                       fc_disc_done(lp);
+       } else {
+               fc_block_rports(lp);
+               fc_disc_gpn_ft_req(lp); /* get ports by FC-4 type */
+               error = 0;
+       }
+       return error;
+}
+
+/*
+ * Restart discovery after a delay due to resource shortages.
+ * If the error persists, the discovery will be abandoned.
+ */
+static void fc_disc_retry(struct fc_lport *lp)
+{
+       unsigned long delay = FC_DISC_RETRY_DELAY;
+
+       if (!lp->disc_retry_count)
+               delay /= 4;     /* timeout faster first time */
+       if (lp->disc_retry_count++ < FC_DISC_RETRY_LIMIT)
+               schedule_delayed_work(&lp->disc_work,
+                                     msecs_to_jiffies(delay));
+       else
+               fc_disc_done(lp);
+}
+
+/*
+ * Handle new target found by discovery.
+ * Create remote port and session if needed.
+ * Ignore returns of our own FID & WWPN.
+ *
+ * If a non-NULL rp is passed in, it is held for the caller, but not for us.
+ *
+ * Events delivered are:
+ *  FC_EV_READY, when remote port is rediscovered.
+ */
+static int fc_disc_new_target(struct fc_lport *lp,
+                             struct fc_rport *rport,
+                             struct fc_rport_identifiers *ids)
+{
+       struct fc_rport_libfc_priv *rp;
+       int error = 0;
+
+       if (rport && ids->port_name) {
+               if (rport->port_name == -1) {
+                       /*
+                        * Set WWN and fall through to notify of create.
+                        */
+                       fc_rport_set_name(rport, ids->port_name,
+                                         rport->node_name);
+               } else if (rport->port_name != ids->port_name) {
+                       /*
+                        * This is a new port with the same FCID as
+                        * a previously-discovered port.  Presumably the old
+                        * port logged out and a new port logged in and was
+                        * assigned the same FCID.  This should be rare.
+                        * Delete the old one and fall thru to re-create.
+                        */
+                       fc_disc_del_target(lp, rport);
+                       rport = NULL;
+               }
+       }
+       if (((ids->port_name != -1) || (ids->port_id != -1)) &&
+           ids->port_id != lp->fid && ids->port_name != lp->wwpn) {
+               if (!rport) {
+                       rport = lp->tt.rport_lookup(lp, ids->port_id);
+                       if (!rport) {
+                               struct fc_disc_port dp;
+                               dp.lp = lp;
+                               dp.ids.port_id = ids->port_id;
+                               dp.ids.port_name = ids->port_name;
+                               dp.ids.node_name = ids->node_name;
+                               dp.ids.roles = ids->roles;
+                               rport = fc_rport_dummy_create(&dp);
+                       }
+                       if (!rport)
+                               error = ENOMEM;
+               }
+               if (rport) {
+                       rp = rport->dd_data;
+                       rp->event_callback = lp->tt.event_callback;
+                       rp->rp_state = RPORT_ST_INIT;
+                       lp->tt.rport_login(rport);
+               }
+       }
+       return error;
+}
+
+/*
+ * Delete the remote port.
+ */
+static void fc_disc_del_target(struct fc_lport *lp, struct fc_rport *rport)
+{
+       lp->tt.rport_reset(rport);
+       fc_remote_port_delete(rport);   /* release hold from create */
+}
+
+/*
+ * Done with discovery
+ */
+static void fc_disc_done(struct fc_lport *lp)
+{
+       lp->disc_done = 1;
+       lp->disc_pending = 0;
+       if (lp->disc_requested)
+               lp->tt.disc_start(lp);
+}
+
+/**
+ * fc_disc_gpn_ft_req - Send Get Port Names by FC-4 type (GPN_FT) request
+ * @lp: Fibre Channel host port instance
+ */
+static void fc_disc_gpn_ft_req(struct fc_lport *lp)
+{
+       struct fc_frame *fp;
+       struct fc_seq *sp = NULL;
+       struct req {
+               struct fc_ct_hdr ct;
+               struct fc_ns_gid_ft gid;
+       } *rp;
+       int error = 0;
+
+       lp->disc_buf_len = 0;
+       lp->disc_seq_count = 0;
+       fp = fc_frame_alloc(lp, sizeof(*rp));
+       if (fp == NULL) {
+               error = ENOMEM;
+       } else {
+               rp = fc_frame_payload_get(fp, sizeof(*rp));
+               fc_fill_dns_hdr(lp, &rp->ct, FC_NS_GPN_FT, sizeof(rp->gid));
+               rp->gid.fn_fc4_type = FC_TYPE_FCP;
+
+               WARN_ON(!fc_lport_test_ready(lp));
+
+               fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
+               sp = lp->tt.exch_seq_send(lp, fp,
+                                         fc_disc_gpn_ft_resp, NULL,
+                                         lp, lp->e_d_tov,
+                                         lp->fid,
+                                         FC_FID_DIR_SERV,
+                                         FC_FC_SEQ_INIT | FC_FC_END_SEQ);
+       }
+       if (error || sp == NULL)
+               fc_disc_retry(lp);
+}
+
+/*
+ * Handle error on dNS request.
+ */
+static void fc_disc_error(struct fc_lport *lp, struct fc_frame *fp)
+{
+       int err = PTR_ERR(fp);
+
+       switch (err) {
+       case -FC_EX_TIMEOUT:
+               if (lp->disc_retry_count++ < FC_DISC_RETRY_LIMIT) {
+                       fc_disc_gpn_ft_req(lp);
+               } else {
+                       FC_DBG("err %d - ending\n", err);
+                       fc_disc_done(lp);
+               }
+               break;
+       default:
+               FC_DBG("err %d - ending\n", err);
+               fc_disc_done(lp);
+               break;
+       }
+}
+
+/**
+ * fc_disc_gpn_ft_parse - Parse the list of IDs and names resulting from a request
+ * @lp: Fibre Channel host port instance
+ * @buf: GPN_FT response buffer
+ * @len: size of response buffer
+ */
+static int fc_disc_gpn_ft_parse(struct fc_lport *lp, void *buf, size_t len)
+{
+       struct fc_gpn_ft_resp *np;
+       char *bp;
+       size_t plen;
+       size_t tlen;
+       int error = 0;
+       struct fc_disc_port dp;
+       struct fc_rport *rp;
+       struct fc_rport_libfc_priv *rpp;
+
+       /*
+        * Handle partial name record left over from previous call.
+        */
+       bp = buf;
+       plen = len;
+       np = (struct fc_gpn_ft_resp *)bp;
+       tlen = lp->disc_buf_len;
+       if (tlen) {
+               WARN_ON(tlen >= sizeof(*np));
+               plen = sizeof(*np) - tlen;
+               WARN_ON(plen <= 0);
+               WARN_ON(plen >= sizeof(*np));
+               if (plen > len)
+                       plen = len;
+               np = &lp->disc_buf;
+               memcpy((char *)np + tlen, bp, plen);
+
+               /*
+                * Set bp so that the loop below will advance it to the
+                * first valid full name element.
+                */
+               bp -= tlen;
+               len += tlen;
+               plen += tlen;
+               lp->disc_buf_len = (unsigned char) plen;
+               if (plen == sizeof(*np))
+                       lp->disc_buf_len = 0;
+       }
+
+       /*
+        * Handle full name records, including the one filled from above.
+        * Normally, np == bp and plen == len, but from the partial case above,
+        * bp, len describe the overall buffer, and np, plen describe the
+        * partial buffer, which if would usually be full now.
+        * After the first time through the loop, things return to "normal".
+        */
+       while (plen >= sizeof(*np)) {
+               dp.lp = lp;
+               dp.ids.port_id = ntoh24(np->fp_fid);
+               dp.ids.port_name = ntohll(np->fp_wwpn);
+               dp.ids.node_name = -1;
+               dp.ids.roles = FC_RPORT_ROLE_UNKNOWN;
+
+               if ((dp.ids.port_id != lp->fid) &&
+                   (dp.ids.port_name != lp->wwpn)) {
+                       rp = fc_rport_dummy_create(&dp);
+                       if (rp) {
+                               rpp = rp->dd_data;
+                               rpp->local_port = lp;
+                               lp->tt.rport_login(rp);
+                       } else
+                               FC_DBG("Failed to allocate memory for "
+                                      "the newly discovered port (%6x)\n",
+                                      dp.ids.port_id);
+               }
+
+               if (np->fp_flags & FC_NS_FID_LAST) {
+                       fc_disc_done(lp);
+                       len = 0;
+                       break;
+               }
+               len -= sizeof(*np);
+               bp += sizeof(*np);
+               np = (struct fc_gpn_ft_resp *)bp;
+               plen = len;
+       }
+
+       /*
+        * Save any partial record at the end of the buffer for next time.
+        */
+       if (error == 0 && len > 0 && len < sizeof(*np)) {
+               if (np != &lp->disc_buf)
+                       memcpy(&lp->disc_buf, np, len);
+               lp->disc_buf_len = (unsigned char) len;
+       } else {
+               lp->disc_buf_len = 0;
+       }
+       return error;
+}
+
+/*
+ * Handle retry of memory allocation for remote ports.
+ */
+static void fc_disc_timeout(struct work_struct *work)
+{
+       struct fc_lport *lp;
+
+       lp = container_of(work, struct fc_lport, disc_work.work);
+
+       if (lp->disc_pending)
+               fc_disc_gpn_ft_req(lp);
+       else
+               lp->tt.disc_start(lp);
+}
+
+/**
+ * fc_disc_gpn_ft_resp - Handle a response frame from Get Port Names (GPN_FT)
+ * @sp: Current sequence of GPN_FT exchange
+ * @fp: response frame
+ * @lp_arg: Fibre Channel host port instance
+ *
+ * The response may be in multiple frames
+ */
+static void fc_disc_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp,
+                             void *lp_arg)
+{
+       struct fc_lport *lp = lp_arg;
+       struct fc_ct_hdr *cp;
+       struct fc_frame_header *fh;
+       unsigned int seq_cnt;
+       void *buf = NULL;
+       unsigned int len;
+       int error;
+
+       if (IS_ERR(fp)) {
+               fc_disc_error(lp, fp);
+               return;
+       }
+
+       WARN_ON(!fc_frame_is_linear(fp));       /* buffer must be contiguous */
+       fh = fc_frame_header_get(fp);
+       len = fr_len(fp) - sizeof(*fh);
+       seq_cnt = ntohs(fh->fh_seq_cnt);
+       if (fr_sof(fp) == FC_SOF_I3 && seq_cnt == 0 &&
+           lp->disc_seq_count == 0) {
+               cp = fc_frame_payload_get(fp, sizeof(*cp));
+               if (cp == NULL) {
+                       FC_DBG("GPN_FT response too short, len %d\n",
+                              fr_len(fp));
+               } else if (ntohs(cp->ct_cmd) == FC_FS_ACC) {
+
+                       /*
+                        * Accepted.  Parse response.
+                        */
+                       buf = cp + 1;
+                       len -= sizeof(*cp);
+               } else if (ntohs(cp->ct_cmd) == FC_FS_RJT) {
+                       FC_DBG("GPN_FT rejected reason %x exp %x "
+                              "(check zoning)\n", cp->ct_reason,
+                              cp->ct_explan);
+                       fc_disc_done(lp);
+               } else {
+                       FC_DBG("GPN_FT unexpected response code %x\n",
+                              ntohs(cp->ct_cmd));
+               }
+       } else if (fr_sof(fp) == FC_SOF_N3 &&
+                  seq_cnt == lp->disc_seq_count) {
+               buf = fh + 1;
+       } else {
+               FC_DBG("GPN_FT unexpected frame - out of sequence? "
+                      "seq_cnt %x expected %x sof %x eof %x\n",
+                      seq_cnt, lp->disc_seq_count, fr_sof(fp), fr_eof(fp));
+       }
+       if (buf) {
+               error = fc_disc_gpn_ft_parse(lp, buf, len);
+               if (error)
+                       fc_disc_retry(lp);
+               else
+                       lp->disc_seq_count++;
+       }
+       fc_frame_free(fp);
+}
+
+/*
+ * Discover the directory information for a single target.
+ * This could be from an RSCN that reported a change for the target.
+ */
+static void fc_disc_single(struct fc_lport *lp, struct fc_disc_port *dp)
+{
+       struct fc_rport *rport;
+       struct fc_rport *rp;
+       struct fc_rport_libfc_priv *rpp;
+
+       if (dp->ids.port_id == lp->fid)
+               goto out;
+
+       rport = lp->tt.rport_lookup(lp, dp->ids.port_id);
+       if (rport) {
+               fc_disc_del_target(lp, rport);
+               put_device(&rport->dev); /* hold from lookup */
+       }
+
+       rp = fc_rport_dummy_create(dp);
+       if (rp) {
+               rpp = rp->dd_data;
+               kfree(dp);
+               lp->tt.rport_login(rp);
+       }
+       return;
+out:
+       kfree(dp);
+}
+
+int fc_disc_init(struct fc_lport *lp)
+{
+       INIT_DELAYED_WORK(&lp->disc_work, fc_disc_timeout);
+
+       if (!lp->tt.disc_start)
+               lp->tt.disc_start = fc_disc_start;
+
+       if (!lp->tt.disc_recv_req)
+               lp->tt.disc_recv_req = fc_disc_recv_req;
+
+       return 0;
+}
+EXPORT_SYMBOL(fc_disc_init);
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index 11a03bd..ed74d95 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -1,5 +1,7 @@
 /*
  * Copyright(c) 2007 Intel Corporation. All rights reserved.
+ * Copyright(c) 2008 Red Hat, Inc.  All rights reserved.
+ * Copyright(c) 2008 Mike Christie
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -73,6 +75,9 @@ struct fc_exch;
  *     esb_stat, f_ctl, seq.ssb_stat, seq.f_ctl.
  *     seq_id
  *     sequence allocation
+ *
+ * If the em_lock and ex_lock must be taken at the same time, the
+ * em_lock must be taken before the ex_lock.
  */
 struct fc_exch {
        struct fc_exch_mgr *em;         /* exchange manager */
@@ -95,13 +100,16 @@ struct fc_exch {
        u8              fh_type;        /* frame type */
        enum fc_class   class;          /* class of service */
        struct fc_seq   seq;            /* single sequence */
-       struct fc_exch  *aborted_ep;    /* ref to ep rrq is cleaning up */
-
        /*
         * Handler for responses to this current exchange.
         */
        void            (*resp)(struct fc_seq *, struct fc_frame *, void *);
-       void            *resp_arg;      /* 3rd arg for exchange resp handler */
+       void            (*destructor)(struct fc_seq *, void *);
+       /*
+        * arg is passed as void pointer to exchange
+        * resp and destructor handlers
+        */
+       void            *arg;
 };
 
 /*
@@ -297,6 +305,8 @@ static void fc_exch_release(struct fc_exch *ep)
 
        if (atomic_dec_and_test(&ep->ex_refcnt)) {
                mp = ep->em;
+               if (ep->destructor)
+                       ep->destructor(&ep->seq, ep->arg);
                if (ep->lp->tt.exch_put)
                        ep->lp->tt.exch_put(ep->lp, mp, ep->xid);
                WARN_ON(!ep->esb_stat & ESB_ST_COMPLETE);
@@ -324,7 +334,6 @@ static int fc_exch_done_locked(struct fc_exch *ep)
                ep->state |= FC_EX_DONE;
                if (del_timer(&ep->ex_timer))
                        atomic_dec(&ep->ex_refcnt); /* drop hold for timer */
-               atomic_dec(&ep->ex_refcnt); /* drop hold from alloc */
                rc = 0;
        }
        return rc;
@@ -341,6 +350,7 @@ static void fc_exch_mgr_delete_ep(struct fc_exch *ep)
        mp->exches[ep->xid - mp->min_xid] = NULL;
        list_del(&ep->ex_list);
        spin_unlock_bh(&mp->em_lock);
+       fc_exch_release(ep);    /* drop hold for exch in mp */
 }
 
 /*
@@ -441,13 +451,13 @@ static void fc_exch_timeout(unsigned long ep_arg)
        e_stat = ep->esb_stat;
        if (e_stat & ESB_ST_COMPLETE) {
                ep->esb_stat = e_stat & ~ESB_ST_REC_QUAL;
-               spin_unlock_bh(&ep->ex_lock);
                if (e_stat & ESB_ST_REC_QUAL)
                        fc_exch_rrq(ep);
+               spin_unlock_bh(&ep->ex_lock);
                goto done;
        } else {
                resp = ep->resp;
-               arg = ep->resp_arg;
+               arg = ep->arg;
                ep->resp = NULL;
                if (e_stat & ESB_ST_ABNORMAL)
                        rc = fc_exch_done_locked(ep);
@@ -492,6 +502,7 @@ static struct fc_seq *fc_seq_alloc(struct fc_exch *ep, u8 seq_id)
  *
  * if xid is supplied zero then assign next free exchange ID
  * from exchange manager, otherwise use supplied xid.
+ * Returns with exch lock held.
  */
 struct fc_exch *fc_exch_alloc(struct fc_exch_mgr *mp, u16 xid)
 {
@@ -540,16 +551,24 @@ struct fc_exch *fc_exch_alloc(struct fc_exch_mgr *mp, u16 xid)
                        xid = fc_exch_next_xid(mp, xid);
                }
 
-               if (likely(mp->exches[xid - min_xid] == NULL)) {
-                       mp->last_xid = xid;
-               } else {
-                       spin_unlock_bh(&mp->em_lock);
-                       atomic_inc(&mp->stats.no_free_exch_xid);
-                       mempool_free(ep, mp->ep_pool);
-                       goto out;
-               }
+               if (unlikely(mp->exches[xid - min_xid] != NULL))
+                       goto err;
+               mp->last_xid = xid;
        }
 
+       /*  lport lock ? */
+       if (mp->lp->state == LPORT_ST_RESET)
+               goto err;       /*  don't add new ep during local port reset  */
+
+       fc_exch_hold(ep);       /* hold for exch in mp */
+       spin_lock_init(&ep->ex_lock);
+       /*
+        * Hold exch lock for caller to prevent fc_exch_reset()
+        * from releasing exch  while fc_exch_alloc() caller is
+        * still working on exch.
+        */
+       spin_lock_bh(&ep->ex_lock);
+
        mp->exches[xid - min_xid] = ep;
        list_add_tail(&ep->ex_list, &mp->ex_list);
        fc_seq_alloc(ep, ep->seq_id++);
@@ -565,13 +584,14 @@ struct fc_exch *fc_exch_alloc(struct fc_exch_mgr *mp, u16 xid)
        ep->f_ctl = FC_FC_FIRST_SEQ;    /* next seq is first seq */
        ep->rxid = FC_XID_UNKNOWN;
        ep->class = mp->class;
-
-       spin_lock_init(&ep->ex_lock);
        setup_timer(&ep->ex_timer, fc_exch_timeout, (unsigned long)ep);
-
-       fc_exch_hold(ep);       /* hold for caller */
 out:
        return ep;
+err:
+       spin_unlock_bh(&mp->em_lock);
+       atomic_inc(&mp->stats.no_free_exch_xid);
+       mempool_free(ep, mp->ep_pool);
+       return NULL;
 }
 EXPORT_SYMBOL(fc_exch_alloc);
 
@@ -654,6 +674,8 @@ static struct fc_exch *fc_exch_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
                        WARN_ON(rxid != FC_XID_UNKNOWN);
                        fh->fh_rx_id = htons(ep->rxid);
                }
+               fc_exch_hold(ep);       /* hold for caller */
+               spin_unlock_bh(&ep->ex_lock);   /* lock from exch_get */
        }
        return ep;
 }
@@ -667,7 +689,7 @@ static enum fc_pf_rjt_reason
 fc_seq_lookup_recip(struct fc_exch_mgr *mp, struct fc_frame *fp)
 {
        struct fc_frame_header *fh = fc_frame_header_get(fp);
-       struct fc_exch *ep = NULL, *new_ep = NULL;
+       struct fc_exch *ep = NULL;
        struct fc_seq *sp = NULL;
        enum fc_pf_rjt_reason reject = FC_RJT_NONE;
        u32 f_ctl;
@@ -717,12 +739,11 @@ fc_seq_lookup_recip(struct fc_exch_mgr *mp, struct fc_frame *fp)
                                reject = FC_RJT_RX_ID;
                                goto rel;
                        }
-                       new_ep = ep = fc_exch_resp(mp, fp);
+                       ep = fc_exch_resp(mp, fp);
                        if (!ep) {
                                reject = FC_RJT_EXCH_EST;       /* XXX */
                                goto out;
                        }
-                       fc_exch_hold(ep);       /* Additional hold for caller */
                        xid = ep->xid;  /* get our XID */
                } else if (!ep) {
                        atomic_inc(&mp->stats.xid_not_found);
@@ -760,9 +781,8 @@ fc_seq_lookup_recip(struct fc_exch_mgr *mp, struct fc_frame *fp)
 out:
        return reject;
 rel:
-       fc_exch_release(ep);
-       if (new_ep)
-               fc_exch_release(new_ep);
+       fc_exch_done(&ep->seq);
+       fc_exch_release(ep);    /* hold from fc_exch_find/fc_exch_resp */
        return reject;
 }
 
@@ -1160,7 +1180,7 @@ static void fc_exch_recv_req(struct fc_lport *lp, struct fc_exch_mgr *mp,
                 * first.
                 */
                if (ep->resp)
-                       ep->resp(sp, fp, ep->resp_arg);
+                       ep->resp(sp, fp, ep->arg);
                else
                        lp->tt.lport_recv(lp, sp, fp);
                fc_exch_release(ep);    /* release from lookup */
@@ -1222,7 +1242,7 @@ static void fc_exch_recv_seq_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
        if (fc_sof_needs_ack(sof))
                fc_seq_send_ack(sp, fp);
        resp = ep->resp;
-       ex_resp_arg = ep->resp_arg;
+       ex_resp_arg = ep->arg;
 
        if (fh->fh_type != FC_TYPE_FCP && fr_eof(fp) == FC_EOF_T &&
            (f_ctl & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
@@ -1332,7 +1352,7 @@ static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
        }
 
        resp = ep->resp;
-       ex_resp_arg = ep->resp_arg;
+       ex_resp_arg = ep->arg;
 
        /* do we need to do some other checks here. Can we reuse more of
         * fc_exch_recv_seq_resp
@@ -1341,7 +1361,7 @@ static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
        /*
         * do we want to check END_SEQ as well as LAST_SEQ here?
         */
-       if (fh->fh_type != FC_TYPE_FCP &&
+       if (ep->fh_type != FC_TYPE_FCP &&
            ntoh24(fh->fh_f_ctl) & FC_FC_LAST_SEQ)
                rc = fc_exch_done_locked(ep);
        spin_unlock_bh(&ep->ex_lock);
@@ -1485,11 +1505,9 @@ static void fc_exch_reset(struct fc_exch *ep)
        if (ep->esb_stat & ESB_ST_REC_QUAL)
                atomic_dec(&ep->ex_refcnt);     /* drop hold for rec_qual */
        ep->esb_stat &= ~ESB_ST_REC_QUAL;
-       arg = ep->resp_arg;
+       arg = ep->arg;
        sp = &ep->seq;
-
-       if (ep->fh_type != FC_TYPE_FCP)
-               rc = fc_exch_done_locked(ep);
+       rc = fc_exch_done_locked(ep);
        spin_unlock_bh(&ep->ex_lock);
        if (!rc)
                fc_exch_mgr_delete_ep(ep);
@@ -1640,9 +1658,7 @@ reject:
  */
 static void fc_exch_rrq_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
 {
-       struct fc_exch *ep = fc_seq_exch(sp);
-       struct fc_exch *aborted_ep;
-
+       struct fc_exch *aborted_ep = arg;
        unsigned int op;
 
        if (IS_ERR(fp)) {
@@ -1669,16 +1685,9 @@ static void fc_exch_rrq_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
        }
 
 cleanup:
-       spin_lock_bh(&ep->ex_lock);
-       aborted_ep = ep->aborted_ep;
-       ep->aborted_ep = NULL;
-       spin_unlock_bh(&ep->ex_lock);
-
-       if (aborted_ep) {
-               fc_exch_done(&aborted_ep->seq);
-               /* drop hold for rec qual */
-               fc_exch_release(aborted_ep);
-       }
+       fc_exch_done(&aborted_ep->seq);
+       /* drop hold for rec qual */
+       fc_exch_release(aborted_ep);
 }
 
 /*
@@ -1692,7 +1701,6 @@ static void fc_exch_rrq(struct fc_exch *ep)
        struct fc_els_rrq *rrq;
        struct fc_frame *fp;
        struct fc_seq *rrq_sp;
-       struct fc_exch *rrq_ep;
        u32 did;
 
        lp = ep->lp;
@@ -1711,18 +1719,14 @@ static void fc_exch_rrq(struct fc_exch *ep)
        did = ep->did;
        if (ep->esb_stat & ESB_ST_RESP)
                did = ep->sid;
-       rrq_sp = fc_exch_seq_send(lp, fp, fc_exch_rrq_resp, ep, lp->e_d_tov,
-                                 lp->fid, did, FC_FC_SEQ_INIT | FC_FC_END_SEQ);
+       rrq_sp = fc_exch_seq_send(lp, fp, fc_exch_rrq_resp, NULL, ep,
+                                 lp->e_d_tov, lp->fid, did,
+                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ);
        if (!rrq_sp) {
-               spin_lock_bh(&ep->ex_lock);
                ep->esb_stat |= ESB_ST_REC_QUAL;
                fc_exch_timer_set_locked(ep, ep->r_a_tov);
-               spin_unlock_bh(&ep->ex_lock);
                return;
        }
-
-       rrq_ep = fc_seq_exch(rrq_sp);
-       rrq_ep->aborted_ep = ep;
 }
 
 
@@ -1860,13 +1864,15 @@ struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
                                void (*resp)(struct fc_seq *,
                                             struct fc_frame *fp,
                                             void *arg),
-                               void *resp_arg, u32 timer_msec,
+                               void (*destructor)(struct fc_seq *, void *),
+                               void *arg, u32 timer_msec,
                                u32 sid, u32 did, u32 f_ctl)
 {
        struct fc_exch *ep;
        struct fc_seq *sp = NULL;
        struct fc_frame_header *fh;
        u16 fill;
+       int rc = 1;
 
        ep = lp->tt.exch_get(lp, fp);
        if (!ep) {
@@ -1876,7 +1882,8 @@ struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
        ep->esb_stat |= ESB_ST_SEQ_INIT;
        fc_exch_set_addr(ep, sid, did);
        ep->resp = resp;
-       ep->resp_arg = resp_arg;
+       ep->destructor = destructor;
+       ep->arg = arg;
        ep->r_a_tov = FC_DEF_R_A_TOV;
        ep->lp = lp;
        sp = &ep->seq;
@@ -1912,7 +1919,6 @@ struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
        if (unlikely(lp->tt.frame_send(lp, fp)))
                goto err;
 
-       spin_lock_bh(&ep->ex_lock);
        if (timer_msec)
                fc_exch_timer_set_locked(ep, timer_msec);
        sp->f_ctl = f_ctl;      /* save for possible abort */
@@ -1924,7 +1930,10 @@ struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
        spin_unlock_bh(&ep->ex_lock);
        return sp;
 err:
-       fc_exch_done(sp);
+       rc = fc_exch_done_locked(ep);
+       spin_unlock_bh(&ep->ex_lock);
+       if (!rc)
+               fc_exch_mgr_delete_ep(ep);
        return NULL;
 }
 EXPORT_SYMBOL(fc_exch_seq_send);
@@ -1938,6 +1947,7 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
        struct fc_frame_header *fh = fc_frame_header_get(fp);
        u32 f_ctl;
 
+       /* lport lock ? */
        if (!lp || !mp || (lp->state == LPORT_ST_NONE)) {
                FC_DBG("fc_lport or EM is not allocated and configured");
                fc_frame_free(fp);
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 97da731..2566eed 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -38,6 +38,10 @@
 
 #include <scsi/libfc/libfc.h>
 
+MODULE_AUTHOR("Open-FCoE.org");
+MODULE_DESCRIPTION("libfc");
+MODULE_LICENSE("GPL");
+
 int fc_fcp_debug;
 static struct kmem_cache *scsi_pkt_cachep;
 
@@ -206,6 +210,7 @@ static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lp, gfp_t gfp)
                atomic_set(&sp->ref_cnt, 1);
                init_timer(&sp->timer);
                INIT_LIST_HEAD(&sp->list);
+               spin_lock_init(&sp->scsi_pkt_lock);
        }
        return sp;
 }
@@ -233,6 +238,22 @@ static void fc_fcp_pkt_hold(struct fc_fcp_pkt *sp)
 }
 
 /**
+ * fc_fcp_pkt_destory - release hold on scsi_pkt packet
+ *
+ * @sp:                exchange sequence
+ * @fsp:       fcp packet struct
+ *
+ * Release hold on scsi_pkt packet set to keep scsi_pkt
+ * till EM layer exch resource is not freed.
+ * Context     : called from from EM layer.
+ *               no locking required
+ */
+static void fc_fcp_pkt_destroy(struct fc_seq *sp, void *arg)
+{
+       fc_fcp_pkt_release(arg);
+}
+
+/**
  * fc_fcp_lock_pkt - lock a packet and get a ref to it.
  * @fsp:       fcp packet
  *
@@ -604,13 +625,31 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *sp,
        return 0;
 }
 
-static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame_header *fh)
+static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
-       /*
-        * we will let the command timeout and scsi-ml escalate if
-        * the abort was rejected
-        */
-       if (fh->fh_r_ctl == FC_RCTL_BA_ACC) {
+       int ba_done = 1;
+       struct fc_ba_rjt *brp;
+       struct fc_frame_header *fh;
+
+       fh = fc_frame_header_get(fp);
+       switch (fh->fh_r_ctl) {
+       case FC_RCTL_BA_ACC:
+               break;
+       case FC_RCTL_BA_RJT:
+               brp = fc_frame_payload_get(fp, sizeof(*brp));
+               if (brp && brp->br_reason == FC_BA_RJT_LOG_ERR)
+                       break;
+               /* fall thru */
+       default:
+               /*
+                * we will let the command timeout
+                * and scsi-ml recover in this case,
+                * therefore cleared the ba_done flag.
+                */
+               ba_done = 0;
+       }
+
+       if (ba_done) {
                fsp->state |= FC_SRB_ABORTED;
                fsp->state &= ~FC_SRB_ABORT_PENDING;
 
@@ -666,7 +705,7 @@ static void fc_fcp_recv(struct fc_seq *sp, struct fc_frame *fp, void *arg)
        struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
        struct fc_lport *lp;
        struct fc_frame_header *fh;
-       struct fc_data_desc *dd;
+       struct fcp_txrdy *dd;
        u8 r_ctl;
        int rc = 0;
 
@@ -684,7 +723,7 @@ static void fc_fcp_recv(struct fc_seq *sp, struct fc_frame *fp, void *arg)
        fsp->last_pkt_time = jiffies;
 
        if (fh->fh_type == FC_TYPE_BLS) {
-               fc_fcp_abts_resp(fsp, fh);
+               fc_fcp_abts_resp(fsp, fp);
                goto unlock;
        }
 
@@ -701,8 +740,8 @@ static void fc_fcp_recv(struct fc_seq *sp, struct fc_frame *fp, void *arg)
                WARN_ON(!dd);
 
                rc = fc_fcp_send_data(fsp, sp,
-                                     (size_t) ntohl(dd->dd_offset),
-                                     (size_t) ntohl(dd->dd_len), fp,
+                                     (size_t) ntohl(dd->ft_data_ro),
+                                     (size_t) ntohl(dd->ft_burst_len), fp,
                                      lp->capabilities & TRANS_C_SG);
                if (!rc)
                        lp->tt.seq_set_rec_data(sp, fsp->xfer_len);
@@ -1025,6 +1064,7 @@ static int fc_fcp_send_cmd(struct fc_fcp_pkt *fsp)
        rp = rport->dd_data;
        sp = lp->tt.exch_seq_send(lp, fp,
                                  fc_fcp_recv,
+                                 fc_fcp_pkt_destroy,
                                  fsp, 0,
                                  rp->local_port->fid,
                                  rport->port_id,
@@ -1034,7 +1074,9 @@ static int fc_fcp_send_cmd(struct fc_fcp_pkt *fsp)
                rc = -1;
                goto unlock;
        }
+       fsp->last_pkt_time = jiffies;
        fsp->seq_ptr = sp;
+       fc_fcp_pkt_hold(fsp);   /* hold for fc_fcp_pkt_destroy */
 
        setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
        fc_fcp_timer_set(fsp,
@@ -1131,6 +1173,7 @@ static void fc_lun_reset_send(unsigned long data)
        rp = rport->dd_data;
        sp = lp->tt.exch_seq_send(lp, fp,
                                  fc_tm_done,
+                                 fc_fcp_pkt_destroy,
                                  fsp, 0,
                                  rp->local_port->fid,
                                  rport->port_id,
@@ -1138,6 +1181,7 @@ static void fc_lun_reset_send(unsigned long data)
 
        if (sp) {
                fsp->seq_ptr = sp;
+               fc_fcp_pkt_hold(fsp);   /* hold for fc_fcp_pkt_destroy */
                goto unlock;
        }
        /*
@@ -1183,12 +1227,6 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
 
        spin_lock_bh(&fsp->scsi_pkt_lock);
        if (fsp->seq_ptr) {
-               /* TODO:
-                * if the exch resp function is running and trying to grab
-                * the scsi_pkt_lock, this could free the exch from under
-                * it and it could allow the fsp to be freed from under
-                * fc_tm_done.
-                */
                lp->tt.exch_done(fsp->seq_ptr);
                fsp->seq_ptr = NULL;
        }
@@ -1231,9 +1269,6 @@ static void fc_tm_done(struct fc_seq *sp, struct fc_frame *fp, void *arg)
 
        /*
         * raced with eh timeout handler.
-        *
-        * TODO: If this happens we could be freeing the fsp right now and
-        * would oops. Next patches will fix this race.
         */
        if ((fsp->state & FC_SRB_COMPL) || !fsp->seq_ptr ||
            !fsp->wait_for_comp) {
@@ -1288,14 +1323,13 @@ static void fc_fcp_timeout(unsigned long data)
 
        if (rp->flags & FC_RP_FLAGS_REC_SUPPORTED)
                fc_fcp_rec(fsp);
-       /* TODO: change this to time_before/after */
-       else if (jiffies - fsp->last_pkt_time < FC_SCSI_ER_TIMEOUT / 2)
+       else if (time_after_eq(fsp->last_pkt_time + (FC_SCSI_ER_TIMEOUT / 2),
+                              jiffies))
                fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
        else if (fsp->state & FC_SRB_RCV_STATUS)
                fc_fcp_complete(fsp);
        else
                fc_timeout_error(fsp);
-
        fsp->state &= ~FC_SRB_FCP_PROCESSING_TMO;
 unlock:
        fc_fcp_unlock_pkt(fsp);
@@ -1340,7 +1374,7 @@ static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
        fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
        fc_frame_set_offset(fp, 0);
        sp = lp->tt.exch_seq_send(lp, fp,
-                                 fc_fcp_rec_resp,
+                                 fc_fcp_rec_resp, NULL,
                                  fsp, jiffies_to_msecs(FC_SCSI_REC_TOV),
                                  rp->local_port->fid,
                                  rport->port_id,
@@ -1402,9 +1436,14 @@ static void fc_fcp_rec_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
                        if (fc_fcp_debug)
                                FC_DBG("device does not support REC\n");
                        rp = fsp->rport->dd_data;
+                       /*
+                        * if we do not spport RECs or got some bogus
+                        * reason then resetup timer so we check for
+                        * making progress.
+                        */
                        rp->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
-                       /* fall through */
-
+                       fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
+                       break;
                case ELS_RJT_LOGIC:
                case ELS_RJT_UNAB:
                        /*
@@ -1595,7 +1634,7 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
        fc_frame_setup(fp, FC_RCTL_ELS4_REQ, FC_TYPE_FCP);
        fc_frame_set_offset(fp, 0);
        sp = lp->tt.exch_seq_send(lp, fp,
-                                 fc_fcp_srr_resp,
+                                 fc_fcp_srr_resp, NULL,
                                  fsp, jiffies_to_msecs(FC_SCSI_REC_TOV),
                                  rp->local_port->fid,
                                  rport->port_id,
@@ -2048,7 +2087,7 @@ int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
                shost_printk(KERN_INFO, shost, "Host reset succeeded.\n");
                return SUCCESS;
        } else {
-               shost_printk(KERN_INFO, shost, "Host reset succeeded failed."
+               shost_printk(KERN_INFO, shost, "Host reset failed. "
                            "lport not ready.\n");
                return FAILED;
        }
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index b390a32..b1854b9 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -36,76 +36,130 @@
 
 static int fc_lport_debug;
 
+static void fc_lport_error(struct fc_lport *, struct fc_frame *);
+
+static void fc_lport_enter_reset(struct fc_lport *);
 static void fc_lport_enter_flogi(struct fc_lport *);
+static void fc_lport_enter_dns(struct fc_lport *);
+static void fc_lport_enter_rpn_id(struct fc_lport *);
+static void fc_lport_enter_rft_id(struct fc_lport *);
+static void fc_lport_enter_scr(struct fc_lport *);
+static void fc_lport_enter_ready(struct fc_lport *);
 static void fc_lport_enter_logo(struct fc_lport *);
 
 static const char *fc_lport_state_names[] = {
        [LPORT_ST_NONE] =     "none",
        [LPORT_ST_FLOGI] =    "FLOGI",
        [LPORT_ST_DNS] =      "dNS",
-       [LPORT_ST_REG_PN] =   "REG_PN",
-       [LPORT_ST_REG_FT] =   "REG_FT",
+       [LPORT_ST_RPN_ID] =   "RPN_ID",
+       [LPORT_ST_RFT_ID] =   "RFT_ID",
        [LPORT_ST_SCR] =      "SCR",
-       [LPORT_ST_READY] =    "ready",
-       [LPORT_ST_DNS_STOP] = "stop",
+       [LPORT_ST_READY] =    "Ready",
        [LPORT_ST_LOGO] =     "LOGO",
        [LPORT_ST_RESET] =    "reset",
 };
 
-static int fc_frame_drop(struct fc_lport *lp, struct fc_frame *fp)
+static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
 {
        fc_frame_free(fp);
        return 0;
 }
 
-static const char *fc_lport_state(struct fc_lport *lp)
+/**
+ * fc_lport_rport_event - Event handler for rport events
+ * @lport: The lport which is receiving the event
+ * @port_id: The FID of the rport which the event has occured on
+ * @event: The event that occured
+ *
+ * Locking Note: The rport lock should not be held when calling
+ *               this function.
+ */
+static void fc_lport_rport_event(struct fc_lport *lport, u32 port_id,
+                                enum fc_lport_event event)
+{
+       struct fc_rport *rport = lport->tt.rport_lookup(lport, port_id);
+
+       if (fc_lport_debug)
+               FC_DBG("Received a %d event for port (%6x)\n", event, port_id);
+
+       if (port_id == FC_FID_DIR_SERV) {
+               mutex_lock(&lport->lp_mutex);
+               switch (event) {
+               case LPORT_EV_RPORT_CREATED:
+                       if (rport) {
+                               lport->dns_rp = rport;
+                               fc_lport_enter_rpn_id(lport);
+                       }
+                       break;
+               case LPORT_EV_RPORT_LOGO:
+               case LPORT_EV_RPORT_FAILED:
+                       lport->dns_rp = NULL;
+                       fc_lport_enter_dns(lport);
+                       break;
+               case LPORT_EV_RPORT_NONE:
+                       break;
+               }
+               mutex_unlock(&lport->lp_mutex);
+       }
+}
+
+/**
+ * fc_lport_state - Return a string which represents the lport's state
+ * @lport: The lport whose state is to converted to a string
+ */
+static const char *fc_lport_state(struct fc_lport *lport)
 {
        const char *cp;
 
-       cp = fc_lport_state_names[lp->state];
+       cp = fc_lport_state_names[lport->state];
        if (!cp)
                cp = "unknown";
        return cp;
 }
 
-static void fc_lport_ptp_setup(struct fc_lport *lp,
-                              u32 remote_fid, u64 remote_wwpn,
-                              u64 remote_wwnn)
+/**
+ * fc_lport_ptp_clear - Delete the ptp rport
+ * @lport: The lport whose ptp rport should be removed
+ */
+static void fc_lport_ptp_clear(struct fc_lport *lport)
 {
-       struct fc_rport *rport;
-       struct fc_rport_identifiers ids = {
-               .port_id = remote_fid,
-               .port_name = remote_wwpn,
-               .node_name = remote_wwnn,
-       };
-
-       /*
-        * if we have to create a rport the fc class can sleep so we must
-        * drop the lock here
-        */
-       fc_lport_unlock(lp);
-       rport = lp->tt.rport_lookup(lp, ids.port_id); /* lookup and hold */
-       if (rport == NULL)
-               rport = lp->tt.rport_create(lp, &ids); /* create and hold */
-       fc_lport_lock(lp);
-       if (rport) {
-               if (lp->ptp_rp)
-                       fc_remote_port_delete(lp->ptp_rp);
-               lp->ptp_rp = rport;
-               fc_lport_state_enter(lp, LPORT_ST_READY);
+       if (lport->ptp_rp) {
+               fc_remote_port_delete(lport->ptp_rp);
+               lport->ptp_rp = NULL;
        }
 }
 
-static void fc_lport_ptp_clear(struct fc_lport *lp)
+/**
+ * fc_lport_ptp_setup - Create an rport for point-to-point mode
+ * @lport: The lport to attach the ptp rport to
+ * @fid: The FID of the ptp rport
+ * @remote_wwpn: The WWPN of the ptp rport
+ * @remote_wwnn: The WWNN of the ptp rport
+ */
+static void fc_lport_ptp_setup(struct fc_lport *lport,
+                              u32 remote_fid, u64 remote_wwpn,
+                              u64 remote_wwnn)
 {
-       if (lp->ptp_rp) {
-               fc_remote_port_delete(lp->ptp_rp);
-               lp->ptp_rp = NULL;
-       }
+       struct fc_disc_port dp;
+
+       dp.lp = lport;
+       dp.ids.port_id = remote_fid;
+       dp.ids.port_name = remote_wwpn;
+       dp.ids.node_name = remote_wwnn;
+       dp.ids.roles = FC_RPORT_ROLE_UNKNOWN;
+
+       fc_lport_ptp_clear(lport);
+
+       lport->ptp_rp = fc_rport_dummy_create(&dp);
+
+       lport->tt.rport_login(lport->ptp_rp);
+
+       fc_lport_enter_ready(lport);
 }
 
-/*
- * Routines to support struct fc_function_template
+/**
+ * fc_get_host_port_state - supports fc_function_template
+ * @shost: The host whose port state should be returned
  */
 void fc_get_host_port_state(struct Scsi_Host *shost)
 {
@@ -118,82 +172,130 @@ void fc_get_host_port_state(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_port_state);
 
+void fc_get_host_speed(struct Scsi_Host *shost)
+{
+       struct fc_lport *lport = shost_priv(shost);
+
+       fc_host_speed(shost) = lport->link_speed;
+}
+EXPORT_SYMBOL(fc_get_host_speed);
+
+struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
+{
+       int i;
+       struct fc_host_statistics *fcoe_stats;
+       struct fc_lport *lp = shost_priv(shost);
+       struct timespec v0, v1;
+
+       fcoe_stats = &lp->host_stats;
+       memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
+
+       jiffies_to_timespec(jiffies, &v0);
+       jiffies_to_timespec(lp->boot_time, &v1);
+       fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
+
+       for_each_online_cpu(i) {
+               struct fcoe_dev_stats *stats = lp->dev_stats[i];
+               if (stats == NULL)
+                       continue;
+               fcoe_stats->tx_frames += stats->TxFrames;
+               fcoe_stats->tx_words += stats->TxWords;
+               fcoe_stats->rx_frames += stats->RxFrames;
+               fcoe_stats->rx_words += stats->RxWords;
+               fcoe_stats->error_frames += stats->ErrorFrames;
+               fcoe_stats->invalid_crc_count += stats->InvalidCRCCount;
+               fcoe_stats->fcp_input_requests += stats->InputRequests;
+               fcoe_stats->fcp_output_requests += stats->OutputRequests;
+               fcoe_stats->fcp_control_requests += stats->ControlRequests;
+               fcoe_stats->fcp_input_megabytes += stats->InputMegabytes;
+               fcoe_stats->fcp_output_megabytes += stats->OutputMegabytes;
+               fcoe_stats->link_failure_count += stats->LinkFailureCount;
+       }
+       fcoe_stats->lip_count = -1;
+       fcoe_stats->nos_count = -1;
+       fcoe_stats->loss_of_sync_count = -1;
+       fcoe_stats->loss_of_signal_count = -1;
+       fcoe_stats->prim_seq_protocol_err_count = -1;
+       fcoe_stats->dumped_frames = -1;
+       return fcoe_stats;
+}
+EXPORT_SYMBOL(fc_get_host_stats);
+
 /*
  * Fill in FLOGI command for request.
  */
 static void
-fc_lport_flogi_fill(struct fc_lport *lp,
-                   struct fc_els_flogi *flogi, unsigned int op)
+fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
+                   unsigned int op)
 {
        struct fc_els_csp *sp;
        struct fc_els_cssp *cp;
 
        memset(flogi, 0, sizeof(*flogi));
        flogi->fl_cmd = (u8) op;
-       put_unaligned_be64(lp->wwpn, &flogi->fl_wwpn);
-       put_unaligned_be64(lp->wwnn, &flogi->fl_wwnn);
+       put_unaligned_be64(lport->wwpn, &flogi->fl_wwpn);
+       put_unaligned_be64(lport->wwnn, &flogi->fl_wwnn);
        sp = &flogi->fl_csp;
        sp->sp_hi_ver = 0x20;
        sp->sp_lo_ver = 0x20;
        sp->sp_bb_cred = htons(10);     /* this gets set by gateway */
-       sp->sp_bb_data = htons((u16) lp->mfs);
+       sp->sp_bb_data = htons((u16) lport->mfs);
        cp = &flogi->fl_cssp[3 - 1];    /* class 3 parameters */
        cp->cp_class = htons(FC_CPC_VALID | FC_CPC_SEQ);
        if (op != ELS_FLOGI) {
                sp->sp_features = htons(FC_SP_FT_CIRO);
                sp->sp_tot_seq = htons(255);    /* seq. we accept */
                sp->sp_rel_off = htons(0x1f);
-               sp->sp_e_d_tov = htonl(lp->e_d_tov);
+               sp->sp_e_d_tov = htonl(lport->e_d_tov);
 
-               cp->cp_rdfs = htons((u16) lp->mfs);
+               cp->cp_rdfs = htons((u16) lport->mfs);
                cp->cp_con_seq = htons(255);
                cp->cp_open_seq = 1;
        }
 }
 
 /*
- * Set the fid. This indicates that we have a new connection to the
- * fabric so we should reset our list of fc_rports. Passing a fid of
- * 0 will also reset the rport list regardless of the previous fid.
- */
-static void fc_lport_set_fid(struct fc_lport *lp, u32 fid)
-{
-       if (fid != 0 && lp->fid == fid)
-               return;
-
-       if (fc_lport_debug)
-               FC_DBG("changing local port fid from %x to %x\n",
-                      lp->fid, fid);
-       lp->fid = fid;
-       lp->tt.rport_reset_list(lp);
-}
-
-/*
  * Add a supported FC-4 type.
  */
-static void fc_lport_add_fc4_type(struct fc_lport *lp, enum fc_fh_type type)
+static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 {
        __be32 *mp;
 
-       mp = &lp->fcts.ff_type_map[type / FC_NS_BPW];
+       mp = &lport->fcts.ff_type_map[type / FC_NS_BPW];
        *mp = htonl(ntohl(*mp) | 1UL << (type % FC_NS_BPW));
 }
 
-/*
- * Handle received RLIR - registered link incident report.
+/**
+ * fc_lport_recv_rlir_req - Handle received Registered Link Incident Report.
+ * @lport: Fibre Channel local port recieving the RLIR
+ * @sp: current sequence in the RLIR exchange
+ * @fp: RLIR request frame
+ *
+ * Locking Note: The lport lock is exected to be held before calling
+ * this function.
  */
-static void fc_lport_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
-                             struct fc_lport *lp)
+static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
+                                  struct fc_lport *lport)
 {
-       lp->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
+       if (fc_lport_debug)
+               FC_DBG("Received RLIR request while in state %s\n",
+                      fc_lport_state(lport));
+
+       lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
        fc_frame_free(fp);
 }
 
-/*
- * Handle received ECHO.
+/**
+ * fc_lport_recv_echo_req - Handle received ECHO request
+ * @lport: Fibre Channel local port recieving the ECHO
+ * @sp: current sequence in the ECHO exchange
+ * @fp: ECHO request frame
+ *
+ * Locking Note: The lport lock is exected to be held before calling
+ * this function.
  */
-static void fc_lport_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
-                             struct fc_lport *lp)
+static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
+                                  struct fc_lport *lport)
 {
        struct fc_frame *fp;
        unsigned int len;
@@ -201,29 +303,40 @@ static void fc_lport_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
        void *dp;
        u32 f_ctl;
 
+       if (fc_lport_debug)
+               FC_DBG("Received RLIR request while in state %s\n",
+                      fc_lport_state(lport));
+
        len = fr_len(in_fp) - sizeof(struct fc_frame_header);
        pp = fc_frame_payload_get(in_fp, len);
 
        if (len < sizeof(__be32))
                len = sizeof(__be32);
-       fp = fc_frame_alloc(lp, len);
+
+       fp = fc_frame_alloc(lport, len);
        if (fp) {
                dp = fc_frame_payload_get(fp, len);
                memcpy(dp, pp, len);
                *((u32 *)dp) = htonl(ELS_LS_ACC << 24);
-               sp = lp->tt.seq_start_next(sp);
+               sp = lport->tt.seq_start_next(sp);
                f_ctl = FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                fc_frame_setup(fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
-               lp->tt.seq_send(lp, sp, fp, f_ctl);
+               lport->tt.seq_send(lport, sp, fp, f_ctl);
        }
        fc_frame_free(in_fp);
 }
 
-/*
- * Handle received RNID.
+/**
+ * fc_lport_recv_echo_req - Handle received Request Node ID data request
+ * @lport: Fibre Channel local port recieving the RNID
+ * @sp: current sequence in the RNID exchange
+ * @fp: RNID request frame
+ *
+ * Locking Note: The lport lock is exected to be held before calling
+ * this function.
  */
-static void fc_lport_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
-                             struct fc_lport *lp)
+static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
+                                  struct fc_lport *lport)
 {
        struct fc_frame *fp;
        struct fc_els_rnid *req;
@@ -237,146 +350,165 @@ static void fc_lport_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
        size_t len;
        u32 f_ctl;
 
+       if (fc_lport_debug)
+               FC_DBG("Received RNID request while in state %s\n",
+                      fc_lport_state(lport));
+
        req = fc_frame_payload_get(in_fp, sizeof(*req));
        if (!req) {
                rjt_data.fp = NULL;
                rjt_data.reason = ELS_RJT_LOGIC;
                rjt_data.explan = ELS_EXPL_NONE;
-               lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
+               lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
        } else {
                fmt = req->rnid_fmt;
                len = sizeof(*rp);
                if (fmt != ELS_RNIDF_GEN ||
-                   ntohl(lp->rnid_gen.rnid_atype) == 0) {
+                   ntohl(lport->rnid_gen.rnid_atype) == 0) {
                        fmt = ELS_RNIDF_NONE;   /* nothing to provide */
                        len -= sizeof(rp->gen);
                }
-               fp = fc_frame_alloc(lp, len);
+               fp = fc_frame_alloc(lport, len);
                if (fp) {
                        rp = fc_frame_payload_get(fp, len);
                        memset(rp, 0, len);
                        rp->rnid.rnid_cmd = ELS_LS_ACC;
                        rp->rnid.rnid_fmt = fmt;
                        rp->rnid.rnid_cid_len = sizeof(rp->cid);
-                       rp->cid.rnid_wwpn = htonll(lp->wwpn);
-                       rp->cid.rnid_wwnn = htonll(lp->wwnn);
+                       rp->cid.rnid_wwpn = htonll(lport->wwpn);
+                       rp->cid.rnid_wwnn = htonll(lport->wwnn);
                        if (fmt == ELS_RNIDF_GEN) {
                                rp->rnid.rnid_sid_len = sizeof(rp->gen);
-                               memcpy(&rp->gen, &lp->rnid_gen,
+                               memcpy(&rp->gen, &lport->rnid_gen,
                                       sizeof(rp->gen));
                        }
-                       sp = lp->tt.seq_start_next(sp);
+                       sp = lport->tt.seq_start_next(sp);
                        f_ctl = FC_FC_SEQ_INIT | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                        fc_frame_setup(fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
-                       lp->tt.seq_send(lp, sp, fp, f_ctl);
+                       lport->tt.seq_send(lport, sp, fp, f_ctl);
                }
        }
        fc_frame_free(in_fp);
 }
 
-/*
- * Handle received fabric logout request.
+/**
+ * fc_lport_recv_logo_req - Handle received fabric LOGO request
+ * @lport: Fibre Channel local port recieving the LOGO
+ * @sp: current sequence in the LOGO exchange
+ * @fp: LOGO request frame
+ *
+ * Locking Note: The lport lock is exected to be held before calling
+ * this function.
  */
 static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp,
-                                  struct fc_lport *lp)
+                                  struct fc_lport *lport)
 {
-       lp->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
-       fc_lport_enter_reset(lp);
+       lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
+       fc_lport_enter_reset(lport);
        fc_frame_free(fp);
 }
 
-/*
- * Receive request frame
+/**
+ * fc_fabric_login - Start the lport state machine
+ * @lport: The lport that should log into the fabric
+ *
+ * Locking Note: This function should not be called
+ *               with the lport lock held.
  */
-
-int fc_fabric_login(struct fc_lport *lp)
+int fc_fabric_login(struct fc_lport *lport)
 {
        int rc = -1;
 
-       if (lp->state == LPORT_ST_NONE) {
-               fc_lport_lock(lp);
-               fc_lport_enter_reset(lp);
-               fc_lport_unlock(lp);
+       mutex_lock(&lport->lp_mutex);
+       if (lport->state == LPORT_ST_NONE) {
+               fc_lport_enter_reset(lport);
                rc = 0;
        }
+       mutex_unlock(&lport->lp_mutex);
+
        return rc;
 }
 EXPORT_SYMBOL(fc_fabric_login);
 
 /**
- * fc_linkup - link up notification
- * @dev:      Pointer to fc_lport .
- **/
-void fc_linkup(struct fc_lport *lp)
+ * fc_linkup - Handler for transport linkup events
+ * @lport: The lport whose link is up
+ */
+void fc_linkup(struct fc_lport *lport)
 {
-       if ((lp->link_status & FC_LINK_UP) != FC_LINK_UP) {
-               lp->link_status |= FC_LINK_UP;
-               fc_lport_lock(lp);
-               if (lp->state == LPORT_ST_RESET)
-                       lp->tt.lport_login(lp);
-               fc_lport_unlock(lp);
+       mutex_lock(&lport->lp_mutex);
+       if ((lport->link_status & FC_LINK_UP) != FC_LINK_UP) {
+               lport->link_status |= FC_LINK_UP;
+
+               if (lport->state == LPORT_ST_RESET)
+                       fc_lport_enter_flogi(lport);
        }
+       mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkup);
 
 /**
- * fc_linkdown -  link down notification
- * @dev:      Pointer to fc_lport .
- **/
-void fc_linkdown(struct fc_lport *lp)
+ * fc_linkdown - Handler for transport linkdown events
+ * @lport: The lport whose link is down
+ */
+void fc_linkdown(struct fc_lport *lport)
 {
-       if ((lp->link_status & FC_LINK_UP) == FC_LINK_UP) {
-               lp->link_status &= ~(FC_LINK_UP);
-               fc_lport_enter_reset(lp);
-               lp->tt.scsi_cleanup(lp);
+       mutex_lock(&lport->lp_mutex);
+
+       if ((lport->link_status & FC_LINK_UP) == FC_LINK_UP) {
+               lport->link_status &= ~(FC_LINK_UP);
+               fc_lport_enter_reset(lport);
+               lport->tt.scsi_cleanup(lport);
        }
+
+       mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkdown);
 
-void fc_pause(struct fc_lport *lp)
+/**
+ * fc_pause - Pause the flow of frames
+ * @lport: The lport to be paused
+ */
+void fc_pause(struct fc_lport *lport)
 {
-       lp->link_status |= FC_PAUSE;
+       mutex_lock(&lport->lp_mutex);
+       lport->link_status |= FC_PAUSE;
+       mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_pause);
 
-void fc_unpause(struct fc_lport *lp)
+/**
+ * fc_unpause - Unpause the flow of frames
+ * @lport: The lport to be unpaused
+ */
+void fc_unpause(struct fc_lport *lport)
 {
-       lp->link_status &= ~(FC_PAUSE);
+       mutex_lock(&lport->lp_mutex);
+       lport->link_status &= ~(FC_PAUSE);
+       mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_unpause);
 
-int fc_fabric_logoff(struct fc_lport *lp)
+/**
+ * fc_fabric_logoff - Logout of the fabric
+ * @lport:           fc_lport pointer to logoff the fabric
+ *
+ * Return value:
+ *     0 for success, -1 for failure
+ **/
+int fc_fabric_logoff(struct fc_lport *lport)
 {
-       fc_lport_lock(lp);
-       switch (lp->state) {
-       case LPORT_ST_NONE:
-               break;
-       case LPORT_ST_FLOGI:
-       case LPORT_ST_LOGO:
-       case LPORT_ST_RESET:
-               fc_lport_enter_reset(lp);
-               break;
-       case LPORT_ST_DNS:
-       case LPORT_ST_DNS_STOP:
-               fc_lport_enter_logo(lp);
-               break;
-       case LPORT_ST_REG_PN:
-       case LPORT_ST_REG_FT:
-       case LPORT_ST_SCR:
-       case LPORT_ST_READY:
-               lp->tt.disc_stop(lp);
-               break;
-       }
-       fc_lport_unlock(lp);
-       lp->tt.scsi_cleanup(lp);
-
+       mutex_lock(&lport->lp_mutex);
+       fc_lport_enter_logo(lport);
+       lport->tt.scsi_cleanup(lport);
+       mutex_unlock(&lport->lp_mutex);
        return 0;
 }
 EXPORT_SYMBOL(fc_fabric_logoff);
 
 /**
  * fc_lport_destroy - unregister a fc_lport
- * @lp:           fc_lport pointer to unregister
+ * @lport:           fc_lport pointer to unregister
  *
  * Return value:
  *     None
@@ -386,30 +518,26 @@ EXPORT_SYMBOL(fc_fabric_logoff);
  * and free up other system resources.
  *
  **/
-int fc_lport_destroy(struct fc_lport *lp)
+int fc_lport_destroy(struct fc_lport *lport)
 {
-       fc_lport_lock(lp);
-       fc_lport_state_enter(lp, LPORT_ST_LOGO);
-       fc_lport_unlock(lp);
-
-       cancel_delayed_work_sync(&lp->ns_disc_work);
-
-       lp->tt.scsi_abort_io(lp);
-
-       lp->tt.frame_send = fc_frame_drop;
-
-       lp->tt.exch_mgr_reset(lp->emp, 0, 0);
-
+       mutex_lock(&lport->lp_mutex);
+       cancel_delayed_work_sync(&lport->disc_work);
+       lport->tt.scsi_abort_io(lport);
+       lport->tt.frame_send = fc_frame_drop;
+       lport->tt.exch_mgr_reset(lport->emp, 0, 0);
+       mutex_unlock(&lport->lp_mutex);
        return 0;
 }
 EXPORT_SYMBOL(fc_lport_destroy);
 
-int fc_set_mfs(struct fc_lport *lp, u32 mfs)
+int fc_set_mfs(struct fc_lport *lport, u32 mfs)
 {
        unsigned int old_mfs;
        int rc = -1;
 
-       old_mfs = lp->mfs;
+       mutex_lock(&lport->lp_mutex);
+
+       old_mfs = lport->mfs;
 
        if (mfs >= FC_MIN_MAX_FRAME) {
                mfs &= ~3;
@@ -417,97 +545,55 @@ int fc_set_mfs(struct fc_lport *lp, u32 mfs)
                if (mfs > FC_MAX_FRAME)
                        mfs = FC_MAX_FRAME;
                mfs -= sizeof(struct fc_frame_header);
-               lp->mfs = mfs;
+               lport->mfs = mfs;
                rc = 0;
        }
 
        if (!rc && mfs < old_mfs) {
-               lp->ns_disc_done = 0;
-               fc_lport_enter_reset(lp);
+               lport->disc_done = 0;
+               fc_lport_enter_reset(lport);
        }
+
+       mutex_unlock(&lport->lp_mutex);
+
        return rc;
 }
 EXPORT_SYMBOL(fc_set_mfs);
 
-/*
- * re-enter state for retrying a request after a timeout or alloc failure.
+/**
+ * fc_rport_enter_ready - Enter the ready state and start discovery
+ * @lport: Fibre Channel local port that is ready
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
  */
-static void fc_lport_enter_retry(struct fc_lport *lp)
+static void fc_lport_enter_ready(struct fc_lport *lport)
 {
-       switch (lp->state) {
-       case LPORT_ST_NONE:
-       case LPORT_ST_READY:
-       case LPORT_ST_RESET:
-       case LPORT_ST_DNS:
-       case LPORT_ST_DNS_STOP:
-       case LPORT_ST_REG_PN:
-       case LPORT_ST_REG_FT:
-       case LPORT_ST_SCR:
-               WARN_ON(1);
-               break;
-       case LPORT_ST_FLOGI:
-               fc_lport_enter_flogi(lp);
-               break;
-       case LPORT_ST_LOGO:
-               fc_lport_enter_logo(lp);
-               break;
-       }
-}
+       if (fc_lport_debug)
+               FC_DBG("Port (%6x) entered Ready from state %s\n",
+                      lport->fid, fc_lport_state(lport));
 
-/*
- * enter next state for handling an exchange reject or retry exhaustion
- * in the current state.
- */
-static void fc_lport_enter_reject(struct fc_lport *lp)
-{
-       switch (lp->state) {
-       case LPORT_ST_NONE:
-       case LPORT_ST_READY:
-       case LPORT_ST_RESET:
-       case LPORT_ST_REG_PN:
-       case LPORT_ST_REG_FT:
-       case LPORT_ST_SCR:
-       case LPORT_ST_DNS_STOP:
-       case LPORT_ST_DNS:
-               WARN_ON(1);
-               break;
-       case LPORT_ST_FLOGI:
-               fc_lport_enter_flogi(lp);
-               break;
-       case LPORT_ST_LOGO:
-               fc_lport_enter_reset(lp);
-               break;
-       }
-}
+       fc_lport_state_enter(lport, LPORT_ST_READY);
 
-/*
- * Handle resource allocation problem by retrying in a bit.
- */
-static void fc_lport_retry(struct fc_lport *lp)
-{
-       if (lp->retry_count == 0)
-               FC_DBG("local port %6x alloc failure in state %s "
-                      "- will retry\n", lp->fid, fc_lport_state(lp));
-       if (lp->retry_count < lp->max_retry_count) {
-               lp->retry_count++;
-               mod_timer(&lp->state_timer,
-                         jiffies + msecs_to_jiffies(lp->e_d_tov));
-       } else {
-               FC_DBG("local port %6x alloc failure in state %s "
-                      "- retries exhausted\n", lp->fid,
-                      fc_lport_state(lp));
-               fc_lport_enter_reject(lp);
-       }
+       lport->tt.disc_start(lport);
 }
 
-/*
+/**
+ * fc_lport_recv_flogi_req - Receive a FLOGI request
+ * @sp_in: The sequence the FLOGI is on
+ * @rx_fp: The frame the FLOGI is in
+ * @lport: The lport that recieved the request
+ *
  * A received FLOGI request indicates a point-to-point connection.
  * Accept it with the common service parameters indicating our N port.
  * Set up to do a PLOGI if we have the higher-number WWPN.
+ *
+ * Locking Note: The lport lock is exected to be held before calling
+ * this function.
  */
 static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                                    struct fc_frame *rx_fp,
-                                   struct fc_lport *lp)
+                                   struct fc_lport *lport)
 {
        struct fc_frame *fp;
        struct fc_frame_header *fh;
@@ -519,19 +605,22 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
        u32 local_fid;
        u32 f_ctl;
 
+       if (fc_lport_debug)
+               FC_DBG("Received FLOGI request while in state %s\n",
+                      fc_lport_state(lport));
+
        fh = fc_frame_header_get(rx_fp);
        remote_fid = ntoh24(fh->fh_s_id);
        flp = fc_frame_payload_get(rx_fp, sizeof(*flp));
        if (!flp)
                goto out;
        remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
-       if (remote_wwpn == lp->wwpn) {
+       if (remote_wwpn == lport->wwpn) {
                FC_DBG("FLOGI from port with same WWPN %llx "
                       "possible configuration error\n", remote_wwpn);
                goto out;
        }
        FC_DBG("FLOGI from port WWPN %llx\n", remote_wwpn);
-       fc_lport_lock(lp);
 
        /*
         * XXX what is the right thing to do for FIDs?
@@ -539,20 +628,21 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
         * But if so, both of us could end up with the same FID.
         */
        local_fid = FC_LOCAL_PTP_FID_LO;
-       if (remote_wwpn < lp->wwpn) {
+       if (remote_wwpn < lport->wwpn) {
                local_fid = FC_LOCAL_PTP_FID_HI;
                if (!remote_fid || remote_fid == local_fid)
                        remote_fid = FC_LOCAL_PTP_FID_LO;
        } else if (!remote_fid) {
                remote_fid = FC_LOCAL_PTP_FID_HI;
        }
-       fc_lport_set_fid(lp, local_fid);
 
-       fp = fc_frame_alloc(lp, sizeof(*flp));
+       lport->fid = local_fid;
+
+       fp = fc_frame_alloc(lport, sizeof(*flp));
        if (fp) {
-               sp = lp->tt.seq_start_next(fr_seq(rx_fp));
+               sp = lport->tt.seq_start_next(fr_seq(rx_fp));
                new_flp = fc_frame_payload_get(fp, sizeof(*flp));
-               fc_lport_flogi_fill(lp, new_flp, ELS_FLOGI);
+               fc_lport_flogi_fill(lport, new_flp, ELS_FLOGI);
                new_flp->fl_cmd = (u8) ELS_LS_ACC;
 
                /*
@@ -561,23 +651,35 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                 */
                f_ctl = FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                fc_frame_setup(fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
-               lp->tt.seq_send(lp, sp, fp, f_ctl);
+               lport->tt.seq_send(lport, sp, fp, f_ctl);
 
        } else {
-               fc_lport_retry(lp);
+               fc_lport_error(lport, fp);
        }
-       fc_lport_ptp_setup(lp, remote_fid, remote_wwpn,
+       fc_lport_ptp_setup(lport, remote_fid, remote_wwpn,
                           get_unaligned_be64(&flp->fl_wwnn));
-       fc_lport_unlock(lp);
-       if (lp->tt.disc_start(lp))
+
+       if (lport->tt.disc_start(lport))
                FC_DBG("target discovery start error\n");
 out:
        sp = fr_seq(rx_fp);
        fc_frame_free(rx_fp);
 }
 
-static void fc_lport_recv(struct fc_lport *lp, struct fc_seq *sp,
-                         struct fc_frame *fp)
+/**
+ * fc_lport_recv_req - The generic lport request handler
+ * @lport: The lport that received the request
+ * @sp: The sequence the request is on
+ * @fp: The frame the request is in
+ *
+ * This function will see if the lport handles the request or
+ * if an rport should handle the request.
+ *
+ * Locking Note: This function should not be called with the lport
+ *               lock held becuase it will grab the lock.
+ */
+static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
+                             struct fc_frame *fp)
 {
        struct fc_frame_header *fh = fc_frame_header_get(fp);
        void (*recv) (struct fc_seq *, struct fc_frame *, struct fc_lport *);
@@ -586,6 +688,8 @@ static void fc_lport_recv(struct fc_lport *lp, struct fc_seq *sp,
        u32 d_id;
        struct fc_seq_els_data rjt_data;
 
+       mutex_lock(&lport->lp_mutex);
+
        /*
         * Handle special ELS cases like FLOGI, LOGO, and
         * RSCN here.  These don't require a session.
@@ -606,21 +710,21 @@ static void fc_lport_recv(struct fc_lport *lp, struct fc_seq *sp,
                                recv = fc_lport_recv_logo_req;
                        break;
                case ELS_RSCN:
-                       recv = lp->tt.disc_recv_req;
+                       recv = lport->tt.disc_recv_req;
                        break;
                case ELS_ECHO:
-                       recv = fc_lport_echo_req;
+                       recv = fc_lport_recv_echo_req;
                        break;
                case ELS_RLIR:
-                       recv = fc_lport_rlir_req;
+                       recv = fc_lport_recv_rlir_req;
                        break;
                case ELS_RNID:
-                       recv = fc_lport_rnid_req;
+                       recv = fc_lport_recv_rnid_req;
                        break;
                }
 
                if (recv)
-                       recv(sp, fp, lp);
+                       recv(sp, fp, lport);
                else {
                        /*
                         * Find session.
@@ -629,16 +733,17 @@ static void fc_lport_recv(struct fc_lport *lp, struct fc_seq *sp,
                        s_id = ntoh24(fh->fh_s_id);
                        d_id = ntoh24(fh->fh_d_id);
 
-                       rport = lp->tt.rport_lookup(lp, s_id);
+                       rport = lport->tt.rport_lookup(lport, s_id);
                        if (rport) {
-                               lp->tt.rport_recv_req(sp, fp, rport);
+                               lport->tt.rport_recv_req(sp, fp, rport);
                                put_device(&rport->dev); /* hold from lookup */
                        } else {
                                rjt_data.fp = NULL;
                                rjt_data.reason = ELS_RJT_UNAB;
                                rjt_data.explan = ELS_EXPL_NONE;
-                               lp->tt.seq_els_rsp_send(sp,
-                                                       ELS_LS_RJT, &rjt_data);
+                               lport->tt.seq_els_rsp_send(sp,
+                                                          ELS_LS_RJT,
+                                                          &rjt_data);
                                fc_frame_free(fp);
                        }
                }
@@ -646,151 +751,572 @@ static void fc_lport_recv(struct fc_lport *lp, struct fc_seq *sp,
                FC_DBG("dropping invalid frame (eof %x)\n", fr_eof(fp));
                fc_frame_free(fp);
        }
+       mutex_unlock(&lport->lp_mutex);
+}
 
-       /*
-        *  The common exch_done for all request may not be good
-        *  if any request requires longer hold on exhange. XXX
-        */
-       lp->tt.exch_done(sp);
+/**
+ * fc_lport_reset - Reset an lport
+ * @lport: The lport which should be reset
+ *
+ * Locking Note: This functions should not be called with the
+ *               lport lock held.
+ */
+int fc_lport_reset(struct fc_lport *lport)
+{
+       mutex_lock(&lport->lp_mutex);
+       fc_lport_enter_reset(lport);
+       mutex_unlock(&lport->lp_mutex);
+       return 0;
 }
+EXPORT_SYMBOL(fc_lport_reset);
 
-/*
- * Put the local port back into the initial state.  Reset all sessions.
- * This is called after a SCSI reset or the driver is unloading
- * or the program is exiting.
+/**
+ * fc_rport_enter_reset - Reset the local port
+ * @lport: Fibre Channel local port to be reset
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
  */
-int fc_lport_enter_reset(struct fc_lport *lp)
+static void fc_lport_enter_reset(struct fc_lport *lport)
 {
        if (fc_lport_debug)
-               FC_DBG("Processing RESET state\n");
+               FC_DBG("Port (%6x) entered RESET state from %s state\n",
+                      lport->fid, fc_lport_state(lport));
+
+       fc_lport_state_enter(lport, LPORT_ST_RESET);
 
-       if (lp->dns_rp) {
-               fc_remote_port_delete(lp->dns_rp);
-               lp->dns_rp = NULL;
+       if (lport->dns_rp) {
+               fc_remote_port_delete(lport->dns_rp);
+               lport->dns_rp = NULL;
        }
-       fc_lport_ptp_clear(lp);
+       fc_lport_ptp_clear(lport);
 
-       /*
-        * Setting state RESET keeps fc_lport_error() callbacks
-        * by exch_mgr_reset() from recursing on the lock.
-        * It also causes fc_lport_sess_event() to ignore events.
-        * The lock is held for the duration of the time in RESET state.
-        */
-       fc_lport_state_enter(lp, LPORT_ST_RESET);
-       lp->tt.exch_mgr_reset(lp->emp, 0, 0);
-       fc_lport_set_fid(lp, 0);
-       if ((lp->link_status & FC_LINK_UP) == FC_LINK_UP)
-               fc_lport_enter_flogi(lp);
-       return 0;
+       fc_block_rports(lport);
+
+       lport->tt.rport_reset_list(lport);
+       lport->tt.exch_mgr_reset(lport->emp, 0, 0);
+       fc_host_fabric_name(lport->host) = 0;
+       lport->fid = 0;
+
+       if ((lport->link_status & FC_LINK_UP) == FC_LINK_UP)
+               fc_lport_enter_flogi(lport);
 }
-EXPORT_SYMBOL(fc_lport_enter_reset);
 
-/*
- * Handle errors on local port requests.
- * Don't get locks if in RESET state.
- * The only possible errors so far are exchange TIMEOUT and CLOSED (reset).
+/**
+ * fc_lport_error - Handler for any errors
+ * @lport: The fc_lport object
+ * @fp: The frame pointer
+ *
+ * If the error was caused by a resource allocation failure
+ * then wait for half a second and retry, otherwise retry
+ * after the e_d_tov time.
+ */
+static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
+{
+       unsigned long delay = 0;
+       if (fc_lport_debug)
+               FC_DBG("Error %ld in state %s, retries %d\n",
+                      PTR_ERR(fp), fc_lport_state(lport),
+                      lport->retry_count);
+
+       if (lport->retry_count < lport->max_retry_count) {
+               lport->retry_count++;
+               if (!fp)
+                       delay = msecs_to_jiffies(500);
+               else
+                       delay = jiffies +
+                               msecs_to_jiffies(lport->e_d_tov);
+
+               schedule_delayed_work(&lport->retry_work, delay);
+       } else {
+               switch (lport->state) {
+               case LPORT_ST_NONE:
+               case LPORT_ST_READY:
+               case LPORT_ST_RESET:
+               case LPORT_ST_RPN_ID:
+               case LPORT_ST_RFT_ID:
+               case LPORT_ST_SCR:
+               case LPORT_ST_DNS:
+               case LPORT_ST_FLOGI:
+               case LPORT_ST_LOGO:
+                       fc_lport_enter_reset(lport);
+                       break;
+               }
+       }
+}
+
+/**
+ * fc_lport_rft_id_resp - Handle response to Register Fibre
+ *                        Channel Types by ID (RPN_ID) request
+ * @sp: current sequence in RPN_ID exchange
+ * @fp: response frame
+ * @lp_arg: Fibre Channel host port instance
+ *
+ * Locking Note: This function will be called without the lport lock
+ * held, but it will lock, call an _enter_* function or fc_lport_error
+ * and then unlock the lport.
+ */
+static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
+                                void *lp_arg)
+{
+       struct fc_lport *lport = lp_arg;
+       struct fc_frame_header *fh;
+       struct fc_ct_hdr *ct;
+
+       mutex_lock(&lport->lp_mutex);
+
+       if (fc_lport_debug)
+               FC_DBG("Received a RFT_ID response\n");
+
+       if (lport->state != LPORT_ST_RFT_ID) {
+               FC_DBG("Received a RFT_ID response, but in state %s\n",
+                      fc_lport_state(lport));
+               goto out;
+       }
+
+       if (IS_ERR(fp)) {
+               fc_lport_error(lport, fp);
+               goto out;
+       }
+
+       fh = fc_frame_header_get(fp);
+       ct = fc_frame_payload_get(fp, sizeof(*ct));
+
+       if (fh && ct && fh->fh_type == FC_TYPE_CT &&
+           ct->ct_fs_type == FC_FST_DIR &&
+           ct->ct_fs_subtype == FC_NS_SUBTYPE &&
+           ntohs(ct->ct_cmd) == FC_FS_ACC)
+               fc_lport_enter_scr(lport);
+       else
+               fc_lport_error(lport, fp);
+out:
+       mutex_unlock(&lport->lp_mutex);
+       fc_frame_free(fp);
+}
+
+/**
+ * fc_lport_rpn_id_resp - Handle response to Register Port
+ *                        Name by ID (RPN_ID) request
+ * @sp: current sequence in RPN_ID exchange
+ * @fp: response frame
+ * @lp_arg: Fibre Channel host port instance
+ *
+ * Locking Note: This function will be called without the lport lock
+ * held, but it will lock, call an _enter_* function or fc_lport_error
+ * and then unlock the lport.
+ */
+static void fc_lport_rpn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
+                                void *lp_arg)
+{
+       struct fc_lport *lport = lp_arg;
+       struct fc_frame_header *fh;
+       struct fc_ct_hdr *ct;
+
+       mutex_lock(&lport->lp_mutex);
+
+       if (fc_lport_debug)
+               FC_DBG("Received a RPN_ID response\n");
+
+       if (lport->state != LPORT_ST_RPN_ID) {
+               FC_DBG("Received a RPN_ID response, but in state %s\n",
+                      fc_lport_state(lport));
+               goto out;
+       }
+
+       if (IS_ERR(fp)) {
+               fc_lport_error(lport, fp);
+               goto out;
+       }
+
+       fh = fc_frame_header_get(fp);
+       ct = fc_frame_payload_get(fp, sizeof(*ct));
+       if (fh && ct && fh->fh_type == FC_TYPE_CT &&
+           ct->ct_fs_type == FC_FST_DIR &&
+           ct->ct_fs_subtype == FC_NS_SUBTYPE &&
+           ntohs(ct->ct_cmd) == FC_FS_ACC)
+               fc_lport_enter_rft_id(lport);
+       else
+               fc_lport_error(lport, fp);
+
+out:
+       mutex_unlock(&lport->lp_mutex);
+       fc_frame_free(fp);
+}
+
+/**
+ * fc_lport_scr_resp - Handle response to State Change Register (SCR) request
+ * @sp: current sequence in SCR exchange
+ * @fp: response frame
+ * @lp_arg: Fibre Channel lport port instance that sent the registration request
+ *
+ * Locking Note: This function will be called without the lport lock
+ * held, but it will lock, call an _enter_* function or fc_lport_error
+ * and then unlock the lport.
  */
-static void fc_lport_error(struct fc_lport *lp, struct fc_frame *fp)
+static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
+                             void *lp_arg)
 {
-       if (lp->state == LPORT_ST_RESET)
+       struct fc_lport *lport = lp_arg;
+       u8 op;
+
+       mutex_lock(&lport->lp_mutex);
+
+       if (fc_lport_debug)
+               FC_DBG("Received a SCR response\n");
+
+       if (lport->state != LPORT_ST_SCR) {
+               FC_DBG("Received a SCR response, but in state %s\n",
+                      fc_lport_state(lport));
+               goto out;
+       }
+
+       if (IS_ERR(fp)) {
+               fc_lport_error(lport, fp);
+               goto out;
+       }
+
+       op = fc_frame_payload_op(fp);
+       if (op == ELS_LS_ACC)
+               fc_lport_enter_ready(lport);
+       else
+               fc_lport_error(lport, fp);
+
+out:
+       mutex_unlock(&lport->lp_mutex);
+       fc_frame_free(fp);
+}
+
+/**
+ * fc_lport_enter_scr - Send a State Change Register (SCR) request
+ * @lport: Fibre Channel local port to register for state changes
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static void fc_lport_enter_scr(struct fc_lport *lport)
+{
+       struct fc_frame *fp;
+       struct fc_els_scr *scr;
+
+       if (fc_lport_debug)
+               FC_DBG("Port (%6x) entered SCR state from %s state\n",
+                      lport->fid, fc_lport_state(lport));
+
+       fc_lport_state_enter(lport, LPORT_ST_SCR);
+
+       fp = fc_frame_alloc(lport, sizeof(*scr));
+       if (!fp) {
+               fc_lport_error(lport, fp);
                return;
+       }
 
-       fc_lport_lock(lp);
-       if (PTR_ERR(fp) == -FC_EX_TIMEOUT) {
-               if (lp->retry_count < lp->max_retry_count) {
-                       lp->retry_count++;
-                       fc_lport_enter_retry(lp);
-               } else {
-                       fc_lport_enter_reject(lp);
+       scr = fc_frame_payload_get(fp, sizeof(*scr));
+       memset(scr, 0, sizeof(*scr));
+       scr->scr_cmd = ELS_SCR;
+       scr->scr_reg_func = ELS_SCRF_FULL;
+       fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
+       fc_frame_set_offset(fp, 0);
+
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_lport_scr_resp, NULL,
+                                    lport, lport->e_d_tov,
+                                    lport->fid, FC_FID_FCTRL,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_lport_error(lport, fp);
+}
+
+/**
+ * fc_lport_enter_rft_id - Register FC4-types with the name server
+ * @lport: Fibre Channel local port to register
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static void fc_lport_enter_rft_id(struct fc_lport *lport)
+{
+       struct fc_frame *fp;
+       struct req {
+               struct fc_ct_hdr ct;
+               struct fc_ns_fid fid;   /* port ID object */
+               struct fc_ns_fts fts;   /* FC4-types object */
+       } *req;
+       struct fc_ns_fts *lps;
+       int i;
+
+       if (fc_lport_debug)
+               FC_DBG("Port (%6x) entered RFT_ID state from %s state\n",
+                      lport->fid, fc_lport_state(lport));
 
+       fc_lport_state_enter(lport, LPORT_ST_RFT_ID);
+
+       lps = &lport->fcts;
+       i = sizeof(lps->ff_type_map) / sizeof(lps->ff_type_map[0]);
+       while (--i >= 0)
+               if (ntohl(lps->ff_type_map[i]) != 0)
+                       break;
+       if (i < 0) {
+               /* nothing to register, move on to SCR */
+               fc_lport_enter_scr(lport);
+       } else {
+               fp = fc_frame_alloc(lport, sizeof(*req));
+               if (!fp) {
+                       fc_lport_error(lport, fp);
+                       return;
                }
+
+               req = fc_frame_payload_get(fp, sizeof(*req));
+               fc_fill_dns_hdr(lport, &req->ct,
+                               FC_NS_RFT_ID,
+                               sizeof(*req) -
+                               sizeof(struct fc_ct_hdr));
+               hton24(req->fid.fp_fid, lport->fid);
+               req->fts = *lps;
+               fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
+
+               if (!lport->tt.exch_seq_send(lport, fp,
+                                            fc_lport_rft_id_resp, NULL,
+                                            lport, lport->e_d_tov,
+                                            lport->fid,
+                                            FC_FID_DIR_SERV,
+                                            FC_FC_SEQ_INIT |
+                                            FC_FC_END_SEQ))
+                       fc_lport_error(lport, fp);
+       }
+}
+
+/**
+ * fc_rport_enter_rft_id - Register port name with the name server
+ * @lport: Fibre Channel local port to register
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static void fc_lport_enter_rpn_id(struct fc_lport *lport)
+{
+       struct fc_frame *fp;
+       struct req {
+               struct fc_ct_hdr ct;
+               struct fc_ns_rn_id rn;
+       } *req;
+
+       if (fc_lport_debug)
+               FC_DBG("Port (%6x) entered RPN_ID state from %s state\n",
+                      lport->fid, fc_lport_state(lport));
+
+       fc_lport_state_enter(lport, LPORT_ST_RPN_ID);
+
+       fp = fc_frame_alloc(lport, sizeof(*req));
+       if (!fp) {
+               fc_lport_error(lport, fp);
+               return;
        }
+
+       req = fc_frame_payload_get(fp, sizeof(*req));
+       memset(req, 0, sizeof(*req));
+       fc_fill_dns_hdr(lport, &req->ct, FC_NS_RPN_ID, sizeof(req->rn));
+       hton24(req->rn.fr_fid.fp_fid, lport->fid);
+       put_unaligned_be64(lport->wwpn, &req->rn.fr_wwn);
+       fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
+
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_lport_rpn_id_resp, NULL,
+                                    lport, lport->e_d_tov,
+                                    lport->fid,
+                                    FC_FID_DIR_SERV,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_lport_error(lport, fp);
+
+}
+
+/**
+ * fc_rport_enter_dns - Create a rport to the name server
+ * @lport: Fibre Channel local port requesting a rport for the name server
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static void fc_lport_enter_dns(struct fc_lport *lport)
+{
+       struct fc_rport *rport;
+       struct fc_rport_libfc_priv *rdata;
+       struct fc_disc_port dp;
+
+       dp.ids.port_id = FC_FID_DIR_SERV;
+       dp.ids.port_name = -1;
+       dp.ids.node_name = -1;
+       dp.ids.roles = FC_RPORT_ROLE_UNKNOWN;
+       dp.lp = lport;
+
        if (fc_lport_debug)
-               FC_DBG("error %ld retries %d limit %d\n",
-                      PTR_ERR(fp), lp->retry_count, lp->max_retry_count);
-       fc_lport_unlock(lp);
+               FC_DBG("Port (%6x) entered DNS state from %s state\n",
+                      lport->fid, fc_lport_state(lport));
+
+       fc_lport_state_enter(lport, LPORT_ST_DNS);
+
+       if (!lport->dns_rp) {
+               /* Set up a dummy rport to directory server */
+               rport = fc_rport_dummy_create(&dp);
+
+               if (!rport)
+                       goto err;
+               lport->dns_rp = rport;
+               FC_DBG("created an rport for the NS\n");
+       }
+
+       rport = lport->dns_rp;
+       rdata = rport->dd_data;
+       rdata->event_callback = fc_lport_rport_event;
+       lport->tt.rport_login(rport);
+       return;
+
+err:
+       fc_lport_error(lport, NULL);
 }
 
-static void fc_lport_timeout(unsigned long lp_arg)
+/**
+ * fc_lport_timeout - Handler for the retry_work timer.
+ * @work: The work struct of the fc_lport
+ */
+static void fc_lport_timeout(struct work_struct *work)
 {
-       struct fc_lport *lp = (struct fc_lport *)lp_arg;
+       struct fc_lport *lport =
+               container_of(work, struct fc_lport,
+                            retry_work.work);
 
-       fc_lport_lock(lp);
-       fc_lport_enter_retry(lp);
-       fc_lport_unlock(lp);
+       mutex_lock(&lport->lp_mutex);
+
+       switch (lport->state) {
+       case LPORT_ST_NONE:
+       case LPORT_ST_READY:
+       case LPORT_ST_RESET:
+               WARN_ON(1);
+               break;
+       case LPORT_ST_FLOGI:
+               fc_lport_enter_flogi(lport);
+               break;
+       case LPORT_ST_DNS:
+               fc_lport_enter_dns(lport);
+               break;
+       case LPORT_ST_RPN_ID:
+               fc_lport_enter_rpn_id(lport);
+               break;
+       case LPORT_ST_RFT_ID:
+               fc_lport_enter_rft_id(lport);
+               break;
+       case LPORT_ST_SCR:
+               fc_lport_enter_scr(lport);
+               break;
+       case LPORT_ST_LOGO:
+               fc_lport_enter_logo(lport);
+               break;
+       }
+
+       mutex_unlock(&lport->lp_mutex);
 }
 
+/**
+ * fc_lport_logo_resp - Handle response to LOGO request
+ * @sp: current sequence in LOGO exchange
+ * @fp: response frame
+ * @lp_arg: Fibre Channel lport port instance that sent the LOGO request
+ *
+ * Locking Note: This function will be called without the lport lock
+ * held, but it will lock, call an _enter_* function or fc_lport_error
+ * and then unlock the lport.
+ */
 static void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
                               void *lp_arg)
 {
-       struct fc_lport *lp = lp_arg;
+       struct fc_lport *lport = lp_arg;
+       u8 op;
 
-       if (IS_ERR(fp))
-               fc_lport_error(lp, fp);
-       else {
-               fc_frame_free(fp);
-               fc_lport_lock(lp);
-               fc_lport_enter_reset(lp);
-               fc_lport_unlock(lp);
+       mutex_lock(&lport->lp_mutex);
+
+       if (fc_lport_debug)
+               FC_DBG("Received a LOGO response\n");
+
+       if (lport->state != LPORT_ST_LOGO) {
+               FC_DBG("Received a LOGO response, but in state %s\n",
+                      fc_lport_state(lport));
+               goto out;
        }
+
+       if (IS_ERR(fp)) {
+               fc_lport_error(lport, fp);
+               goto out;
+       }
+
+       op = fc_frame_payload_op(fp);
+       if (op == ELS_LS_ACC)
+               fc_lport_enter_reset(lport);
+       else
+               fc_lport_error(lport, fp);
+
+out:
+       mutex_unlock(&lport->lp_mutex);
+       fc_frame_free(fp);
 }
 
-/* Logout of the FC fabric */
-static void fc_lport_enter_logo(struct fc_lport *lp)
+/**
+ * fc_rport_enter_logo - Logout of the fabric
+ * @lport: Fibre Channel local port to be logged out
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static void fc_lport_enter_logo(struct fc_lport *lport)
 {
        struct fc_frame *fp;
        struct fc_els_logo *logo;
 
        if (fc_lport_debug)
-               FC_DBG("Processing LOGO state\n");
+               FC_DBG("Port (%6x) entered LOGO state from %s state\n",
+                      lport->fid, fc_lport_state(lport));
 
-       fc_lport_state_enter(lp, LPORT_ST_LOGO);
+       fc_lport_state_enter(lport, LPORT_ST_LOGO);
 
        /* DNS session should be closed so we can release it here */
-       if (lp->dns_rp) {
-               fc_remote_port_delete(lp->dns_rp);
-               lp->dns_rp = NULL;
+       if (lport->dns_rp) {
+               fc_remote_port_delete(lport->dns_rp);
+               lport->dns_rp = NULL;
        }
 
-       fp = fc_frame_alloc(lp, sizeof(*logo));
+       fp = fc_frame_alloc(lport, sizeof(*logo));
        if (!fp) {
-               FC_DBG("failed to allocate frame\n");
+               fc_lport_error(lport, fp);
                return;
        }
 
        logo = fc_frame_payload_get(fp, sizeof(*logo));
        memset(logo, 0, sizeof(*logo));
        logo->fl_cmd = ELS_LOGO;
-       hton24(logo->fl_n_port_id, lp->fid);
-       logo->fl_n_port_wwn = htonll(lp->wwpn);
-
+       hton24(logo->fl_n_port_id, lport->fid);
+       logo->fl_n_port_wwn = htonll(lport->wwpn);
        fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
        fc_frame_set_offset(fp, 0);
 
-       lp->tt.exch_seq_send(lp, fp,
-                             fc_lport_logo_resp,
-                             lp, lp->e_d_tov,
-                             lp->fid, FC_FID_FLOGI,
-                             FC_FC_SEQ_INIT | FC_FC_END_SEQ);
-}
-
-static int fc_lport_logout(struct fc_lport *lp)
-{
-       fc_lport_lock(lp);
-       if (lp->state != LPORT_ST_LOGO)
-               fc_lport_enter_logo(lp);
-       fc_lport_unlock(lp);
-       return 0;
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_lport_logo_resp, NULL,
+                                    lport, lport->e_d_tov,
+                                    lport->fid, FC_FID_FLOGI,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_lport_error(lport, fp);
 }
 
-/*
- * Handle incoming ELS FLOGI response.
- * Save parameters of remote switch.  Finish exchange.
+/**
+ * fc_lport_flogi_resp - Handle response to FLOGI request
+ * @sp: current sequence in FLOGI exchange
+ * @fp: response frame
+ * @lp_arg: Fibre Channel lport port instance that sent the FLOGI request
+ *
+ * Locking Note: This function will be called without the lport lock
+ * held, but it will lock, call an _enter_* function or fc_lport_error
+ * and then unlock the lport.
  */
-static void
-fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp, void *lp_arg)
+static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
+                               void *lp_arg)
 {
-       struct fc_lport *lp = lp_arg;
+       struct fc_lport *lport = lp_arg;
        struct fc_frame_header *fh;
        struct fc_els_flogi *flp;
        u32 did;
@@ -799,127 +1325,160 @@ fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp, void *lp_arg)
        unsigned int e_d_tov;
        u16 mfs;
 
+       mutex_lock(&lport->lp_mutex);
+
+       if (fc_lport_debug)
+               FC_DBG("Received a FLOGI response\n");
+
+       if (lport->state != LPORT_ST_FLOGI) {
+               FC_DBG("Received a FLOGI response, but in state %s\n",
+                      fc_lport_state(lport));
+               goto out;
+       }
+
        if (IS_ERR(fp)) {
-               fc_lport_error(lp, fp);
-               return;
+               fc_lport_error(lport, fp);
+               goto out;
        }
 
        fh = fc_frame_header_get(fp);
        did = ntoh24(fh->fh_d_id);
        if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
                if (fc_lport_debug)
-                       FC_DBG("assigned fid %x\n", did);
-               fc_lport_lock(lp);
-               fc_lport_set_fid(lp, did);
+                       FC_DBG("Assigned fid %x\n", did);
+
+               lport->fid = did;
                flp = fc_frame_payload_get(fp, sizeof(*flp));
                if (flp) {
                        mfs = ntohs(flp->fl_csp.sp_bb_data) &
                                FC_SP_BB_DATA_MASK;
                        if (mfs >= FC_SP_MIN_MAX_PAYLOAD &&
-                           mfs < lp->mfs)
-                               lp->mfs = mfs;
+                           mfs < lport->mfs)
+                               lport->mfs = mfs;
                        csp_flags = ntohs(flp->fl_csp.sp_features);
                        r_a_tov = ntohl(flp->fl_csp.sp_r_a_tov);
                        e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
                        if (csp_flags & FC_SP_FT_EDTR)
                                e_d_tov /= 1000000;
                        if ((csp_flags & FC_SP_FT_FPORT) == 0) {
-                               if (e_d_tov > lp->e_d_tov)
-                                       lp->e_d_tov = e_d_tov;
-                               lp->r_a_tov = 2 * e_d_tov;
-                               FC_DBG("point-to-point mode\n");
-                               fc_lport_ptp_setup(lp, ntoh24(fh->fh_s_id),
+                               if (e_d_tov > lport->e_d_tov)
+                                       lport->e_d_tov = e_d_tov;
+                               lport->r_a_tov = 2 * e_d_tov;
+                               FC_DBG("Point-to-Point mode\n");
+                               fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
                                                   get_unaligned_be64(
                                                           &flp->fl_wwpn),
                                                   get_unaligned_be64(
                                                           &flp->fl_wwnn));
                        } else {
-                               lp->e_d_tov = e_d_tov;
-                               lp->r_a_tov = r_a_tov;
-                               lp->tt.dns_register(lp);
+                               lport->e_d_tov = e_d_tov;
+                               lport->r_a_tov = r_a_tov;
+                               fc_host_fabric_name(lport->host) =
+                                       get_unaligned_be64(&flp->fl_wwnn);
+                               fc_lport_enter_dns(lport);
                        }
                }
-               fc_lport_unlock(lp);
+
                if (flp) {
                        csp_flags = ntohs(flp->fl_csp.sp_features);
                        if ((csp_flags & FC_SP_FT_FPORT) == 0) {
-                               if (lp->tt.disc_start(lp))
-                                       FC_DBG("target disc start error\n");
+                               if (lport->tt.disc_start(lport))
+                                       FC_DBG("Target disc start error\n");
                        }
                }
        } else {
                FC_DBG("bad FLOGI response\n");
        }
+
+out:
+       mutex_unlock(&lport->lp_mutex);
        fc_frame_free(fp);
 }
 
-/*
- * Send ELS (extended link service) FLOGI request to peer.
+/**
+ * fc_rport_enter_flogi - Send a FLOGI request to the fabric manager
+ * @lport: Fibre Channel local port to be logged in to the fabric
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
  */
-static void fc_lport_flogi_send(struct fc_lport *lp)
+void fc_lport_enter_flogi(struct fc_lport *lport)
 {
        struct fc_frame *fp;
        struct fc_els_flogi *flp;
 
-       fp = fc_frame_alloc(lp, sizeof(*flp));
+       if (fc_lport_debug)
+               FC_DBG("Processing FLOGI state\n");
+
+       fc_lport_state_enter(lport, LPORT_ST_FLOGI);
+
+       fp = fc_frame_alloc(lport, sizeof(*flp));
        if (!fp)
-               return fc_lport_retry(lp);
+               return fc_lport_error(lport, fp);
 
        flp = fc_frame_payload_get(fp, sizeof(*flp));
-       fc_lport_flogi_fill(lp, flp, ELS_FLOGI);
+       fc_lport_flogi_fill(lport, flp, ELS_FLOGI);
 
        fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
        fc_frame_set_offset(fp, 0);
 
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                  fc_lport_flogi_resp,
-                                  lp, lp->e_d_tov,
-                                  0, FC_FID_FLOGI,
-                                  FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               fc_lport_retry(lp);
-
-}
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_lport_flogi_resp, NULL,
+                                    lport, lport->e_d_tov,
+                                    0, FC_FID_FLOGI,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_lport_error(lport, fp);
 
-void fc_lport_enter_flogi(struct fc_lport *lp)
-{
-       if (fc_lport_debug)
-               FC_DBG("Processing FLOGI state\n");
-       fc_lport_state_enter(lp, LPORT_ST_FLOGI);
-       fc_lport_flogi_send(lp);
 }
 
 /* Configure a fc_lport */
-int fc_lport_config(struct fc_lport *lp)
+int fc_lport_config(struct fc_lport *lport)
 {
-       setup_timer(&lp->state_timer, fc_lport_timeout, (unsigned long)lp);
-       spin_lock_init(&lp->state_lock);
+       INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
+       mutex_init(&lport->lp_mutex);
 
-       fc_lport_lock(lp);
-       fc_lport_state_enter(lp, LPORT_ST_NONE);
-       fc_lport_unlock(lp);
+       fc_lport_state_enter(lport, LPORT_ST_NONE);
 
-       lp->ns_disc_delay = DNS_DELAY;
+       lport->disc_delay = DNS_DELAY;
 
-       fc_lport_add_fc4_type(lp, FC_TYPE_FCP);
-       fc_lport_add_fc4_type(lp, FC_TYPE_CT);
+       fc_lport_add_fc4_type(lport, FC_TYPE_FCP);
+       fc_lport_add_fc4_type(lport, FC_TYPE_CT);
 
        return 0;
 }
 EXPORT_SYMBOL(fc_lport_config);
 
-int fc_lport_init(struct fc_lport *lp)
+int fc_lport_init(struct fc_lport *lport)
 {
-       if (!lp->tt.lport_recv)
-               lp->tt.lport_recv = fc_lport_recv;
-
-       if (!lp->tt.lport_login)
-               lp->tt.lport_login = fc_lport_enter_reset;
-
-       if (!lp->tt.lport_reset)
-               lp->tt.lport_reset = fc_lport_enter_reset;
-
-       if (!lp->tt.lport_logout)
-               lp->tt.lport_logout = fc_lport_logout;
+       if (!lport->tt.lport_recv)
+               lport->tt.lport_recv = fc_lport_recv_req;
+
+       if (!lport->tt.lport_reset)
+               lport->tt.lport_reset = fc_lport_reset;
+
+       if (!lport->tt.event_callback)
+               lport->tt.event_callback = fc_lport_rport_event;
+
+       fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
+       fc_host_node_name(lport->host) = lport->wwnn;
+       fc_host_port_name(lport->host) = lport->wwpn;
+       fc_host_supported_classes(lport->host) = FC_COS_CLASS3;
+       memset(fc_host_supported_fc4s(lport->host), 0,
+              sizeof(fc_host_supported_fc4s(lport->host)));
+       fc_host_supported_fc4s(lport->host)[2] = 1;
+       fc_host_supported_fc4s(lport->host)[7] = 1;
+
+       /* This value is also unchanging */
+       memset(fc_host_active_fc4s(lport->host), 0,
+              sizeof(fc_host_active_fc4s(lport->host)));
+       fc_host_active_fc4s(lport->host)[2] = 1;
+       fc_host_active_fc4s(lport->host)[7] = 1;
+       fc_host_maxframe_size(lport->host) = lport->mfs;
+       fc_host_supported_speeds(lport->host) = 0;
+       if (lport->link_supported_speeds & FC_PORTSPEED_1GBIT)
+               fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_1GBIT;
+       if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
+               fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
 
        return 0;
 }
diff --git a/drivers/scsi/libfc/fc_ns.c b/drivers/scsi/libfc/fc_ns.c
deleted file mode 100644
index 5c9272c..0000000
--- a/drivers/scsi/libfc/fc_ns.c
+++ /dev/null
@@ -1,1283 +0,0 @@
-/*
- * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Maintained at www.Open-FCoE.org
- */
-
-/*
- * Target Discovery
- * Actually, this discovers all FC-4 remote ports, including FCP initiators.
- */
-
-#include <linux/timer.h>
-#include <linux/err.h>
-#include <asm/unaligned.h>
-
-#include <scsi/fc/fc_gs.h>
-
-#include <scsi/libfc/libfc.h>
-
-#define FC_NS_RETRY_LIMIT      3       /* max retries */
-#define FC_NS_RETRY_DELAY      500UL   /* (msecs) delay */
-
-int fc_ns_debug;
-
-static void fc_ns_gpn_ft_req(struct fc_lport *);
-static void fc_ns_gpn_ft_resp(struct fc_seq *, struct fc_frame *, void *);
-static int fc_ns_new_target(struct fc_lport *, struct fc_rport *,
-                           struct fc_rport_identifiers *);
-static void fc_ns_del_target(struct fc_lport *, struct fc_rport *);
-static void fc_ns_disc_done(struct fc_lport *);
-static void fcdt_ns_error(struct fc_lport *, struct fc_frame *);
-static void fc_ns_timeout(struct work_struct *);
-
-/**
- * struct fc_ns_port - temporary discovery port to hold rport identifiers
- * @lp: Fibre Channel host port instance
- * @peers: node for list management during discovery and RSCN processing
- * @ids: identifiers structure to pass to fc_remote_port_add()
- */
-struct fc_ns_port {
-       struct fc_lport *lp;
-       struct list_head peers;
-       struct fc_rport_identifiers ids;
-};
-
-static int fc_ns_gpn_id_req(struct fc_lport *, struct fc_ns_port *);
-static void fc_ns_gpn_id_resp(struct fc_seq *, struct fc_frame *, void *);
-static void fc_ns_gpn_id_error(struct fc_ns_port *rp, struct fc_frame *fp);
-
-static int fc_ns_gnn_id_req(struct fc_lport *, struct fc_ns_port *);
-static void fc_ns_gnn_id_resp(struct fc_seq *, struct fc_frame *, void *);
-static void fc_ns_gnn_id_error(struct fc_ns_port *, struct fc_frame *);
-static void fc_ns_enter_reg_pn(struct fc_lport *lp);
-static void fc_ns_error(struct fc_lport *lp, struct fc_frame *fp);
-static void fc_lport_fill_dns_hdr(struct fc_lport *lp, struct fc_ct_hdr *ct,
-                                 unsigned int op, unsigned int req_size);
-static void fc_ns_resp(struct fc_seq *sp, struct fc_frame *fp,
-                      void *lp_arg);
-static void fc_ns_retry(struct fc_lport *lp);
-static void fc_ns_single(struct fc_lport *, struct fc_ns_port *);
-static int fc_ns_restart(struct fc_lport *);
-
-
-/**
- * fc_ns_rscn_req - Handle Registered State Change Notification (RSCN)
- * @sp: Current sequence of the RSCN exchange
- * @fp: RSCN Frame
- * @lp: Fibre Channel host port instance
- */
-static void fc_ns_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
-                          struct fc_lport *lp)
-{
-       struct fc_els_rscn *rp;
-       struct fc_els_rscn_page *pp;
-       struct fc_seq_els_data rjt_data;
-       unsigned int len;
-       int redisc = 0;
-       enum fc_els_rscn_ev_qual ev_qual;
-       enum fc_els_rscn_addr_fmt fmt;
-       LIST_HEAD(disc_list);
-       struct fc_ns_port *dp, *next;
-
-       rp = fc_frame_payload_get(fp, sizeof(*rp));
-
-       if (!rp || rp->rscn_page_len != sizeof(*pp))
-               goto reject;
-
-       len = ntohs(rp->rscn_plen);
-       if (len < sizeof(*rp))
-               goto reject;
-       len -= sizeof(*rp);
-
-       for (pp = (void *)(rp + 1); len; len -= sizeof(*pp), pp++) {
-               ev_qual = pp->rscn_page_flags >> ELS_RSCN_EV_QUAL_BIT;
-               ev_qual &= ELS_RSCN_EV_QUAL_MASK;
-               fmt = pp->rscn_page_flags >> ELS_RSCN_ADDR_FMT_BIT;
-               fmt &= ELS_RSCN_ADDR_FMT_MASK;
-               /*
-                * if we get an address format other than port
-                * (area, domain, fabric), then do a full discovery
-                */
-               switch (fmt) {
-               case ELS_ADDR_FMT_PORT:
-                       dp = kzalloc(sizeof(*dp), GFP_KERNEL);
-                       if (!dp) {
-                               redisc = 1;
-                               break;
-                       }
-                       dp->lp = lp;
-                       dp->ids.port_id = ntoh24(pp->rscn_fid);
-                       dp->ids.port_name = -1;
-                       dp->ids.node_name = -1;
-                       dp->ids.roles = FC_RPORT_ROLE_UNKNOWN;
-                       list_add_tail(&dp->peers, &disc_list);
-                       break;
-               case ELS_ADDR_FMT_AREA:
-               case ELS_ADDR_FMT_DOM:
-               case ELS_ADDR_FMT_FAB:
-               default:
-                       redisc = 1;
-                       break;
-               }
-       }
-       lp->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
-       if (redisc) {
-               if (fc_ns_debug)
-                       FC_DBG("RSCN received: rediscovering\n");
-               list_for_each_entry_safe(dp, next, &disc_list, peers) {
-                       list_del(&dp->peers);
-                       kfree(dp);
-               }
-               fc_ns_restart(lp);
-       } else {
-               if (fc_ns_debug)
-                       FC_DBG("RSCN received: not rediscovering. "
-                               "redisc %d state %d in_prog %d\n",
-                               redisc, lp->state, lp->ns_disc_pending);
-               list_for_each_entry_safe(dp, next, &disc_list, peers) {
-                       list_del(&dp->peers);
-                       fc_ns_single(lp, dp);
-               }
-       }
-       fc_frame_free(fp);
-       return;
-reject:
-       rjt_data.fp = NULL;
-       rjt_data.reason = ELS_RJT_LOGIC;
-       rjt_data.explan = ELS_EXPL_NONE;
-       lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
-       fc_frame_free(fp);
-}
-
-static void fc_ns_recv_req(struct fc_seq *sp, struct fc_frame *fp,
-                          struct fc_lport *lp)
-{
-       switch (fc_frame_payload_op(fp)) {
-       case ELS_RSCN:
-               fc_ns_rscn_req(sp, fp, lp);
-               break;
-       default:
-               FC_DBG("fc_ns recieved an unexpected request\n");
-               break;
-       }
-}
-
-/**
- * fc_ns_scr_resp - Handle response to State Change Register (SCR) request
- * @sp: current sequence in SCR exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel host port instance
- */
-static void fc_ns_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
-                          void *lp_arg)
-{
-       struct fc_lport *lp = lp_arg;
-       int err;
-
-       if (IS_ERR(fp))
-               fc_ns_error(lp, fp);
-       else {
-               fc_lport_lock(lp);
-               fc_lport_state_enter(lp, LPORT_ST_READY);
-               fc_lport_unlock(lp);
-               err = lp->tt.disc_start(lp);
-               if (err)
-                       FC_DBG("target discovery start error\n");
-               fc_frame_free(fp);
-       }
-}
-
-/**
- * fc_ns_enter scr - Send a State Change Register (SCR) request
- * @lp: Fibre Channel host port instance
- */
-static void fc_ns_enter_scr(struct fc_lport *lp)
-{
-       struct fc_frame *fp;
-       struct fc_els_scr *scr;
-
-       if (fc_ns_debug)
-               FC_DBG("Processing SCR state\n");
-
-       fc_lport_state_enter(lp, LPORT_ST_SCR);
-
-       fp = fc_frame_alloc(lp, sizeof(*scr));
-       if (fp) {
-               scr = fc_frame_payload_get(fp, sizeof(*scr));
-               memset(scr, 0, sizeof(*scr));
-               scr->scr_cmd = ELS_SCR;
-               scr->scr_reg_func = ELS_SCRF_FULL;
-       }
-       fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
-       fc_frame_set_offset(fp, 0);
-
-       lp->tt.exch_seq_send(lp, fp,
-                            fc_ns_scr_resp,
-                            lp, lp->e_d_tov,
-                            lp->fid, FC_FID_FCTRL,
-                            FC_FC_SEQ_INIT | FC_FC_END_SEQ);
-}
-
-/**
- * fc_ns_enter_reg_ft - Register FC4-types with the name server
- * @lp: Fibre Channel host port instance
- */
-static void fc_ns_enter_reg_ft(struct fc_lport *lp)
-{
-       struct fc_frame *fp;
-       struct req {
-               struct fc_ct_hdr ct;
-               struct fc_ns_fid fid;   /* port ID object */
-               struct fc_ns_fts fts;   /* FC4-types object */
-       } *req;
-       struct fc_ns_fts *lps;
-       int i;
-
-       if (fc_ns_debug)
-               FC_DBG("Processing REG_FT state\n");
-
-       fc_lport_state_enter(lp, LPORT_ST_REG_FT);
-
-       lps = &lp->fcts;
-       i = sizeof(lps->ff_type_map) / sizeof(lps->ff_type_map[0]);
-       while (--i >= 0)
-               if (ntohl(lps->ff_type_map[i]) != 0)
-                       break;
-       if (i >= 0) {
-               fp = fc_frame_alloc(lp, sizeof(*req));
-               if (fp) {
-                       req = fc_frame_payload_get(fp, sizeof(*req));
-                       fc_lport_fill_dns_hdr(lp, &req->ct,
-                                             FC_NS_RFT_ID,
-                                             sizeof(*req) -
-                                             sizeof(struct fc_ct_hdr));
-                       hton24(req->fid.fp_fid, lp->fid);
-                       req->fts = *lps;
-                       fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
-                       if (!lp->tt.exch_seq_send(lp, fp,
-                                                 fc_ns_resp, lp,
-                                                 lp->e_d_tov,
-                                                 lp->fid,
-                                                 lp->dns_rp->port_id,
-                                                 FC_FC_SEQ_INIT |
-                                                 FC_FC_END_SEQ))
-                               fc_ns_retry(lp);
-               } else {
-                       fc_ns_retry(lp);
-               }
-       } else {
-               fc_ns_enter_scr(lp);
-       }
-}
-
-/*
- * enter next state for handling an exchange reject or retry exhaustion
- * in the current state.
- */
-static void fc_ns_enter_reject(struct fc_lport *lp)
-{
-       switch (lp->state) {
-       case LPORT_ST_NONE:
-       case LPORT_ST_READY:
-       case LPORT_ST_RESET:
-       case LPORT_ST_FLOGI:
-       case LPORT_ST_LOGO:
-               WARN_ON(1);
-               break;
-       case LPORT_ST_REG_PN:
-               fc_ns_enter_reg_ft(lp);
-               break;
-       case LPORT_ST_REG_FT:
-               fc_ns_enter_scr(lp);
-               break;
-       case LPORT_ST_SCR:
-       case LPORT_ST_DNS_STOP:
-               lp->tt.disc_stop(lp);
-               break;
-       case LPORT_ST_DNS:
-               lp->tt.lport_reset(lp);
-               break;
-       }
-}
-
-static void fc_ns_enter_retry(struct fc_lport *lp)
-{
-       switch (lp->state) {
-       case LPORT_ST_NONE:
-       case LPORT_ST_RESET:
-       case LPORT_ST_READY:
-       case LPORT_ST_FLOGI:
-       case LPORT_ST_LOGO:
-               WARN_ON(1);
-               break;
-       case LPORT_ST_DNS:
-               lp->tt.dns_register(lp);
-               break;
-       case LPORT_ST_DNS_STOP:
-               lp->tt.disc_stop(lp);
-               break;
-       case LPORT_ST_REG_PN:
-               fc_ns_enter_reg_pn(lp);
-               break;
-       case LPORT_ST_REG_FT:
-               fc_ns_enter_reg_ft(lp);
-               break;
-       case LPORT_ST_SCR:
-               fc_ns_enter_scr(lp);
-               break;
-       }
-}
-
-/*
- * Refresh target discovery, perhaps due to an RSCN.
- * A configurable delay is introduced to collect any subsequent RSCNs.
- */
-static int fc_ns_restart(struct fc_lport *lp)
-{
-       fc_lport_lock(lp);
-       if (!lp->ns_disc_requested && !lp->ns_disc_pending) {
-               schedule_delayed_work(&lp->ns_disc_work,
-                               msecs_to_jiffies(lp->ns_disc_delay * 1000));
-       }
-       lp->ns_disc_requested = 1;
-       fc_lport_unlock(lp);
-       return 0;
-}
-
-/* unlocked varient of scsi_target_block from scsi_lib.c */
-#include "../scsi_priv.h"
-
-static void __device_block(struct scsi_device *sdev, void *data)
-{
-       scsi_internal_device_block(sdev);
-}
-
-static int __target_block(struct device *dev, void *data)
-{
-       if (scsi_is_target_device(dev))
-               __starget_for_each_device(to_scsi_target(dev),
-                                         NULL, __device_block);
-       return 0;
-}
-
-static void __scsi_target_block(struct device *dev)
-{
-       if (scsi_is_target_device(dev))
-               __starget_for_each_device(to_scsi_target(dev),
-                                         NULL, __device_block);
-       else
-               device_for_each_child(dev, NULL, __target_block);
-}
-
-static void fc_block_rports(struct fc_lport *lp)
-{
-       struct Scsi_Host *shost = lp->host;
-       struct fc_rport *rport;
-       unsigned long flags;
-
-       spin_lock_irqsave(shost->host_lock, flags);
-       list_for_each_entry(rport, &fc_host_rports(shost), peers) {
-               /* protect the name service remote port */
-               if (rport == lp->dns_rp)
-                       continue;
-               if (rport->port_state != FC_PORTSTATE_ONLINE)
-                       continue;
-               rport->port_state = FC_PORTSTATE_BLOCKED;
-               rport->flags |= FC_RPORT_DEVLOSS_PENDING;
-               __scsi_target_block(&rport->dev);
-       }
-       spin_unlock_irqrestore(shost->host_lock, flags);
-}
-
-/*
- * Fibre Channel Target discovery.
- *
- * Returns non-zero if discovery cannot be started.
- *
- * Callback is called for each target remote port found in discovery.
- * When discovery is complete, the callback is called with a NULL remote port.
- * Discovery may be restarted after an RSCN is received, causing the
- * callback to be called after discovery complete is indicated.
- */
-int fc_ns_disc_start(struct fc_lport *lp)
-{
-       struct fc_rport *rport;
-       int error;
-       struct fc_rport_identifiers ids;
-
-       fc_lport_lock(lp);
-
-       /*
-        * If not ready, or already running discovery, just set request flag.
-        */
-       if (!fc_lport_test_ready(lp) || lp->ns_disc_pending) {
-               lp->ns_disc_requested = 1;
-               fc_lport_unlock(lp);
-               return 0;
-       }
-       lp->ns_disc_pending = 1;
-       lp->ns_disc_requested = 0;
-       lp->ns_disc_retry_count = 0;
-
-       /*
-        * Handle point-to-point mode as a simple discovery
-        * of the remote port.
-        */
-       rport = lp->ptp_rp;
-       if (rport) {
-               ids.port_id = rport->port_id;
-               ids.port_name = rport->port_name;
-               ids.node_name = rport->node_name;
-               ids.roles = FC_RPORT_ROLE_UNKNOWN;
-               get_device(&rport->dev);
-               fc_lport_unlock(lp);
-               error = fc_ns_new_target(lp, rport, &ids);
-               put_device(&rport->dev);
-               if (!error)
-                       fc_ns_disc_done(lp);
-       } else {
-               fc_lport_unlock(lp);
-               fc_block_rports(lp);
-               fc_ns_gpn_ft_req(lp);   /* get ports by FC-4 type */
-               error = 0;
-       }
-       return error;
-}
-
-/*
- * Handle resource allocation problem by retrying in a bit.
- */
-static void fc_ns_retry(struct fc_lport *lp)
-{
-       if (lp->retry_count == 0)
-               FC_DBG("local port %6x alloc failure "
-                      "- will retry\n", lp->fid);
-       if (lp->retry_count < lp->max_retry_count) {
-               lp->retry_count++;
-               mod_timer(&lp->state_timer,
-                         jiffies + msecs_to_jiffies(lp->e_d_tov));
-       } else {
-               FC_DBG("local port %6x alloc failure "
-                      "- retries exhausted\n", lp->fid);
-               fc_ns_enter_reject(lp);
-       }
-}
-
-/*
- * Handle errors on local port requests.
- * Don't get locks if in RESET state.
- * The only possible errors so far are exchange TIMEOUT and CLOSED (reset).
- */
-static void fc_ns_error(struct fc_lport *lp, struct fc_frame *fp)
-{
-       if (lp->state == LPORT_ST_RESET)
-               return;
-
-       fc_lport_lock(lp);
-       if (PTR_ERR(fp) == -FC_EX_TIMEOUT) {
-               if (lp->retry_count < lp->max_retry_count) {
-                       lp->retry_count++;
-                       fc_ns_enter_retry(lp);
-               } else {
-                       fc_ns_enter_reject(lp);
-               }
-       }
-       if (fc_ns_debug)
-               FC_DBG("error %ld retries %d limit %d\n",
-                      PTR_ERR(fp), lp->retry_count, lp->max_retry_count);
-       fc_lport_unlock(lp);
-}
-
-/*
- * Restart discovery after a delay due to resource shortages.
- * If the error persists, the discovery will be abandoned.
- */
-static void fcdt_ns_retry(struct fc_lport *lp)
-{
-       unsigned long delay = FC_NS_RETRY_DELAY;
-
-       if (!lp->ns_disc_retry_count)
-               delay /= 4;     /* timeout faster first time */
-       if (lp->ns_disc_retry_count++ < FC_NS_RETRY_LIMIT)
-               schedule_delayed_work(&lp->ns_disc_work,
-                                     msecs_to_jiffies(delay));
-       else
-               fc_ns_disc_done(lp);
-}
-
-/*
- * Test for dNS accept in response payload.
- */
-static int fc_lport_dns_acc(struct fc_frame *fp)
-{
-       struct fc_frame_header *fh;
-       struct fc_ct_hdr *ct;
-       int rc = 0;
-
-       fh = fc_frame_header_get(fp);
-       ct = fc_frame_payload_get(fp, sizeof(*ct));
-       if (fh && ct && fh->fh_type == FC_TYPE_CT &&
-           ct->ct_fs_type == FC_FST_DIR &&
-           ct->ct_fs_subtype == FC_NS_SUBTYPE &&
-           ntohs(ct->ct_cmd) == FC_FS_ACC) {
-               rc = 1;
-       }
-       return rc;
-}
-
-/*
- * Handle response from name server.
- */
-static void
-fc_ns_resp(struct fc_seq *sp, struct fc_frame *fp, void *lp_arg)
-{
-       struct fc_lport *lp = lp_arg;
-
-       if (!IS_ERR(fp)) {
-               fc_lport_lock(lp);
-               del_timer(&lp->state_timer);
-               if (fc_lport_dns_acc(fp)) {
-                       if (lp->state == LPORT_ST_REG_PN)
-                               fc_ns_enter_reg_ft(lp);
-                       else
-                               fc_ns_enter_scr(lp);
-
-               } else {
-                       fc_ns_retry(lp);
-               }
-               fc_lport_unlock(lp);
-               fc_frame_free(fp);
-       } else
-               fc_ns_error(lp, fp);
-}
-
-/*
- * Handle new target found by discovery.
- * Create remote port and session if needed.
- * Ignore returns of our own FID & WWPN.
- *
- * If a non-NULL rp is passed in, it is held for the caller, but not for us.
- *
- * Events delivered are:
- *  FC_EV_READY, when remote port is rediscovered.
- */
-static int fc_ns_new_target(struct fc_lport *lp,
-                           struct fc_rport *rport,
-                           struct fc_rport_identifiers *ids)
-{
-       struct fc_rport_libfc_priv *rp;
-       int error = 0;
-
-       if (rport && ids->port_name) {
-               if (rport->port_name == -1) {
-                       /*
-                        * Set WWN and fall through to notify of create.
-                        */
-                       fc_rport_set_name(rport, ids->port_name,
-                                         rport->node_name);
-               } else if (rport->port_name != ids->port_name) {
-                       /*
-                        * This is a new port with the same FCID as
-                        * a previously-discovered port.  Presumably the old
-                        * port logged out and a new port logged in and was
-                        * assigned the same FCID.  This should be rare.
-                        * Delete the old one and fall thru to re-create.
-                        */
-                       fc_ns_del_target(lp, rport);
-                       rport = NULL;
-               }
-       }
-       if (((ids->port_name != -1) || (ids->port_id != -1)) &&
-           ids->port_id != lp->fid && ids->port_name != lp->wwpn) {
-               if (!rport) {
-                       rport = lp->tt.rport_lookup(lp, ids->port_id);
-                       if (rport == NULL)
-                               rport = lp->tt.rport_create(lp, ids);
-                       if (!rport)
-                               error = ENOMEM;
-               }
-               if (rport) {
-                       rp = rport->dd_data;
-                       rp->rp_state = RPORT_ST_INIT;
-                       lp->tt.rport_login(rport);
-               }
-       }
-       return error;
-}
-
-/*
- * Delete the remote port.
- */
-static void fc_ns_del_target(struct fc_lport *lp, struct fc_rport *rport)
-{
-       lp->tt.rport_reset(rport);
-       fc_remote_port_delete(rport);   /* release hold from create */
-}
-
-/*
- * Done with discovery
- */
-static void fc_ns_disc_done(struct fc_lport *lp)
-{
-       lp->ns_disc_done = 1;
-       lp->ns_disc_pending = 0;
-       if (lp->ns_disc_requested)
-               lp->tt.disc_start(lp);
-}
-
-/**
- * fc_ns_fill_dns_hdr - Fill in a name service request header
- * @lp: Fibre Channel host port instance
- * @ct: Common Transport (CT) header structure
- * @op: Name Service request code
- * @req_size: Full size of Name Service request
- */
-static void fc_ns_fill_dns_hdr(struct fc_lport *lp, struct fc_ct_hdr *ct,
-                              unsigned int op, unsigned int req_size)
-{
-       memset(ct, 0, sizeof(*ct) + req_size);
-       ct->ct_rev = FC_CT_REV;
-       ct->ct_fs_type = FC_FST_DIR;
-       ct->ct_fs_subtype = FC_NS_SUBTYPE;
-       ct->ct_cmd = htons((u16) op);
-}
-
-/**
- * fc_ns_gpn_ft_req - Send Get Port Names by FC-4 type (GPN_FT) request
- * @lp: Fibre Channel host port instance
- */
-static void fc_ns_gpn_ft_req(struct fc_lport *lp)
-{
-       struct fc_frame *fp;
-       struct fc_seq *sp = NULL;
-       struct req {
-               struct fc_ct_hdr ct;
-               struct fc_ns_gid_ft gid;
-       } *rp;
-       int error = 0;
-
-       lp->ns_disc_buf_len = 0;
-       lp->ns_disc_seq_count = 0;
-       fp = fc_frame_alloc(lp, sizeof(*rp));
-       if (fp == NULL) {
-               error = ENOMEM;
-       } else {
-               rp = fc_frame_payload_get(fp, sizeof(*rp));
-               fc_ns_fill_dns_hdr(lp, &rp->ct, FC_NS_GPN_FT, sizeof(rp->gid));
-               rp->gid.fn_fc4_type = FC_TYPE_FCP;
-
-               WARN_ON(!fc_lport_test_ready(lp));
-
-               fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
-               sp = lp->tt.exch_seq_send(lp, fp,
-                                         fc_ns_gpn_ft_resp,
-                                         lp, lp->e_d_tov,
-                                         lp->fid,
-                                         lp->dns_rp->port_id,
-                                         FC_FC_SEQ_INIT | FC_FC_END_SEQ);
-       }
-       if (error || sp == NULL)
-               fcdt_ns_retry(lp);
-}
-
-/*
- * Handle error on dNS request.
- */
-static void fcdt_ns_error(struct fc_lport *lp, struct fc_frame *fp)
-{
-       int err = PTR_ERR(fp);
-
-       switch (err) {
-       case -FC_EX_TIMEOUT:
-               if (lp->ns_disc_retry_count++ < FC_NS_RETRY_LIMIT) {
-                       fc_ns_gpn_ft_req(lp);
-               } else {
-                       FC_DBG("err %d - ending\n", err);
-                       fc_ns_disc_done(lp);
-               }
-               break;
-       default:
-               FC_DBG("err %d - ending\n", err);
-               fc_ns_disc_done(lp);
-               break;
-       }
-}
-
-/**
- * fc_ns_gpn_ft_parse - Parse the list of IDs and names resulting from a request
- * @lp: Fibre Channel host port instance
- * @buf: GPN_FT response buffer
- * @len: size of response buffer
- */
-static int fc_ns_gpn_ft_parse(struct fc_lport *lp, void *buf, size_t len)
-{
-       struct fc_gpn_ft_resp *np;
-       char *bp;
-       size_t plen;
-       size_t tlen;
-       int error = 0;
-       struct fc_ns_port *dp;
-
-       /*
-        * Handle partial name record left over from previous call.
-        */
-       bp = buf;
-       plen = len;
-       np = (struct fc_gpn_ft_resp *)bp;
-       tlen = lp->ns_disc_buf_len;
-       if (tlen) {
-               WARN_ON(tlen >= sizeof(*np));
-               plen = sizeof(*np) - tlen;
-               WARN_ON(plen <= 0);
-               WARN_ON(plen >= sizeof(*np));
-               if (plen > len)
-                       plen = len;
-               np = &lp->ns_disc_buf;
-               memcpy((char *)np + tlen, bp, plen);
-
-               /*
-                * Set bp so that the loop below will advance it to the
-                * first valid full name element.
-                */
-               bp -= tlen;
-               len += tlen;
-               plen += tlen;
-               lp->ns_disc_buf_len = (unsigned char) plen;
-               if (plen == sizeof(*np))
-                       lp->ns_disc_buf_len = 0;
-       }
-
-       /*
-        * Handle full name records, including the one filled from above.
-        * Normally, np == bp and plen == len, but from the partial case above,
-        * bp, len describe the overall buffer, and np, plen describe the
-        * partial buffer, which if would usually be full now.
-        * After the first time through the loop, things return to "normal".
-        */
-       while (plen >= sizeof(*np)) {
-               dp = kzalloc(sizeof(*dp), GFP_KERNEL);
-               if (!dp)
-                       break;
-               dp->lp = lp;
-               dp->ids.port_id = ntoh24(np->fp_fid);
-               dp->ids.port_name = ntohll(np->fp_wwpn);
-               dp->ids.node_name = -1;
-               dp->ids.roles = FC_RPORT_ROLE_UNKNOWN;
-               error = fc_ns_gnn_id_req(lp, dp);
-               if (error)
-                       break;
-               if (np->fp_flags & FC_NS_FID_LAST) {
-                       fc_ns_disc_done(lp);
-                       len = 0;
-                       break;
-               }
-               len -= sizeof(*np);
-               bp += sizeof(*np);
-               np = (struct fc_gpn_ft_resp *)bp;
-               plen = len;
-       }
-
-       /*
-        * Save any partial record at the end of the buffer for next time.
-        */
-       if (error == 0 && len > 0 && len < sizeof(*np)) {
-               if (np != &lp->ns_disc_buf)
-                       memcpy(&lp->ns_disc_buf, np, len);
-               lp->ns_disc_buf_len = (unsigned char) len;
-       } else {
-               lp->ns_disc_buf_len = 0;
-       }
-       return error;
-}
-
-/*
- * Handle retry of memory allocation for remote ports.
- */
-static void fc_ns_timeout(struct work_struct *work)
-{
-       struct fc_lport *lp;
-
-       lp = container_of(work, struct fc_lport, ns_disc_work.work);
-
-       if (lp->ns_disc_pending)
-               fc_ns_gpn_ft_req(lp);
-       else
-               lp->tt.disc_start(lp);
-}
-
-/**
- * fc_ns_gpn_ft_resp - Handle a response frame from Get Port Names (GPN_FT)
- * @sp: Current sequence of GPN_FT exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel host port instance
- *
- * The response may be in multiple frames
- */
-static void fc_ns_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp,
-                             void *lp_arg)
-{
-       struct fc_lport *lp = lp_arg;
-       struct fc_ct_hdr *cp;
-       struct fc_frame_header *fh;
-       unsigned int seq_cnt;
-       void *buf = NULL;
-       unsigned int len;
-       int error;
-
-       if (IS_ERR(fp)) {
-               fcdt_ns_error(lp, fp);
-               return;
-       }
-
-       WARN_ON(!fc_frame_is_linear(fp));       /* buffer must be contiguous */
-       fh = fc_frame_header_get(fp);
-       len = fr_len(fp) - sizeof(*fh);
-       seq_cnt = ntohs(fh->fh_seq_cnt);
-       if (fr_sof(fp) == FC_SOF_I3 && seq_cnt == 0 &&
-           lp->ns_disc_seq_count == 0) {
-               cp = fc_frame_payload_get(fp, sizeof(*cp));
-               if (cp == NULL) {
-                       FC_DBG("GPN_FT response too short, len %d\n",
-                              fr_len(fp));
-               } else if (ntohs(cp->ct_cmd) == FC_FS_ACC) {
-
-                       /*
-                        * Accepted.  Parse response.
-                        */
-                       buf = cp + 1;
-                       len -= sizeof(*cp);
-               } else if (ntohs(cp->ct_cmd) == FC_FS_RJT) {
-                       FC_DBG("GPN_FT rejected reason %x exp %x "
-                              "(check zoning)\n", cp->ct_reason,
-                              cp->ct_explan);
-                       fc_ns_disc_done(lp);
-               } else {
-                       FC_DBG("GPN_FT unexpected response code %x\n",
-                              ntohs(cp->ct_cmd));
-               }
-       } else if (fr_sof(fp) == FC_SOF_N3 &&
-                  seq_cnt == lp->ns_disc_seq_count) {
-               buf = fh + 1;
-       } else {
-               FC_DBG("GPN_FT unexpected frame - out of sequence? "
-                      "seq_cnt %x expected %x sof %x eof %x\n",
-                      seq_cnt, lp->ns_disc_seq_count, fr_sof(fp), fr_eof(fp));
-       }
-       if (buf) {
-               error = fc_ns_gpn_ft_parse(lp, buf, len);
-               if (error)
-                       fcdt_ns_retry(lp);
-               else
-                       lp->ns_disc_seq_count++;
-       }
-       fc_frame_free(fp);
-}
-
-/*
- * Discover the directory information for a single target.
- * This could be from an RSCN that reported a change for the target.
- */
-static void fc_ns_single(struct fc_lport *lp, struct fc_ns_port *dp)
-{
-       struct fc_rport *rport;
-
-       if (dp->ids.port_id == lp->fid)
-               goto out;
-
-       rport = lp->tt.rport_lookup(lp, dp->ids.port_id);
-       if (rport) {
-               fc_ns_del_target(lp, rport);
-               put_device(&rport->dev); /* hold from lookup */
-       }
-
-       if (fc_ns_gpn_id_req(lp, dp) != 0)
-               goto error;
-       return;
-error:
-       fc_ns_restart(lp);
-out:
-       kfree(dp);
-}
-
-/**
- * fc_ns_gpn_id_req - Send Get Port Name by ID (GPN_ID) request
- * @lp: Fibre Channel host port instance
- * @dp: Temporary discovery port for holding IDs and world wide names
- *
- * The remote port is held by the caller for us.
- */
-static int fc_ns_gpn_id_req(struct fc_lport *lp, struct fc_ns_port *dp)
-{
-       struct fc_frame *fp;
-       struct req {
-               struct fc_ct_hdr ct;
-               struct fc_ns_fid fid;
-       } *cp;
-       int error = 0;
-
-       fp = fc_frame_alloc(lp, sizeof(*cp));
-       if (fp == NULL)
-               return -ENOMEM;
-
-       cp = fc_frame_payload_get(fp, sizeof(*cp));
-       fc_ns_fill_dns_hdr(lp, &cp->ct, FC_NS_GPN_ID, sizeof(cp->fid));
-       hton24(cp->fid.fp_fid, dp->ids.port_id);
-
-       WARN_ON(!fc_lport_test_ready(lp));
-
-       fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                 fc_ns_gpn_id_resp,
-                                 dp, lp->e_d_tov,
-                                 lp->fid,
-                                 lp->dns_rp->port_id,
-                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               error = -ENOMEM;
-
-       return error;
-}
-
-/**
- * fc_ns_gpn_id_resp - Handle response to GPN_ID
- * @sp: Current sequence of GPN_ID exchange
- * @fp: response frame
- * @dp_arg: Temporary discovery port for holding IDs and world wide names
- */
-static void fc_ns_gpn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
-                             void *dp_arg)
-{
-       struct fc_ns_port *dp = dp_arg;
-       struct fc_lport *lp;
-       struct resp {
-               struct fc_ct_hdr ct;
-               __be64 wwn;
-       } *cp;
-       unsigned int cmd;
-
-       if (IS_ERR(fp)) {
-               fc_ns_gpn_id_error(dp, fp);
-               return;
-       }
-
-       lp = dp->lp;
-       WARN_ON(!fc_frame_is_linear(fp));       /* buffer must be contiguous */
-
-       cp = fc_frame_payload_get(fp, sizeof(cp->ct));
-       if (cp == NULL) {
-               FC_DBG("GPN_ID response too short, len %d\n", fr_len(fp));
-               return;
-       }
-       cmd = ntohs(cp->ct.ct_cmd);
-       switch (cmd) {
-       case FC_FS_ACC:
-               cp = fc_frame_payload_get(fp, sizeof(*cp));
-               if (cp == NULL) {
-                       FC_DBG("GPN_ID response payload too short, len %d\n",
-                              fr_len(fp));
-                       break;
-               }
-               dp->ids.port_name = ntohll(cp->wwn);
-               fc_ns_gnn_id_req(lp, dp);
-               break;
-       case FC_FS_RJT:
-               fc_ns_restart(lp);
-               break;
-       default:
-               FC_DBG("GPN_ID unexpected CT response cmd %x\n", cmd);
-               break;
-       }
-       fc_frame_free(fp);
-}
-
-/**
- * fc_ns_gpn_id_error - Handle error from GPN_ID
- * @dp: Temporary discovery port for holding IDs and world wide names
- * @fp: response frame
- */
-static void fc_ns_gpn_id_error(struct fc_ns_port *dp, struct fc_frame *fp)
-{
-       struct fc_lport *lp = dp->lp;
-
-       switch (PTR_ERR(fp)) {
-       case -FC_EX_TIMEOUT:
-               fc_ns_restart(lp);
-               break;
-       case -FC_EX_CLOSED:
-       default:
-               break;
-       }
-       kfree(dp);
-}
-
-/*
- * Setup session to dNS if not already set up.
- */
-static void fc_ns_enter_dns(struct fc_lport *lp)
-{
-       struct fc_rport *rport;
-       struct fc_rport_libfc_priv *rp;
-       struct fc_rport_identifiers ids = {
-               .port_id = FC_FID_DIR_SERV,
-               .port_name = -1,
-               .node_name = -1,
-               .roles = FC_RPORT_ROLE_UNKNOWN,
-       };
-
-       if (fc_ns_debug)
-               FC_DBG("Processing DNS state\n");
-
-       fc_lport_state_enter(lp, LPORT_ST_DNS);
-
-       if (!lp->dns_rp) {
-               /*
-                * Set up remote port to directory server.
-                */
-
-               /*
-                * we are called with the state_lock, but if rport_lookup_create
-                * needs to create a rport then it will sleep.
-                */
-               fc_lport_unlock(lp);
-               rport = lp->tt.rport_lookup(lp, ids.port_id);
-               if (rport == NULL)
-                       rport = lp->tt.rport_create(lp, &ids);
-               fc_lport_lock(lp);
-               if (!rport)
-                       goto err;
-               lp->dns_rp = rport;
-       }
-
-       rport = lp->dns_rp;
-       rp = rport->dd_data;
-
-       /*
-        * If dNS session isn't ready, start its logon.
-        */
-       if (rp->rp_state != RPORT_ST_READY) {
-               lp->tt.rport_login(rport);
-       } else {
-               del_timer(&lp->state_timer);
-               fc_ns_enter_reg_pn(lp);
-       }
-       return;
-
-       /*
-        * Resource allocation problem (malloc).  Try again in 500 mS.
-        */
-err:
-       fc_ns_retry(lp);
-}
-
-/*
- * Logoff DNS session.
- * We should get an event call when the session has been logged out.
- */
-static void fc_ns_enter_dns_stop(struct fc_lport *lp)
-{
-       struct fc_rport *rport = lp->dns_rp;
-
-       if (fc_ns_debug)
-               FC_DBG("Processing DNS_STOP state\n");
-
-       fc_lport_state_enter(lp, LPORT_ST_DNS_STOP);
-
-       if (rport)
-               lp->tt.rport_logout(rport);
-       else
-               lp->tt.lport_logout(lp);
-}
-
-/*
- * Fill in dNS request header.
- */
-static void
-fc_lport_fill_dns_hdr(struct fc_lport *lp, struct fc_ct_hdr *ct,
-                     unsigned int op, unsigned int req_size)
-{
-       memset(ct, 0, sizeof(*ct) + req_size);
-       ct->ct_rev = FC_CT_REV;
-       ct->ct_fs_type = FC_FST_DIR;
-       ct->ct_fs_subtype = FC_NS_SUBTYPE;
-       ct->ct_cmd = htons(op);
-}
-
-/*
- * Register port name with name server.
- */
-static void fc_ns_enter_reg_pn(struct fc_lport *lp)
-{
-       struct fc_frame *fp;
-       struct req {
-               struct fc_ct_hdr ct;
-               struct fc_ns_rn_id rn;
-       } *req;
-
-       if (fc_ns_debug)
-               FC_DBG("Processing REG_PN state\n");
-
-       fc_lport_state_enter(lp, LPORT_ST_REG_PN);
-       fp = fc_frame_alloc(lp, sizeof(*req));
-       if (!fp) {
-               fc_ns_retry(lp);
-               return;
-       }
-       req = fc_frame_payload_get(fp, sizeof(*req));
-       memset(req, 0, sizeof(*req));
-       fc_lport_fill_dns_hdr(lp, &req->ct, FC_NS_RPN_ID, sizeof(req->rn));
-       hton24(req->rn.fr_fid.fp_fid, lp->fid);
-       put_unaligned_be64(lp->wwpn, &req->rn.fr_wwn);
-       fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                 fc_ns_resp, lp,
-                                 lp->e_d_tov,
-                                 lp->fid,
-                                 lp->dns_rp->port_id,
-                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               fc_ns_retry(lp);
-}
-
-int fc_ns_init(struct fc_lport *lp)
-{
-       INIT_DELAYED_WORK(&lp->ns_disc_work, fc_ns_timeout);
-
-       if (!lp->tt.disc_start)
-               lp->tt.disc_start = fc_ns_disc_start;
-
-       if (!lp->tt.disc_recv_req)
-               lp->tt.disc_recv_req = fc_ns_recv_req;
-
-       if (!lp->tt.dns_register)
-               lp->tt.dns_register = fc_ns_enter_dns;
-
-       if (!lp->tt.disc_stop)
-               lp->tt.disc_stop = fc_ns_enter_dns_stop;
-
-       return 0;
-}
-EXPORT_SYMBOL(fc_ns_init);
-
-/**
- * fc_ns_gnn_id_req - Send Get Node Name by ID (GNN_ID) request
- * @lp: Fibre Channel host port instance
- * @dp: Temporary discovery port for holding IDs and world wide names
- *
- * The remote port is held by the caller for us.
- */
-static int fc_ns_gnn_id_req(struct fc_lport *lp, struct fc_ns_port *dp)
-{
-       struct fc_frame *fp;
-       struct req {
-               struct fc_ct_hdr ct;
-               struct fc_ns_fid fid;
-       } *cp;
-       int error = 0;
-
-       fp = fc_frame_alloc(lp, sizeof(*cp));
-       if (fp == NULL)
-               return -ENOMEM;
-
-       cp = fc_frame_payload_get(fp, sizeof(*cp));
-       fc_ns_fill_dns_hdr(lp, &cp->ct, FC_NS_GNN_ID, sizeof(cp->fid));
-       hton24(cp->fid.fp_fid, dp->ids.port_id);
-
-       WARN_ON(!fc_lport_test_ready(lp));
-
-       fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CTL, FC_TYPE_CT);
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                 fc_ns_gnn_id_resp,
-                                 dp, lp->e_d_tov,
-                                 lp->fid,
-                                 lp->dns_rp->port_id,
-                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               error = -ENOMEM;
-
-       return error;
-}
-
-/**
- * fc_ns_gnn_id_resp - Handle response to GNN_ID
- * @sp: Current sequence of GNN_ID exchange
- * @fp: response frame
- * @dp_arg: Temporary discovery port for holding IDs and world wide names
- */
-static void fc_ns_gnn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
-                             void *dp_arg)
-{
-       struct fc_ns_port *dp = dp_arg;
-       struct fc_lport *lp;
-       struct resp {
-               struct fc_ct_hdr ct;
-               __be64 wwn;
-       } *cp;
-       unsigned int cmd;
-
-       if (IS_ERR(fp)) {
-               fc_ns_gnn_id_error(dp, fp);
-               return;
-       }
-
-       lp = dp->lp;
-       WARN_ON(!fc_frame_is_linear(fp));       /* buffer must be contiguous */
-
-       cp = fc_frame_payload_get(fp, sizeof(cp->ct));
-       if (cp == NULL) {
-               FC_DBG("GNN_ID response too short, len %d\n", fr_len(fp));
-               return;
-       }
-       cmd = ntohs(cp->ct.ct_cmd);
-       switch (cmd) {
-       case FC_FS_ACC:
-               cp = fc_frame_payload_get(fp, sizeof(*cp));
-               if (cp == NULL) {
-                       FC_DBG("GNN_ID response payload too short, len %d\n",
-                              fr_len(fp));
-                       break;
-               }
-               dp->ids.node_name = ntohll(cp->wwn);
-               fc_ns_new_target(lp, NULL, &dp->ids);
-               break;
-       case FC_FS_RJT:
-               fc_ns_restart(lp);
-               break;
-       default:
-               FC_DBG("GNN_ID unexpected CT response cmd %x\n", cmd);
-               break;
-       }
-       kfree(dp);
-       fc_frame_free(fp);
-}
-
-/**
- * fc_ns_gnn_id_error - Handle error from GNN_ID
- * @dp: Temporary discovery port for holding IDs and world wide names
- * @fp: response frame
- */
-static void fc_ns_gnn_id_error(struct fc_ns_port *dp, struct fc_frame *fp)
-{
-       struct fc_lport *lp = dp->lp;
-
-       switch (PTR_ERR(fp)) {
-       case -FC_EX_TIMEOUT:
-               fc_ns_restart(lp);
-               break;
-       case -FC_EX_CLOSED:
-       default:
-               break;
-       }
-       kfree(dp);
-}
-
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index 6d0c970..107b304 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -36,14 +36,12 @@
 
 static int fc_rp_debug;
 
-/*
- * static functions.
- */
-static void fc_rport_enter_start(struct fc_rport *);
 static void fc_rport_enter_plogi(struct fc_rport *);
 static void fc_rport_enter_prli(struct fc_rport *);
 static void fc_rport_enter_rtv(struct fc_rport *);
+static void fc_rport_enter_ready(struct fc_rport *);
 static void fc_rport_enter_logo(struct fc_rport *);
+
 static void fc_rport_recv_plogi_req(struct fc_rport *,
                                    struct fc_seq *, struct fc_frame *);
 static void fc_rport_recv_prli_req(struct fc_rport *,
@@ -53,9 +51,69 @@ static void fc_rport_recv_prlo_req(struct fc_rport *,
 static void fc_rport_recv_logo_req(struct fc_rport *,
                                   struct fc_seq *, struct fc_frame *);
 static void fc_rport_timeout(struct work_struct *);
+static void fc_rport_error(struct fc_rport *, struct fc_frame *);
+
+static const char *fc_rport_state_names[] = {
+       [RPORT_ST_NONE] = "None",
+       [RPORT_ST_INIT] = "Init",
+       [RPORT_ST_PLOGI] = "PLOGI",
+       [RPORT_ST_PRLI] = "PRLI",
+       [RPORT_ST_RTV] = "RTV",
+       [RPORT_ST_READY] = "Ready",
+       [RPORT_ST_LOGO] = "LOGO",
+};
+
+struct fc_rport *fc_rport_dummy_create(struct fc_disc_port *dp)
+{
+       struct fc_rport *rport;
+       struct fc_rport_libfc_priv *rdata;
+       rport = kzalloc(sizeof(*rport) + sizeof(*rdata), GFP_KERNEL);
 
-static struct fc_rport *fc_remote_port_create(struct fc_lport *,
-                                             struct fc_rport_identifiers *);
+       if (!rport)
+               return NULL;
+
+       rdata = RPORT_TO_PRIV(rport);
+
+       rport->dd_data = rdata;
+       rport->port_id = dp->ids.port_id;
+       rport->port_name = dp->ids.port_name;
+       rport->node_name = dp->ids.node_name;
+       rport->roles = dp->ids.roles;
+       rport->maxframe_size = FC_MIN_MAX_PAYLOAD;
+
+       mutex_init(&rdata->rp_mutex);
+       rdata->local_port = dp->lp;
+       rdata->trans_state = FC_PORTSTATE_ROGUE;
+       rdata->rp_state = RPORT_ST_INIT;
+       rdata->event = LPORT_EV_RPORT_NONE;
+       rdata->flags = FC_RP_FLAGS_REC_SUPPORTED;
+       rdata->event_callback = NULL;
+       rdata->e_d_tov = dp->lp->e_d_tov;
+       rdata->r_a_tov = dp->lp->r_a_tov;
+       INIT_DELAYED_WORK(&rdata->retry_work, fc_rport_timeout);
+
+       return rport;
+}
+
+void fc_rport_dummy_destroy(struct fc_rport *rport)
+{
+       kfree(rport);
+}
+
+/**
+ * fc_rport_state - return a string for the state the rport is in
+ * @rport: The rport whose state we want to get a string for
+ */
+static const char *fc_rport_state(struct fc_rport *rport)
+{
+       const char *cp;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+
+       cp = fc_rport_state_names[rdata->rp_state];
+       if (!cp)
+               cp = "Unknown";
+       return cp;
+}
 
 /**
  * fc_rport_lookup - lookup a remote port by port_id
@@ -82,48 +140,18 @@ struct fc_rport *fc_rport_lookup(const struct fc_lport *lp, u32 fid)
 }
 
 /**
- * fc_remote_port_create - create a remote port
- * @lp: Fibre Channel host port instance
- * @ids: remote port identifiers (port_id, port_name, and node_name must be set)
+ * fc_set_rport_loss_tmo - Set the remote port loss timeout in seconds.
+ * @rport: Pointer to Fibre Channel remote port structure
+ * @timeout: timeout in seconds
  */
-static struct fc_rport *fc_remote_port_create(struct fc_lport *lp,
-                                             struct fc_rport_identifiers *ids)
+void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
 {
-       struct fc_rport_libfc_priv *rp;
-       struct fc_rport *rport;
-
-       rport = fc_remote_port_add(lp->host, 0, ids);
-       if (!rport)
-               return NULL;
-
-       rp = rport->dd_data;
-       rp->local_port = lp;
-
-       /* default value until service parameters are exchanged in PLOGI */
-       rport->maxframe_size = FC_MIN_MAX_PAYLOAD;
-
-       spin_lock_init(&rp->rp_lock);
-       rp->rp_state = RPORT_ST_INIT;
-       rp->local_port = lp;
-       rp->e_d_tov = lp->e_d_tov;
-       rp->r_a_tov = lp->r_a_tov;
-       rp->flags = FC_RP_FLAGS_REC_SUPPORTED;
-       INIT_DELAYED_WORK(&rp->retry_work, fc_rport_timeout);
-
-       return rport;
-}
-
-static inline void fc_rport_lock(struct fc_rport *rport)
-{
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       spin_lock_bh(&rp->rp_lock);
-}
-
-static inline void fc_rport_unlock(struct fc_rport *rport)
-{
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       spin_unlock_bh(&rp->rp_lock);
+       if (timeout)
+               rport->dev_loss_tmo = timeout + 5;
+       else
+               rport->dev_loss_tmo = 30;
 }
+EXPORT_SYMBOL(fc_set_rport_loss_tmo);
 
 /**
  * fc_plogi_get_maxframe - Get max payload from the common service parameters
@@ -150,12 +178,12 @@ fc_plogi_get_maxframe(struct fc_els_flogi *flp, unsigned int maxval)
 
 /**
  * fc_lport_plogi_fill - Fill in PLOGI command for request
- * @lp: Fibre Channel host port instance
+ * @lport: Fibre Channel host port instance
  * @plogi: PLOGI command structure to fill (same structure as FLOGI)
  * @op: either ELS_PLOGI for a localy generated request, or ELS_LS_ACC
  */
 static void
-fc_lport_plogi_fill(struct fc_lport *lp,
+fc_lport_plogi_fill(struct fc_lport *lport,
                    struct fc_els_flogi *plogi, unsigned int op)
 {
        struct fc_els_csp *sp;
@@ -163,266 +191,241 @@ fc_lport_plogi_fill(struct fc_lport *lp,
 
        memset(plogi, 0, sizeof(*plogi));
        plogi->fl_cmd = (u8) op;
-       put_unaligned_be64(lp->wwpn, &plogi->fl_wwpn);
-       put_unaligned_be64(lp->wwnn, &plogi->fl_wwnn);
+       put_unaligned_be64(lport->wwpn, &plogi->fl_wwpn);
+       put_unaligned_be64(lport->wwnn, &plogi->fl_wwnn);
 
        sp = &plogi->fl_csp;
        sp->sp_hi_ver = 0x20;
        sp->sp_lo_ver = 0x20;
        sp->sp_bb_cred = htons(10);     /* this gets set by gateway */
-       sp->sp_bb_data = htons((u16) lp->mfs);
+       sp->sp_bb_data = htons((u16) lport->mfs);
        cp = &plogi->fl_cssp[3 - 1];    /* class 3 parameters */
        cp->cp_class = htons(FC_CPC_VALID | FC_CPC_SEQ);
        if (op != ELS_FLOGI) {
                sp->sp_features = htons(FC_SP_FT_CIRO);
                sp->sp_tot_seq = htons(255);    /* seq. we accept */
                sp->sp_rel_off = htons(0x1f);
-               sp->sp_e_d_tov = htonl(lp->e_d_tov);
+               sp->sp_e_d_tov = htonl(lport->e_d_tov);
 
-               cp->cp_rdfs = htons((u16) lp->mfs);
+               cp->cp_rdfs = htons((u16) lport->mfs);
                cp->cp_con_seq = htons(255);
                cp->cp_open_seq = 1;
        }
 }
 
+/**
+ * fc_rport_state_enter - Change the rport's state
+ * @rport: The rport whose state should change
+ * @new: The new state of the rport
+ *
+ * Locking Note: Called with the rport lock held
+ */
 static void fc_rport_state_enter(struct fc_rport *rport,
                                 enum fc_rport_state new)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       if (rp->rp_state != new)
-               rp->retries = 0;
-       rp->rp_state = new;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       if (rdata->rp_state != new)
+               rdata->retries = 0;
+       rdata->rp_state = new;
+}
+
+static void fc_rport_unlock(struct fc_rport *rport)
+{
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       enum fc_lport_event event = rdata->event;
+       struct fc_lport *lport = rdata->local_port;
+       u32 fid = rport->port_id;
+       void (*event_callback)(struct fc_lport *, u32,
+                              enum fc_lport_event) =
+               rdata->event_callback;
+
+       if (event == LPORT_EV_RPORT_CREATED) {
+               struct fc_rport *new_rport;
+               struct fc_rport_libfc_priv *new_rdata;
+               struct fc_rport_identifiers ids;
+
+               ids.port_id = rport->port_id;
+               ids.roles = rport->roles;
+               ids.port_name = rport->port_name;
+               ids.node_name = rport->node_name;
+
+               new_rport = fc_remote_port_add(lport->host, 0, &ids);
+               if (new_rport) {
+                       /*
+                        * Switch from the dummy rport to the rport
+                        * returned by the FC class.
+                        */
+                       new_rport->maxframe_size = rport->maxframe_size;
+
+                       new_rdata = new_rport->dd_data;
+                       new_rdata->e_d_tov = rdata->e_d_tov;
+                       new_rdata->r_a_tov = rdata->r_a_tov;
+                       new_rdata->event_callback = rdata->event_callback;
+                       new_rdata->local_port = rdata->local_port;
+                       new_rdata->flags = FC_RP_FLAGS_REC_SUPPORTED;
+                       new_rdata->trans_state = FC_PORTSTATE_REAL;
+                       mutex_init(&new_rdata->rp_mutex);
+                       INIT_DELAYED_WORK(&new_rdata->retry_work,
+                                         fc_rport_timeout);
+
+                       fc_rport_state_enter(new_rport, RPORT_ST_READY);
+                       fc_remote_port_rolechg(new_rport, rdata->roles);
+               } else {
+                       FC_DBG("Failed to create the rport for port "
+                              "(%6x).\n", ids.port_id);
+                       event = LPORT_EV_RPORT_FAILED;
+               }
+
+               mutex_unlock(&rdata->rp_mutex);
+               fc_rport_dummy_destroy(rport);
+               rport = new_rport;
+               rdata = new_rport->dd_data;
+       } else if ((event == LPORT_EV_RPORT_FAILED) ||
+                  (event == LPORT_EV_RPORT_LOGO)) {
+               if (rdata->trans_state == FC_PORTSTATE_ROGUE) {
+                       mutex_unlock(&rdata->rp_mutex);
+                       fc_rport_dummy_destroy(rport);
+               } else {
+                       mutex_unlock(&rdata->rp_mutex);
+                       fc_remote_port_delete(rport);
+               }
+       } else {
+               mutex_unlock(&rdata->rp_mutex);
+       }
+
+       if (event != LPORT_EV_RPORT_NONE && event_callback) {
+               event_callback(lport, fid, event);
+               rdata->event = LPORT_EV_RPORT_NONE;
+       }
 }
 
 /**
  * fc_rport_login - Start the remote port login state machine
  * @rport: Fibre Channel remote port
+ *
+ * Locking Note: Called without the rport lock held. This
+ * function will hold the rport lock, call an _enter_*
+ * function and then unlock the rport.
  */
 int fc_rport_login(struct fc_rport *rport)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
 
-       fc_rport_lock(rport);
-       if (rp->rp_state == RPORT_ST_INIT) {
-               fc_rport_unlock(rport);
-               fc_rport_enter_start(rport);
-       } else if (rp->rp_state == RPORT_ST_ERROR) {
-               fc_rport_state_enter(rport, RPORT_ST_INIT);
-               fc_rport_unlock(rport);
-               if (fc_rp_debug)
-                       FC_DBG("remote %6x closed\n", rport->port_id);
-
-               if (rport == lp->dns_rp &&
-                   lp->state != LPORT_ST_RESET) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->dns_rp = NULL;
-
-                       if (lp->state == LPORT_ST_DNS_STOP) {
-                               fc_lport_unlock(lp);
-                               lp->tt.lport_logout(lp);
-                       } else {
-                               lp->tt.lport_login(lp);
-                               fc_lport_unlock(lp);
-                       }
-                       fc_remote_port_delete(rport);
-               }
-       } else
-               fc_rport_unlock(rport);
+       mutex_lock(&rdata->rp_mutex);
+
+       if (fc_rp_debug)
+               FC_DBG("Login to port (%6x)\n", rport->port_id);
+
+       fc_rport_enter_plogi(rport);
+
+       fc_rport_unlock(rport);
 
        return 0;
 }
 
-/*
- * Stop the session - log it off.
+/**
+ * fc_rport_logout - Logout of the remote port and delete it
+ * @rport: Fibre Channel remote port
+ *
+ * Locking Note: Called without the rport lock held. This
+ * function will hold the rport lock, call an _enter_*
+ * function and then unlock the rport.
  */
 int fc_rport_logout(struct fc_rport *rport)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
 
-       fc_rport_lock(rport);
-       switch (rp->rp_state) {
-       case RPORT_ST_PRLI:
-       case RPORT_ST_RTV:
-       case RPORT_ST_READY:
-               fc_rport_enter_logo(rport);
-               fc_rport_unlock(rport);
-               break;
-       default:
-               fc_rport_state_enter(rport, RPORT_ST_INIT);
-               fc_rport_unlock(rport);
-               if (fc_rp_debug)
-                       FC_DBG("remote %6x closed\n", rport->port_id);
-               if (rport == lp->dns_rp &&
-                   lp->state != LPORT_ST_RESET) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->dns_rp = NULL;
-
-                       if (lp->state == LPORT_ST_DNS_STOP) {
-                               fc_lport_unlock(lp);
-                               lp->tt.lport_logout(lp);
-                       } else {
-                               lp->tt.lport_login(lp);
-                               fc_lport_unlock(lp);
-                       }
+       mutex_lock(&rdata->rp_mutex);
 
-                       fc_remote_port_delete(rport);
-               }
-               break;
-       }
+       if (fc_rp_debug)
+               FC_DBG("Logout of port (%6x)\n", rport->port_id);
+
+       fc_rport_enter_logo(rport);
+       fc_rport_unlock(rport);
 
        return 0;
 }
 
-/*
- * Reset the session - assume it is logged off.         Used after fabric logoff.
- * The local port code takes care of resetting the exchange manager.
+/**
+ * fc_rport_reset - Reset the remote port
+ * @rport: Fibre Channel remote port
+ *
+ * XXX - This functionality is currently broken
+ *
+ * Locking Note: Called without the rport lock held. This
+ * function will hold the rport lock, call an _enter_*
+ * function and then unlock the rport.
  */
 void fc_rport_reset(struct fc_rport *rport)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+
+       mutex_lock(&rdata->rp_mutex);
 
        if (fc_rp_debug)
-               FC_DBG("sess to %6x reset\n", rport->port_id);
-       fc_rport_lock(rport);
+               FC_DBG("Reset port (%6x)\n", rport->port_id);
 
-       lp = rp->local_port;
-       fc_rport_state_enter(rport, RPORT_ST_INIT);
-       fc_rport_unlock(rport);
+       fc_rport_enter_plogi(rport);
 
-       if (fc_rp_debug)
-               FC_DBG("remote %6x closed\n", rport->port_id);
-       if (rport == lp->dns_rp &&
-           lp->state != LPORT_ST_RESET) {
-               fc_lport_lock(lp);
-               del_timer(&lp->state_timer);
-               lp->dns_rp = NULL;
-               if (lp->state == LPORT_ST_DNS_STOP) {
-                       fc_lport_unlock(lp);
-                       lp->tt.lport_logout(lp);
-               } else {
-                       lp->tt.lport_login(lp);
-                       fc_lport_unlock(lp);
-               }
-               fc_remote_port_delete(rport);
-       }
+       fc_rport_unlock(rport);
 }
 
-/*
- * Reset all sessions for a local port session list.
+/**
+ * fc_rport_reset_list - Reset all sessions for a local port session list.
+ * @lport: The lport whose rports should be reset
+ *
+ * Locking Note: TBD
  */
-void fc_rport_reset_list(struct fc_lport *lp)
+void fc_rport_reset_list(struct fc_lport *lport)
 {
-       struct Scsi_Host *shost = lp->host;
+       struct Scsi_Host *shost = lport->host;
        struct fc_rport *rport;
        struct fc_rport *next;
        unsigned long flags;
 
        spin_lock_irqsave(shost->host_lock, flags);
        list_for_each_entry_safe(rport, next, &fc_host_rports(shost), peers) {
-               lp->tt.rport_reset(rport);
+               lport->tt.rport_reset(rport);
        }
        spin_unlock_irqrestore(shost->host_lock, flags);
 }
 
-static void fc_rport_enter_start(struct fc_rport *rport)
+/**
+ * fc_rport_enter_ready - The rport is ready
+ * @rport: Fibre Channel remote port that is ready
+ *
+ * Locking Note: The rport lock is expected to be held before calling
+ * this routine.
+ */
+static void fc_rport_enter_ready(struct fc_rport *rport)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
 
-       /*
-        * If the local port is already logged on, advance to next state.
-        * Otherwise the local port will be logged on by fc_rport_unlock().
-        */
-       fc_rport_state_enter(rport, RPORT_ST_STARTED);
+       fc_rport_state_enter(rport, RPORT_ST_READY);
 
-       if (rport == lp->dns_rp || fc_lport_test_ready(lp))
-               fc_rport_enter_plogi(rport);
-}
+       if (fc_rp_debug)
+               FC_DBG("Port (%6x) is Ready\n", rport->port_id);
 
-/*
- * Handle exchange reject or retry exhaustion in various states.
- */
-static void fc_rport_reject(struct fc_rport *rport)
-{
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
-       switch (rp->rp_state) {
-       case RPORT_ST_PLOGI:
-       case RPORT_ST_PRLI:
-               fc_rport_state_enter(rport, RPORT_ST_ERROR);
-               if (rport == lp->dns_rp &&
-                   lp->state != LPORT_ST_RESET) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->dns_rp = NULL;
-                       if (lp->state == LPORT_ST_DNS_STOP) {
-                               fc_lport_unlock(lp);
-                               lp->tt.lport_logout(lp);
-                       } else {
-                               lp->tt.lport_login(lp);
-                               fc_lport_unlock(lp);
-                       }
-                       fc_remote_port_delete(rport);
-               }
-               break;
-       case RPORT_ST_RTV:
-               fc_rport_state_enter(rport, RPORT_ST_READY);
-               if (fc_rp_debug)
-                       FC_DBG("remote %6x ready\n", rport->port_id);
-               if (rport == lp->dns_rp &&
-                   lp->state == LPORT_ST_DNS) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->tt.dns_register(lp);
-                       fc_lport_unlock(lp);
-               }
-               break;
-       case RPORT_ST_LOGO:
-               fc_rport_state_enter(rport, RPORT_ST_INIT);
-               if (fc_rp_debug)
-                       FC_DBG("remote %6x closed\n", rport->port_id);
-               if (rport == lp->dns_rp &&
-                   lp->state != LPORT_ST_RESET) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->dns_rp = NULL;
-                       if (lp->state == LPORT_ST_DNS_STOP) {
-                               fc_lport_unlock(lp);
-                               lp->tt.lport_logout(lp);
-                       } else {
-                               lp->tt.lport_login(lp);
-                               fc_lport_unlock(lp);
-                       }
-                       fc_remote_port_delete(rport);
-               }
-               break;
-       case RPORT_ST_NONE:
-       case RPORT_ST_READY:
-       case RPORT_ST_ERROR:
-       case RPORT_ST_PLOGI_RECV:
-       case RPORT_ST_STARTED:
-       case RPORT_ST_INIT:
-               BUG();
-               break;
-       }
-       return;
+       rdata->event = LPORT_EV_RPORT_CREATED;
 }
 
-/*
- * Timeout handler for retrying after allocation failures or exchange timeout.
+/**
+ * fc_rport_timeout - Handler for the retry_work timer.
+ * @work: The work struct of the fc_rport_libfc_priv
+ *
+ * Locking Note: Called without the rport lock held. This
+ * function will hold the rport lock, call an _enter_*
+ * function and then unlock the rport.
  */
 static void fc_rport_timeout(struct work_struct *work)
 {
-       struct fc_rport_libfc_priv *rp =
+       struct fc_rport_libfc_priv *rdata =
                container_of(work, struct fc_rport_libfc_priv, retry_work.work);
-       struct fc_rport *rport = (((void *)rp) - sizeof(struct fc_rport));
+       struct fc_rport *rport = PRIV_TO_RPORT(rdata);
 
-       switch (rp->rp_state) {
+       mutex_lock(&rdata->rp_mutex);
+
+       switch (rdata->rp_state) {
        case RPORT_ST_PLOGI:
                fc_rport_enter_plogi(rport);
                break;
@@ -436,149 +439,178 @@ static void fc_rport_timeout(struct work_struct *work)
                fc_rport_enter_logo(rport);
                break;
        case RPORT_ST_READY:
-       case RPORT_ST_ERROR:
        case RPORT_ST_INIT:
                break;
        case RPORT_ST_NONE:
-       case RPORT_ST_PLOGI_RECV:
-       case RPORT_ST_STARTED:
                BUG();
                break;
        }
        put_device(&rport->dev);
-}
-
-/*
- * Handle retry for allocation failure via timeout.
- */
-static void fc_rport_retry(struct fc_rport *rport)
-{
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
 
-       if (rp->retries < lp->max_retry_count) {
-               rp->retries++;
-               get_device(&rport->dev);
-               schedule_delayed_work(&rp->retry_work,
-                                     msecs_to_jiffies(rp->e_d_tov));
-       } else {
-               FC_DBG("sess %6x alloc failure in state %d, "
-                      "retries exhausted\n",
-                      rport->port_id, rp->rp_state);
-               fc_rport_reject(rport);
-       }
+       fc_rport_unlock(rport);
 }
 
-/*
- * Handle error from a sequence issued by the rport state machine.
+/**
+ * fc_rport_error - Handler for any errors
+ * @rport: The fc_rport object
+ * @fp: The frame pointer
+ *
+ * If the error was caused by a resource allocation failure
+ * then wait for half a second and retry, otherwise retry
+ * immediately.
+ *
+ * Locking Note: The rport lock is expected to be held before
+ * calling this routine
  */
 static void fc_rport_error(struct fc_rport *rport, struct fc_frame *fp)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       fc_rport_lock(rport);
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       unsigned long delay = 0;
+
        if (fc_rp_debug)
-               FC_DBG("state %d error %ld retries %d\n",
-                      rp->rp_state, PTR_ERR(fp), rp->retries);
+               FC_DBG("Error %ld in state %s, retries %d\n",
+                      PTR_ERR(fp), fc_rport_state(rport), rdata->retries);
 
-       if (PTR_ERR(fp) == -FC_EX_TIMEOUT &&
-           rp->retries++ >= rp->local_port->max_retry_count) {
+       if (rdata->retries < rdata->local_port->max_retry_count) {
+               rdata->retries++;
+               if (!fp)
+                       delay = msecs_to_jiffies(500);
                get_device(&rport->dev);
-               schedule_delayed_work(&rp->retry_work, 0);
-       } else
-               fc_rport_reject(rport);
+               schedule_delayed_work(&rdata->retry_work, delay);
+       } else {
+               switch (rdata->rp_state) {
+               case RPORT_ST_PLOGI:
+               case RPORT_ST_PRLI:
+               case RPORT_ST_LOGO:
+                       if (fc_rp_debug)
+                               FC_DBG("Remote port (%6x) closed.\n",
+                                      rport->port_id);
 
-       fc_rport_unlock(rport);
+                       fc_remote_port_delete(rport);
+
+                       rdata->event = LPORT_EV_RPORT_FAILED;
+                       break;
+               case RPORT_ST_RTV:
+                       fc_rport_enter_ready(rport);
+                       break;
+               case RPORT_ST_NONE:
+               case RPORT_ST_READY:
+               case RPORT_ST_INIT:
+                       BUG();
+                       break;
+               }
+       }
 }
 
 /**
- * fc_rport_plpogi_recv_resp - Handle incoming ELS PLOGI response
+ * fc_rport_plogi_recv_resp - Handle incoming ELS PLOGI response
  * @sp: current sequence in the PLOGI exchange
  * @fp: response frame
  * @rp_arg: Fibre Channel remote port
+ *
+ * Locking Note: This function will be called without the rport lock
+ * held, but it will lock, call an _enter_* function or fc_rport_error
+ * and then unlock the rport.
  */
 static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                                void *rp_arg)
 {
-       struct fc_els_ls_rjt *rjp;
+       struct fc_rport *rport = rp_arg;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
        struct fc_els_flogi *plp;
-       u64 wwpn, wwnn;
        unsigned int tov;
        u16 csp_seq;
        u16 cssp_seq;
        u8 op;
-       struct fc_rport *rport = rp_arg;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
 
-       if (!IS_ERR(fp)) {
-               op = fc_frame_payload_op(fp);
-               fc_rport_lock(rport);
-               if (op == ELS_LS_ACC &&
-                   (plp = fc_frame_payload_get(fp, sizeof(*plp))) != NULL) {
-                       wwpn = get_unaligned_be64(&plp->fl_wwpn);
-                       wwnn = get_unaligned_be64(&plp->fl_wwnn);
+       mutex_lock(&rdata->rp_mutex);
 
-                       fc_rport_set_name(rport, wwpn, wwnn);
-                       tov = ntohl(plp->fl_csp.sp_e_d_tov);
-                       if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
-                               tov /= 1000;
-                       if (tov > rp->e_d_tov)
-                               rp->e_d_tov = tov;
-                       csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
-                       cssp_seq = ntohs(plp->fl_cssp[3 - 1].cp_con_seq);
-                       if (cssp_seq < csp_seq)
-                               csp_seq = cssp_seq;
-                       rp->max_seq = csp_seq;
-                       rport->maxframe_size =
-                               fc_plogi_get_maxframe(plp, rp->local_port->mfs);
-                       if (rp->rp_state == RPORT_ST_PLOGI)
-                               fc_rport_enter_prli(rport);
-               } else {
-                       if (fc_rp_debug)
-                               FC_DBG("bad PLOGI response\n");
-
-                       rjp = fc_frame_payload_get(fp, sizeof(*rjp));
-                       if (op == ELS_LS_RJT && rjp != NULL &&
-                           rjp->er_reason == ELS_RJT_INPROG)
-                               fc_rport_retry(rport);    /* try again */
-                       else
-                               fc_rport_reject(rport);   /* error */
-               }
-               fc_rport_unlock(rport);
-               fc_frame_free(fp);
-       } else {
+       if (fc_rp_debug)
+               FC_DBG("Received a PLOGI response\n");
+
+       if (rdata->rp_state != RPORT_ST_PLOGI) {
+               FC_DBG("Received a PLOGI response, but in state %s\n",
+                      fc_rport_state(rport));
+               goto out;
+       }
+
+       if (IS_ERR(fp)) {
                fc_rport_error(rport, fp);
+               goto out;
        }
+
+       op = fc_frame_payload_op(fp);
+       if (op == ELS_LS_ACC &&
+           (plp = fc_frame_payload_get(fp, sizeof(*plp))) != NULL) {
+               tov = ntohl(plp->fl_csp.sp_e_d_tov);
+               if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
+                       tov /= 1000;
+               if (tov > rdata->e_d_tov)
+                       rdata->e_d_tov = tov;
+               csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
+               cssp_seq = ntohs(plp->fl_cssp[3 - 1].cp_con_seq);
+               if (cssp_seq < csp_seq)
+                       csp_seq = cssp_seq;
+               rdata->max_seq = csp_seq;
+               rport->maxframe_size =
+                       fc_plogi_get_maxframe(plp, lport->mfs);
+
+               /*
+                * If the rport is one of the well known addresses
+                * we skip PRLI and RTV and go straight to READY.
+                */
+               if (rport->port_id >= FC_FID_DOM_MGR)
+                       fc_rport_enter_ready(rport);
+               else
+                       fc_rport_enter_prli(rport);
+       } else
+               fc_rport_error(rport, fp);
+
+out:
+       fc_rport_unlock(rport);
+       fc_frame_free(fp);
 }
 
 /**
  * fc_rport_enter_plogi - Send Port Login (PLOGI) request to peer
  * @rport: Fibre Channel remote port to send PLOGI to
+ *
+ * Locking Note: The rport lock is expected to be held before calling
+ * this routine.
  */
 static void fc_rport_enter_plogi(struct fc_rport *rport)
 {
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
        struct fc_frame *fp;
        struct fc_els_flogi *plogi;
-       struct fc_lport *lp;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
 
-       lp = rp->local_port;
+       if (fc_rp_debug)
+               FC_DBG("Port (%6x) entered PLOGI state from %s state\n",
+                      rport->port_id, fc_rport_state(rport));
+
        fc_rport_state_enter(rport, RPORT_ST_PLOGI);
+
        rport->maxframe_size = FC_MIN_MAX_PAYLOAD;
-       fp = fc_frame_alloc(lp, sizeof(*plogi));
-       if (!fp)
-               return fc_rport_retry(rport);
+       fp = fc_frame_alloc(lport, sizeof(*plogi));
+       if (!fp) {
+               fc_rport_error(rport, fp);
+               return;
+       }
+
        plogi = fc_frame_payload_get(fp, sizeof(*plogi));
-       WARN_ON(!plogi);
-       fc_lport_plogi_fill(rp->local_port, plogi, ELS_PLOGI);
-       rp->e_d_tov = lp->e_d_tov;
+       fc_lport_plogi_fill(rdata->local_port, plogi, ELS_PLOGI);
+       rdata->e_d_tov = lport->e_d_tov;
        fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                 fc_rport_plogi_resp,
-                                 rport, lp->e_d_tov,
-                                 rp->local_port->fid,
-                                 rport->port_id,
-                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               fc_rport_retry(rport);
+
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_rport_plogi_resp, NULL,
+                                    rport, lport->e_d_tov,
+                                    rdata->local_port->fid,
+                                    rport->port_id,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_rport_error(rport, fp);
 }
 
 /**
@@ -586,13 +618,16 @@ static void fc_rport_enter_plogi(struct fc_rport *rport)
  * @sp: current sequence in the PRLI exchange
  * @fp: response frame
  * @rp_arg: Fibre Channel remote port
+ *
+ * Locking Note: This function will be called without the rport lock
+ * held, but it will lock, call an _enter_* function or fc_rport_error
+ * and then unlock the rport.
  */
 static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
                               void *rp_arg)
 {
        struct fc_rport *rport = rp_arg;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
        struct {
                struct fc_els_prli prli;
                struct fc_els_spp spp;
@@ -601,19 +636,29 @@ static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
        u32 fcp_parm = 0;
        u8 op;
 
+       mutex_lock(&rdata->rp_mutex);
+
+       if (fc_rp_debug)
+               FC_DBG("Received a PRLI response\n");
+
+       if (rdata->rp_state != RPORT_ST_PRLI) {
+               FC_DBG("Received a PRLI response, but in state %s\n",
+                      fc_rport_state(rport));
+               goto out;
+       }
+
        if (IS_ERR(fp)) {
                fc_rport_error(rport, fp);
-               return;
+               goto out;
        }
 
-       fc_rport_lock(rport);
        op = fc_frame_payload_op(fp);
        if (op == ELS_LS_ACC) {
                pp = fc_frame_payload_get(fp, sizeof(*pp));
                if (pp && pp->prli.prli_spp_len >= sizeof(pp->spp)) {
                        fcp_parm = ntohl(pp->spp.spp_params);
                        if (fcp_parm & FCP_SPPF_RETRY)
-                               rp->flags |= FC_RP_FLAGS_RETRY;
+                               rdata->flags |= FC_RP_FLAGS_RETRY;
                }
 
                rport->supported_classes = FC_COS_CLASS3;
@@ -622,28 +667,17 @@ static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
                if (fcp_parm & FCP_SPPF_TARG_FCN)
                        roles |= FC_RPORT_ROLE_FCP_TARGET;
 
+               rdata->roles = roles;
                fc_rport_enter_rtv(rport);
-               fc_rport_unlock(rport);
-               fc_remote_port_rolechg(rport, roles);
+
        } else {
-               FC_DBG("bad ELS response\n");
-               fc_rport_state_enter(rport, RPORT_ST_ERROR);
-               fc_rport_unlock(rport);
-               if (rport == lp->dns_rp && lp->state != LPORT_ST_RESET) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->dns_rp = NULL;
-                       if (lp->state == LPORT_ST_DNS_STOP) {
-                               fc_lport_unlock(lp);
-                               lp->tt.lport_logout(lp);
-                       } else {
-                               lp->tt.lport_login(lp);
-                               fc_lport_unlock(lp);
-                       }
-                       fc_remote_port_delete(rport);
-               }
+               FC_DBG("Bad ELS response\n");
+               rdata->event = LPORT_EV_RPORT_FAILED;
+               fc_remote_port_delete(rport);
        }
 
+out:
+       fc_rport_unlock(rport);
        fc_frame_free(fp);
 }
 
@@ -652,101 +686,94 @@ static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
  * @sp: current sequence in the LOGO exchange
  * @fp: response frame
  * @rp_arg: Fibre Channel remote port
+ *
+ * Locking Note: This function will be called without the rport lock
+ * held, but it will lock, call an _enter_* function or fc_rport_error
+ * and then unlock the rport.
  */
 static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
                               void *rp_arg)
 {
        struct fc_rport *rport = rp_arg;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
        u8 op;
 
+       mutex_lock(&rdata->rp_mutex);
+
+       if (fc_rp_debug)
+               FC_DBG("Received a LOGO response\n");
+
+       if (rdata->rp_state != RPORT_ST_LOGO) {
+               FC_DBG("Received a LOGO response, but in state %s\n",
+                      fc_rport_state(rport));
+               goto out;
+       }
+
        if (IS_ERR(fp)) {
                fc_rport_error(rport, fp);
-               return;
+               goto out;
        }
 
-       fc_rport_lock(rport);
        op = fc_frame_payload_op(fp);
        if (op == ELS_LS_ACC) {
                fc_rport_enter_rtv(rport);
-               fc_rport_unlock(rport);
+
        } else {
-               FC_DBG("bad ELS response\n");
-               fc_rport_state_enter(rport, RPORT_ST_ERROR);
-               fc_rport_unlock(rport);
-               if (rport == lp->dns_rp && lp->state != LPORT_ST_RESET) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->dns_rp = NULL;
-                       if (lp->state == LPORT_ST_DNS_STOP) {
-                               fc_lport_unlock(lp);
-                               lp->tt.lport_logout(lp);
-                       } else {
-                               lp->tt.lport_login(lp);
-                               fc_lport_unlock(lp);
-                       }
-                       fc_remote_port_delete(rport);
-               }
+               FC_DBG("Bad ELS response\n");
+               rdata->event = LPORT_EV_RPORT_LOGO;
+               fc_remote_port_delete(rport);
        }
 
+out:
+       fc_rport_unlock(rport);
        fc_frame_free(fp);
 }
 
 /**
  * fc_rport_enter_prli - Send Process Login (PRLI) request to peer
  * @rport: Fibre Channel remote port to send PRLI to
+ *
+ * Locking Note: The rport lock is expected to be held before calling
+ * this routine.
  */
 static void fc_rport_enter_prli(struct fc_rport *rport)
 {
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
        struct {
                struct fc_els_prli prli;
                struct fc_els_spp spp;
        } *pp;
        struct fc_frame *fp;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+
+       if (fc_rp_debug)
+               FC_DBG("Port (%6x) entered PRLI state from %s state\n",
+                      rport->port_id, fc_rport_state(rport));
 
        fc_rport_state_enter(rport, RPORT_ST_PRLI);
 
-       /*
-        * Special case if session is for name server or any other
-        * well-known address:  Skip the PRLI step.
-        * This should be made more general, possibly moved to the FCP layer.
-        */
-       if (rport->port_id >= FC_FID_DOM_MGR) {
-               fc_rport_state_enter(rport, RPORT_ST_READY);
-               if (fc_rp_debug)
-                       FC_DBG("remote %6x ready\n", rport->port_id);
-               if (rport == lp->dns_rp &&
-                   lp->state == LPORT_ST_DNS) {
-                       fc_lport_lock(lp);
-                       del_timer(&lp->state_timer);
-                       lp->tt.dns_register(lp);
-                       fc_lport_unlock(lp);
-               }
+       fp = fc_frame_alloc(lport, sizeof(*pp));
+       if (!fp) {
+               fc_rport_error(rport, fp);
                return;
        }
-       fp = fc_frame_alloc(lp, sizeof(*pp));
-       if (!fp)
-               return fc_rport_retry(rport);
+
        pp = fc_frame_payload_get(fp, sizeof(*pp));
-       WARN_ON(!pp);
        memset(pp, 0, sizeof(*pp));
        pp->prli.prli_cmd = ELS_PRLI;
        pp->prli.prli_spp_len = sizeof(struct fc_els_spp);
        pp->prli.prli_len = htons(sizeof(*pp));
        pp->spp.spp_type = FC_TYPE_FCP;
        pp->spp.spp_flags = FC_SPP_EST_IMG_PAIR;
-       pp->spp.spp_params = htonl(rp->local_port->service_params);
+       pp->spp.spp_params = htonl(lport->service_params);
        fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                 fc_rport_prli_resp,
-                                 rport, lp->e_d_tov,
-                                 rp->local_port->fid,
-                                 rport->port_id,
-                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               fc_rport_retry(rport);
+
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_rport_prli_resp, NULL,
+                                    rport, lport->e_d_tov,
+                                    lport->fid, rport->port_id,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_rport_error(rport, fp);
 }
 
 /**
@@ -756,21 +783,34 @@ static void fc_rport_enter_prli(struct fc_rport *rport)
  * @rp_arg: Fibre Channel remote port
  *
  * Many targets don't seem to support this.
+ *
+ * Locking Note: This function will be called without the rport lock
+ * held, but it will lock, call an _enter_* function or fc_rport_error
+ * and then unlock the rport.
  */
 static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
                              void *rp_arg)
 {
        struct fc_rport *rport = rp_arg;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
        u8 op;
 
+       mutex_lock(&rdata->rp_mutex);
+
+       if (fc_rp_debug)
+               FC_DBG("Received a RTV response\n");
+
+       if (rdata->rp_state != RPORT_ST_RTV) {
+               FC_DBG("Received a RTV response, but in state %s\n",
+                      fc_rport_state(rport));
+               goto out;
+       }
+
        if (IS_ERR(fp)) {
                fc_rport_error(rport, fp);
-               return;
+               goto out;
        }
 
-       fc_rport_lock(rport);
        op = fc_frame_payload_op(fp);
        if (op == ELS_LS_ACC) {
                struct fc_els_rtv_acc *rtv;
@@ -783,107 +823,126 @@ static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
                        tov = ntohl(rtv->rtv_r_a_tov);
                        if (tov == 0)
                                tov = 1;
-                       rp->r_a_tov = tov;
+                       rdata->r_a_tov = tov;
                        tov = ntohl(rtv->rtv_e_d_tov);
                        if (toq & FC_ELS_RTV_EDRES)
                                tov /= 1000000;
                        if (tov == 0)
                                tov = 1;
-                       rp->e_d_tov = tov;
+                       rdata->e_d_tov = tov;
                }
        }
-       fc_rport_state_enter(rport, RPORT_ST_READY);
+
+       fc_rport_enter_ready(rport);
+
+out:
        fc_rport_unlock(rport);
-       if (fc_rp_debug)
-               FC_DBG("remote %6x ready\n", rport->port_id);
-       if (rport == lp->dns_rp &&
-           lp->state == LPORT_ST_DNS) {
-               fc_lport_lock(lp);
-               del_timer(&lp->state_timer);
-               lp->tt.dns_register(lp);
-               fc_lport_unlock(lp);
-       }
        fc_frame_free(fp);
 }
 
 /**
  * fc_rport_enter_rtv - Send Request Timeout Value (RTV) request to peer
  * @rport: Fibre Channel remote port to send RTV to
+ *
+ * Locking Note: The rport lock is expected to be held before calling
+ * this routine.
  */
 static void fc_rport_enter_rtv(struct fc_rport *rport)
 {
        struct fc_els_rtv *rtv;
        struct fc_frame *fp;
-       struct fc_lport *lp;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
+
+       if (fc_rp_debug)
+               FC_DBG("Port (%6x) entered RTV state from %s state\n",
+                      rport->port_id, fc_rport_state(rport));
 
-       lp = rp->local_port;
        fc_rport_state_enter(rport, RPORT_ST_RTV);
 
-       fp = fc_frame_alloc(lp, sizeof(*rtv));
-       if (!fp)
-               return fc_rport_retry(rport);
+       fp = fc_frame_alloc(lport, sizeof(*rtv));
+       if (!fp) {
+               fc_rport_error(rport, fp);
+               return;
+       }
+
        rtv = fc_frame_payload_get(fp, sizeof(*rtv));
-       WARN_ON(!rtv);
        memset(rtv, 0, sizeof(*rtv));
        rtv->rtv_cmd = ELS_RTV;
        fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                 fc_rport_rtv_resp,
-                                 rport, lp->e_d_tov,
-                                 rp->local_port->fid,
-                                 rport->port_id,
-                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               fc_rport_retry(rport);
+
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_rport_rtv_resp, NULL,
+                                    rport, lport->e_d_tov,
+                                    lport->fid, rport->port_id,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_rport_error(rport, fp);
 }
 
 /**
  * fc_rport_enter_logo - Send Logout (LOGO) request to peer
  * @rport: Fibre Channel remote port to send LOGO to
+ *
+ * Locking Note: The rport lock is expected to be held before calling
+ * this routine.
  */
 static void fc_rport_enter_logo(struct fc_rport *rport)
 {
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
        struct fc_frame *fp;
        struct fc_els_logo *logo;
-       struct fc_lport *lp;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
+
+       if (fc_rp_debug)
+               FC_DBG("Port (%6x) entered LOGO state from %s state\n",
+                      rport->port_id, fc_rport_state(rport));
 
        fc_rport_state_enter(rport, RPORT_ST_LOGO);
 
-       lp = rp->local_port;
-       fp = fc_frame_alloc(lp, sizeof(*logo));
-       if (!fp)
-               return fc_rport_retry(rport);
+       fp = fc_frame_alloc(lport, sizeof(*logo));
+       if (!fp) {
+               fc_rport_error(rport, fp);
+               return;
+       }
+
        logo = fc_frame_payload_get(fp, sizeof(*logo));
        memset(logo, 0, sizeof(*logo));
        logo->fl_cmd = ELS_LOGO;
-       hton24(logo->fl_n_port_id, lp->fid);
-       logo->fl_n_port_wwn = htonll(lp->wwpn);
-
+       hton24(logo->fl_n_port_id, lport->fid);
+       logo->fl_n_port_wwn = htonll(lport->wwpn);
        fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
-       if (!lp->tt.exch_seq_send(lp, fp,
-                                 fc_rport_logo_resp,
-                                 rport, lp->e_d_tov,
-                                 rp->local_port->fid,
-                                 rport->port_id,
-                                 FC_FC_SEQ_INIT | FC_FC_END_SEQ))
-               fc_rport_retry(rport);
+
+       if (!lport->tt.exch_seq_send(lport, fp,
+                                    fc_rport_logo_resp, NULL,
+                                    rport, lport->e_d_tov,
+                                    lport->fid, rport->port_id,
+                                    FC_FC_SEQ_INIT | FC_FC_END_SEQ))
+               fc_rport_error(rport, fp);
 }
 
-/*
- * Handle a request received by the exchange manager for the session.
- * This may be an entirely new session, or a PLOGI or LOGO for an existing one.
- * This will free the frame.
+
+/**
+ * fc_rport_recv_req - Receive a request from a rport
+ * @sp: current sequence in the PLOGI exchange
+ * @fp: response frame
+ * @rp_arg: Fibre Channel remote port
+ *
+ * Locking Note: Called without the rport lock held. This
+ * function will hold the rport lock, call an _enter_*
+ * function and then unlock the rport.
  */
 void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
                       struct fc_rport *rport)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
+
        struct fc_frame_header *fh;
-       struct fc_lport *lp = rp->local_port;
        struct fc_seq_els_data els_data;
        u8 op;
 
+       mutex_lock(&rdata->rp_mutex);
+
        els_data.fp = NULL;
        els_data.explan = ELS_EXPL_NONE;
        els_data.reason = ELS_RJT_NONE;
@@ -907,21 +966,21 @@ void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
                        break;
                case ELS_RRQ:
                        els_data.fp = fp;
-                       lp->tt.seq_els_rsp_send(sp, ELS_RRQ, &els_data);
+                       lport->tt.seq_els_rsp_send(sp, ELS_RRQ, &els_data);
                        break;
                case ELS_REC:
                        els_data.fp = fp;
-                       lp->tt.seq_els_rsp_send(sp, ELS_REC, &els_data);
+                       lport->tt.seq_els_rsp_send(sp, ELS_REC, &els_data);
                        break;
                default:
                        els_data.reason = ELS_RJT_UNSUP;
-                       lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
-                       fc_frame_free(fp);
+                       lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
                        break;
                }
-       } else {
-               fc_frame_free(fp);
        }
+
+       fc_rport_unlock(rport);
+       fc_frame_free(fp);
 }
 
 /**
@@ -929,14 +988,18 @@ void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
  * @rport: Fibre Channel remote port that initiated PLOGI
  * @sp: current sequence in the PLOGI exchange
  * @fp: PLOGI request frame
+ *
+ * Locking Note: The rport lock is exected to be held before calling
+ * this function.
  */
 static void fc_rport_recv_plogi_req(struct fc_rport *rport,
                                    struct fc_seq *sp, struct fc_frame *rx_fp)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
        struct fc_frame *fp = rx_fp;
+
        struct fc_frame_header *fh;
-       struct fc_lport *lp;
        struct fc_els_flogi *pl;
        struct fc_seq_els_data rjt_data;
        u32 sid;
@@ -944,9 +1007,15 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
        u64 wwnn;
        enum fc_els_rjt_reason reject = 0;
        u32 f_ctl;
-
        rjt_data.fp = NULL;
+
        fh = fc_frame_header_get(fp);
+
+       if (fc_rp_debug)
+               FC_DBG("Received PLOGI request from port (%6x) "
+                      "while in state %s\n", ntoh24(fh->fh_s_id),
+                      fc_rport_state(rport));
+
        sid = ntoh24(fh->fh_s_id);
        pl = fc_frame_payload_get(fp, sizeof(*pl));
        if (!pl) {
@@ -958,8 +1027,6 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
        }
        wwpn = get_unaligned_be64(&pl->fl_wwpn);
        wwnn = get_unaligned_be64(&pl->fl_wwnn);
-       fc_rport_lock(rport);
-       lp = rp->local_port;
 
        /*
         * If the session was just created, possibly due to the incoming PLOGI,
@@ -972,63 +1039,50 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
         * XXX TBD: If the session was ready before, the PLOGI should result in
         * all outstanding exchanges being reset.
         */
-       switch (rp->rp_state) {
+       switch (rdata->rp_state) {
        case RPORT_ST_INIT:
                if (fc_rp_debug)
                        FC_DBG("incoming PLOGI from %6x wwpn %llx state INIT "
                               "- reject\n", sid, wwpn);
                reject = ELS_RJT_UNSUP;
                break;
-       case RPORT_ST_STARTED:
-               /*
-                * we'll only accept a login if the port name
-                * matches or was unknown.
-                */
-               if (rport->port_name != -1 &&
-                   rport->port_name != wwpn) {
-                       FC_DBG("incoming PLOGI from name %llx expected %llx\n",
-                              wwpn, rport->port_name);
-                       reject = ELS_RJT_UNAB;
-               }
-               break;
        case RPORT_ST_PLOGI:
                if (fc_rp_debug)
                        FC_DBG("incoming PLOGI from %x in PLOGI state %d\n",
-                              sid, rp->rp_state);
-               if (wwpn < lp->wwpn)
+                              sid, rdata->rp_state);
+               if (wwpn < lport->wwpn)
                        reject = ELS_RJT_INPROG;
                break;
        case RPORT_ST_PRLI:
-       case RPORT_ST_ERROR:
        case RPORT_ST_READY:
                if (fc_rp_debug)
                        FC_DBG("incoming PLOGI from %x in logged-in state %d "
-                              "- ignored for now\n", sid, rp->rp_state);
+                              "- ignored for now\n", sid, rdata->rp_state);
                /* XXX TBD - should reset */
                break;
        case RPORT_ST_NONE:
        default:
                if (fc_rp_debug)
                        FC_DBG("incoming PLOGI from %x in unexpected "
-                              "state %d\n", sid, rp->rp_state);
+                              "state %d\n", sid, rdata->rp_state);
                break;
        }
 
        if (reject) {
                rjt_data.reason = reject;
                rjt_data.explan = ELS_EXPL_NONE;
-               lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
+               lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
                fc_frame_free(fp);
        } else {
-               fp = fc_frame_alloc(lp, sizeof(*pl));
+               fp = fc_frame_alloc(lport, sizeof(*pl));
                if (fp == NULL) {
                        fp = rx_fp;
                        rjt_data.reason = ELS_RJT_UNAB;
                        rjt_data.explan = ELS_EXPL_NONE;
-                       lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
+                       lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
                        fc_frame_free(fp);
                } else {
-                       sp = lp->tt.seq_start_next(sp);
+                       sp = lport->tt.seq_start_next(sp);
                        WARN_ON(!sp);
                        fc_rport_set_name(rport, wwpn, wwnn);
 
@@ -1036,11 +1090,11 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
                         * Get session payload size from incoming PLOGI.
                         */
                        rport->maxframe_size =
-                               fc_plogi_get_maxframe(pl, lp->mfs);
+                               fc_plogi_get_maxframe(pl, lport->mfs);
                        fc_frame_free(rx_fp);
                        pl = fc_frame_payload_get(fp, sizeof(*pl));
                        WARN_ON(!pl);
-                       fc_lport_plogi_fill(lp, pl, ELS_LS_ACC);
+                       fc_lport_plogi_fill(lport, pl, ELS_LS_ACC);
 
                        /*
                         * Send LS_ACC.  If this fails,
@@ -1048,15 +1102,11 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
                         */
                        f_ctl = FC_FC_SEQ_INIT | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                        fc_frame_setup(fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
-                       lp->tt.seq_send(lp, sp, fp, f_ctl);
-                       if (rp->rp_state == RPORT_ST_PLOGI)
+                       lport->tt.seq_send(lport, sp, fp, f_ctl);
+                       if (rdata->rp_state == RPORT_ST_PLOGI)
                                fc_rport_enter_prli(rport);
-                       else
-                               fc_rport_state_enter(rport,
-                                                    RPORT_ST_PLOGI_RECV);
                }
        }
-       fc_rport_unlock(rport);
 }
 
 /**
@@ -1064,14 +1114,18 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
  * @rport: Fibre Channel remote port that initiated PRLI
  * @sp: current sequence in the PRLI exchange
  * @fp: PRLI request frame
+ *
+ * Locking Note: The rport lock is exected to be held before calling
+ * this function.
  */
 static void fc_rport_recv_prli_req(struct fc_rport *rport,
                                   struct fc_seq *sp, struct fc_frame *rx_fp)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
+
        struct fc_frame *fp;
        struct fc_frame_header *fh;
-       struct fc_lport *lp;
        struct {
                struct fc_els_prli prli;
                struct fc_els_spp spp;
@@ -1087,12 +1141,16 @@ static void fc_rport_recv_prli_req(struct fc_rport *rport,
        u32 f_ctl;
        u32 fcp_parm;
        u32 roles = FC_RPORT_ROLE_UNKNOWN;
-
        rjt_data.fp = NULL;
+
        fh = fc_frame_header_get(rx_fp);
-       lp = rp->local_port;
-       switch (rp->rp_state) {
-       case RPORT_ST_PLOGI_RECV:
+
+       if (fc_rp_debug)
+               FC_DBG("Received PRLI request from port (%6x) "
+                      "while in state %s\n", ntoh24(fh->fh_s_id),
+                      fc_rport_state(rport));
+
+       switch (rdata->rp_state) {
        case RPORT_ST_PRLI:
        case RPORT_ST_READY:
                reason = ELS_RJT_NONE;
@@ -1122,12 +1180,12 @@ static void fc_rport_recv_prli_req(struct fc_rport *rport,
                rspp = &pp->spp;
        }
        if (reason != ELS_RJT_NONE ||
-           (fp = fc_frame_alloc(lp, len)) == NULL) {
+           (fp = fc_frame_alloc(lport, len)) == NULL) {
                rjt_data.reason = reason;
                rjt_data.explan = explan;
-               lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
+               lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
        } else {
-               sp = lp->tt.seq_start_next(sp);
+               sp = lport->tt.seq_start_next(sp);
                WARN_ON(!sp);
                pp = fc_frame_payload_get(fp, len);
                WARN_ON(!pp);
@@ -1156,15 +1214,16 @@ static void fc_rport_recv_prli_req(struct fc_rport *rport,
                        case FC_TYPE_FCP:
                                fcp_parm = ntohl(rspp->spp_params);
                                if (fcp_parm * FCP_SPPF_RETRY)
-                                       rp->flags |= FC_RP_FLAGS_RETRY;
+                                       rdata->flags |= FC_RP_FLAGS_RETRY;
                                rport->supported_classes = FC_COS_CLASS3;
                                if (fcp_parm & FCP_SPPF_INIT_FCN)
                                        roles |= FC_RPORT_ROLE_FCP_INITIATOR;
                                if (fcp_parm & FCP_SPPF_TARG_FCN)
                                        roles |= FC_RPORT_ROLE_FCP_TARGET;
-                               fc_remote_port_rolechg(rport, roles);
+                               rdata->roles = roles;
+
                                spp->spp_params =
-                                       htonl(rp->local_port->service_params);
+                                       htonl(lport->service_params);
                                break;
                        default:
                                resp = FC_SPP_RESP_INVL;
@@ -1181,32 +1240,20 @@ static void fc_rport_recv_prli_req(struct fc_rport *rport,
                 */
                f_ctl = FC_FC_SEQ_INIT | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                fc_frame_setup(fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
-               lp->tt.seq_send(lp, sp, fp, f_ctl);
+               lport->tt.seq_send(lport, sp, fp, f_ctl);
 
                /*
                 * Get lock and re-check state.
                 */
-               fc_rport_lock(rport);
-               switch (rp->rp_state) {
-               case RPORT_ST_PLOGI_RECV:
+               switch (rdata->rp_state) {
                case RPORT_ST_PRLI:
-                       fc_rport_state_enter(rport, RPORT_ST_READY);
-                       if (fc_rp_debug)
-                               FC_DBG("remote %6x ready\n", rport->port_id);
-                       if (rport == lp->dns_rp &&
-                           lp->state == LPORT_ST_DNS) {
-                               fc_lport_lock(lp);
-                               del_timer(&lp->state_timer);
-                               lp->tt.dns_register(lp);
-                               fc_lport_unlock(lp);
-                       }
+                       fc_rport_enter_ready(rport);
                        break;
                case RPORT_ST_READY:
                        break;
                default:
                        break;
                }
-               fc_rport_unlock(rport);
        }
        fc_frame_free(rx_fp);
 }
@@ -1216,22 +1263,30 @@ static void fc_rport_recv_prli_req(struct fc_rport *rport,
  * @rport: Fibre Channel remote port that initiated PRLO
  * @sp: current sequence in the PRLO exchange
  * @fp: PRLO request frame
+ *
+ * Locking Note: The rport lock is exected to be held before calling
+ * this function.
  */
 static void fc_rport_recv_prlo_req(struct fc_rport *rport, struct fc_seq *sp,
                                   struct fc_frame *fp)
 {
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
+
        struct fc_frame_header *fh;
-       struct fc_lport *lp = rp->local_port;
        struct fc_seq_els_data rjt_data;
 
        fh = fc_frame_header_get(fp);
-       FC_DBG("incoming PRLO from %x state %d\n",
-              ntoh24(fh->fh_s_id), rp->rp_state);
+
+       if (fc_rp_debug)
+               FC_DBG("Received PRLO request from port (%6x) "
+                      "while in state %s\n", ntoh24(fh->fh_s_id),
+                      fc_rport_state(rport));
+
        rjt_data.fp = NULL;
        rjt_data.reason = ELS_RJT_UNAB;
        rjt_data.explan = ELS_EXPL_NONE;
-       lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
+       lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
        fc_frame_free(fp);
 }
 
@@ -1240,62 +1295,95 @@ static void fc_rport_recv_prlo_req(struct fc_rport *rport, struct fc_seq *sp,
  * @rport: Fibre Channel remote port that initiated LOGO
  * @sp: current sequence in the LOGO exchange
  * @fp: LOGO request frame
+ *
+ * Locking Note: The rport lock is exected to be held before calling
+ * this function.
  */
 static void fc_rport_recv_logo_req(struct fc_rport *rport, struct fc_seq *sp,
                                   struct fc_frame *fp)
 {
        struct fc_frame_header *fh;
-       struct fc_rport_libfc_priv *rp = rport->dd_data;
-       struct fc_lport *lp = rp->local_port;
+       struct fc_rport_libfc_priv *rdata = rport->dd_data;
+       struct fc_lport *lport = rdata->local_port;
 
        fh = fc_frame_header_get(fp);
-       fc_rport_lock(rport);
-       fc_rport_state_enter(rport, RPORT_ST_INIT);
-       fc_rport_unlock(rport);
+
        if (fc_rp_debug)
-               FC_DBG("remote %6x closed\n", rport->port_id);
-       if (rport == lp->dns_rp &&
-           lp->state != LPORT_ST_RESET) {
-               fc_lport_lock(lp);
-               del_timer(&lp->state_timer);
-               lp->dns_rp = NULL;
-               if (lp->state == LPORT_ST_DNS_STOP) {
-                       fc_lport_unlock(lp);
-                       lp->tt.lport_logout(lp);
-               } else {
-                       lp->tt.lport_login(lp);
-                       fc_lport_unlock(lp);
-               }
-               fc_remote_port_delete(rport);
-       }
-       lp->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
+               FC_DBG("Received LOGO request from port (%6x) "
+                      "while in state %s\n", ntoh24(fh->fh_s_id),
+                      fc_rport_state(rport));
+
+       rdata->event = LPORT_EV_RPORT_LOGO;
+
+       lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
        fc_frame_free(fp);
 }
 
-int fc_rport_init(struct fc_lport *lp)
+int fc_rport_init(struct fc_lport *lport)
 {
-       if (!lp->tt.rport_login)
-               lp->tt.rport_login = fc_rport_login;
-
-       if (!lp->tt.rport_logout)
-               lp->tt.rport_logout = fc_rport_logout;
+       if (!lport->tt.rport_login)
+               lport->tt.rport_login = fc_rport_login;
 
-       if (!lp->tt.rport_recv_req)
-               lp->tt.rport_recv_req = fc_rport_recv_req;
+       if (!lport->tt.rport_logout)
+               lport->tt.rport_logout = fc_rport_logout;
 
-       if (!lp->tt.rport_create)
-               lp->tt.rport_create = fc_remote_port_create;
+       if (!lport->tt.rport_recv_req)
+               lport->tt.rport_recv_req = fc_rport_recv_req;
 
-       if (!lp->tt.rport_lookup)
-               lp->tt.rport_lookup = fc_rport_lookup;
+       if (!lport->tt.rport_lookup)
+               lport->tt.rport_lookup = fc_rport_lookup;
 
-       if (!lp->tt.rport_reset)
-               lp->tt.rport_reset = fc_rport_reset;
+       if (!lport->tt.rport_reset)
+               lport->tt.rport_reset = fc_rport_reset;
 
-       if (!lp->tt.rport_reset_list)
-               lp->tt.rport_reset_list = fc_rport_reset_list;
+       if (!lport->tt.rport_reset_list)
+               lport->tt.rport_reset_list = fc_rport_reset_list;
 
        return 0;
 }
 EXPORT_SYMBOL(fc_rport_init);
 
+/**
+ * fc_block_rports - delete all the remote ports, on reset or link down
+ * @lp: libfc local port instance
+ *
+ * This routine temporarily removes any online remote ports from the fc_host
+ * rport list, then drops the host lock in order to call fc_remote_port_delete()
+ * on each rport in turn, and finally splices the list back onto the fc_host.
+ */
+void fc_block_rports(struct fc_lport *lp)
+{
+       struct Scsi_Host *shost = lp->host;
+       struct fc_rport *rport, *next;
+       unsigned long flags;
+       LIST_HEAD(rports);
+
+       spin_lock_irqsave(shost->host_lock, flags);
+       list_for_each_entry_safe(rport, next, &fc_host_rports(shost), peers) {
+               /* protect the name service remote port */
+               if (rport->port_id == FC_FID_DIR_SERV)
+                       continue;
+               if (rport->port_state != FC_PORTSTATE_ONLINE)
+                       continue;
+               list_move_tail(&rport->peers, &rports);
+       }
+       spin_unlock_irqrestore(shost->host_lock, flags);
+
+       list_for_each_entry(rport, &rports, peers) {
+               fc_remote_port_delete(rport);
+       }
+
+       spin_lock_irqsave(shost->host_lock, flags);
+       list_splice(&rports, &fc_host_rports(shost));
+       spin_unlock_irqrestore(shost->host_lock, flags);
+}
+
+void fc_rport_terminate_io(struct fc_rport *rport)
+{
+       struct fc_rport_libfc_priv *rp = rport->dd_data;
+       struct fc_lport *lp = rp->local_port;
+
+       lp->tt.exch_mgr_reset(lp->emp, 0, rport->port_id);
+       lp->tt.exch_mgr_reset(lp->emp, rport->port_id, 0);
+}
+EXPORT_SYMBOL(fc_rport_terminate_io);
diff --git a/include/scsi/fc/fc_fcoe.h b/include/scsi/fc/fc_fcoe.h
index b2e07ec..59c9d0c 100644
--- a/include/scsi/fc/fc_fcoe.h
+++ b/include/scsi/fc/fc_fcoe.h
@@ -93,14 +93,6 @@ static inline void fc_fcoe_set_mac(u8 *mac, u8 *did)
        mac[5] = did[2];
 }
 
-/*
- * VLAN header.         This is also defined in linux/if_vlan.h, but for kernels only.
- */
-struct fcoe_vlan_hdr {
-       __be16          vlan_tag;       /* VLAN tag including priority */
-       __be16          vlan_ethertype; /* encapsulated ethertype ETH_P_FCOE */
-};
-
 #ifndef ETH_P_8021Q
 #define        ETH_P_8021Q     0x8100
 #endif
diff --git a/include/scsi/fc/fc_fs.h b/include/scsi/fc/fc_fs.h
index ba6df64..3897c6c 100644
--- a/include/scsi/fc/fc_fs.h
+++ b/include/scsi/fc/fc_fs.h
@@ -329,16 +329,4 @@ enum fc_pf_rjt_reason {
        FC_RJT_VENDOR =         0xff,   /* vendor specific reject */
 };
 
-/*
- * Data descriptor format (R_CTL == FC_RCTL_DD_DATA_DESC).
- * This is used for FCP SCSI transfer ready.
- */
-struct fc_data_desc {
-       __be32          dd_offset;      /* data relative offset in bytes */
-       __be32          dd_len;         /* transfer buffer size in bytes */
-       __u8            _dd_resvd[4];
-};
-
-#define FC_DATA_DESC_LEN    12 /* expected length of structure */
-
 #endif /* _FC_FS_H_ */
diff --git a/include/scsi/libfc/libfc.h b/include/scsi/libfc/libfc.h
index b139aed..24d3fcb 100644
--- a/include/scsi/libfc/libfc.h
+++ b/include/scsi/libfc/libfc.h
@@ -29,6 +29,7 @@
 #include <scsi/fc/fc_fcp.h>
 #include <scsi/fc/fc_ns.h>
 #include <scsi/fc/fc_els.h>
+#include <scsi/fc/fc_gs.h>
 
 #include <scsi/libfc/fc_frame.h>
 
@@ -91,28 +92,50 @@ enum fc_lport_state {
        LPORT_ST_NONE = 0,
        LPORT_ST_FLOGI,
        LPORT_ST_DNS,
-       LPORT_ST_REG_PN,
-       LPORT_ST_REG_FT,
+       LPORT_ST_RPN_ID,
+       LPORT_ST_RFT_ID,
        LPORT_ST_SCR,
        LPORT_ST_READY,
-       LPORT_ST_DNS_STOP,
        LPORT_ST_LOGO,
        LPORT_ST_RESET
 };
 
+enum fc_lport_event {
+       LPORT_EV_RPORT_NONE = 0,
+       LPORT_EV_RPORT_CREATED,
+       LPORT_EV_RPORT_FAILED,
+       LPORT_EV_RPORT_LOGO
+};
+
 enum fc_rport_state {
        RPORT_ST_NONE = 0,
        RPORT_ST_INIT,          /* initialized */
-       RPORT_ST_STARTED,       /* started */
        RPORT_ST_PLOGI,         /* waiting for PLOGI completion */
-       RPORT_ST_PLOGI_RECV,    /* received PLOGI (as target) */
        RPORT_ST_PRLI,          /* waiting for PRLI completion */
        RPORT_ST_RTV,           /* waiting for RTV completion */
-       RPORT_ST_ERROR,         /* error */
        RPORT_ST_READY,         /* ready for use */
        RPORT_ST_LOGO,          /* port logout sent */
 };
 
+enum fc_rport_trans_state {
+       FC_PORTSTATE_ROGUE,
+       FC_PORTSTATE_REAL,
+};
+
+/**
+ * struct fc_disc_port - temporary discovery port to hold rport identifiers
+ * @lp: Fibre Channel host port instance
+ * @peers: node for list management during discovery and RSCN processing
+ * @ids: identifiers structure to pass to fc_remote_port_add()
+ * @rport_work: work struct for starting the rport state machine
+ */
+struct fc_disc_port {
+       struct fc_lport             *lp;
+       struct list_head            peers;
+       struct fc_rport_identifiers ids;
+       struct work_struct          rport_work;
+};
+
 /**
  * struct fc_rport_libfc_priv - libfc internal information about a remote port
  * @local_port: Fibre Channel host port instance
@@ -122,8 +145,9 @@ enum fc_rport_state {
  * @retries: retry count in current state
  * @e_d_tov: error detect timeout value (in msec)
  * @r_a_tov: resource allocation timeout value (in msec)
- * @rp_lock: lock protects state
+ * @rp_mutex: mutex protects rport
  * @retry_work:
+ * @event_callback: Callback for rport READY, FAILED or LOGO
  */
 struct fc_rport_libfc_priv {
        struct fc_lport         *local_port;
@@ -135,10 +159,23 @@ struct fc_rport_libfc_priv {
        unsigned int    retries;
        unsigned int    e_d_tov;
        unsigned int    r_a_tov;
-       spinlock_t      rp_lock;
+       enum fc_rport_trans_state trans_state;
+       struct mutex    rp_mutex;
        struct delayed_work     retry_work;
+       enum fc_lport_event     event;
+       void (*event_callback)(struct fc_lport *, u32,
+                              enum fc_lport_event);
+       u32 roles;
 };
 
+#define PRIV_TO_RPORT(x)                                               \
+       (struct fc_rport*)((void *)x - sizeof(struct fc_rport));
+#define RPORT_TO_PRIV(x)                                               \
+       (struct fc_rport_libfc_priv*)((void *)x + sizeof(struct fc_rport));
+
+struct fc_rport *fc_rport_dummy_create(struct fc_disc_port *);
+void fc_rport_dummy_destroy(struct fc_rport *);
+
 static inline void fc_rport_set_name(struct fc_rport *rport, u64 wwpn, u64 wwnn)
 {
        rport->node_name = wwnn;
@@ -219,9 +256,12 @@ struct libfc_function_template {
         * fc_frame pointer in response handler will also indicate timeout
         * as error using IS_ERR related macros.
         *
-        * The response handler argumemt resp_arg is passed back to resp
-        * handler when it is invoked by EM layer in above mentioned
-        * two scenarios.
+        * The exchange destructor handler is also set in this routine.
+        * The destructor handler is invoked by EM layer when exchange
+        * is about to free, this can be used by caller to free its
+        * resources along with exchange free.
+        *
+        * The arg is passed back to resp and destructor handler.
         *
         * The timeout value (in msec) for an exchange is set if non zero
         * timer_msec argument is specified. The timer is canceled when
@@ -232,10 +272,12 @@ struct libfc_function_template {
         */
        struct fc_seq *(*exch_seq_send)(struct fc_lport *lp,
                                        struct fc_frame *fp,
-                                       void (*resp)(struct fc_seq *,
+                                       void (*resp)(struct fc_seq *sp,
                                                     struct fc_frame *fp,
                                                     void *arg),
-                                       void *resp_arg, unsigned int timer_msec,
+                                       void (*destructor)(struct fc_seq *sp,
+                                                          void *arg),
+                                       void *arg, unsigned int timer_msec,
                                        u32 sid, u32 did, u32 f_ctl);
 
        /*
@@ -316,9 +358,10 @@ struct libfc_function_template {
        void (*lport_recv)(struct fc_lport *lp, struct fc_seq *sp,
                           struct fc_frame *fp);
 
-       int (*lport_login)(struct fc_lport *);
        int (*lport_reset)(struct fc_lport *);
-       int (*lport_logout)(struct fc_lport *);
+
+       void (*event_callback)(struct fc_lport *, u32,
+                              enum fc_lport_event);
 
        /**
         * Remote Port interfaces
@@ -346,9 +389,6 @@ struct libfc_function_template {
 
        struct fc_rport *(*rport_lookup)(const struct fc_lport *, u32);
 
-       struct fc_rport *(*rport_create)(struct fc_lport *,
-                                        struct fc_rport_identifiers *);
-
        void (*rport_reset)(struct fc_rport *);
 
        void (*rport_reset_list)(struct fc_lport *);
@@ -378,9 +418,6 @@ struct libfc_function_template {
         * Start discovery for a local port.
         */
        int (*disc_start)(struct fc_lport *);
-
-       void (*dns_register)(struct fc_lport *);
-       void (*disc_stop)(struct fc_lport *);
 };
 
 struct fc_lport {
@@ -396,7 +433,7 @@ struct fc_lport {
        /* Operational Information */
        struct libfc_function_template tt;
        u16                     link_status;
-       u8                      ns_disc_done;
+       u8                      disc_done;
        enum fc_lport_state     state;
        unsigned long           boot_time;
 
@@ -407,12 +444,12 @@ struct fc_lport {
        u64                     wwnn;
        u32                     fid;
        u8                      retry_count;
-       unsigned char           ns_disc_retry_count;
-       unsigned char           ns_disc_delay;
-       unsigned char           ns_disc_pending;
-       unsigned char           ns_disc_requested;
-       unsigned short          ns_disc_seq_count;
-       unsigned char           ns_disc_buf_len;
+       unsigned char           disc_retry_count;
+       unsigned char           disc_delay;
+       unsigned char           disc_pending;
+       unsigned char           disc_requested;
+       unsigned short          disc_seq_count;
+       unsigned char           disc_buf_len;
 
        /* Capabilities */
        char                    ifname[IFNAMSIZ];
@@ -427,13 +464,13 @@ struct fc_lport {
        struct fc_ns_fts        fcts;           /* FC-4 type masks */
        struct fc_els_rnid_gen  rnid_gen;       /* RNID information */
 
-       /* Locks */
-       spinlock_t              state_lock;     /* serializes state changes */
+       /* Semaphores */
+       struct mutex lp_mutex;
 
        /* Miscellaneous */
-       struct fc_gpn_ft_resp   ns_disc_buf;    /* partial name buffer */
-       struct timer_list       state_timer;    /* timer for state events */
-       struct delayed_work     ns_disc_work;
+       struct fc_gpn_ft_resp   disc_buf;       /* partial name buffer */
+       struct delayed_work     retry_work;
+       struct delayed_work     disc_work;
 
        void                    *drv_priv;
 };
@@ -462,33 +499,26 @@ static inline void fc_set_wwpn(struct fc_lport *lp, u64 wwnn)
        lp->wwpn = wwnn;
 }
 
-static inline int fc_lport_locked(struct fc_lport *lp)
-{
-#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
-       return spin_is_locked(&lp->state_lock);
-#else
-       return 1;
-#endif /* CONFIG_SMP || CONFIG_DEBUG_SPINLOCK */
-}
-
-/*
- * Locking code.
- */
-static inline void fc_lport_lock(struct fc_lport *lp)
-{
-       spin_lock_bh(&lp->state_lock);
-}
-
-static inline void fc_lport_unlock(struct fc_lport *lp)
+/**
+ * fc_fill_dns_hdr - Fill in a name service request header
+ * @lp: Fibre Channel host port instance
+ * @ct: Common Transport (CT) header structure
+ * @op: Name Service request code
+ * @req_size: Full size of Name Service request
+ */
+static inline void fc_fill_dns_hdr(struct fc_lport *lp, struct fc_ct_hdr *ct,
+                                  unsigned int op, unsigned int req_size)
 {
-       spin_unlock_bh(&lp->state_lock);
+       memset(ct, 0, sizeof(*ct) + req_size);
+       ct->ct_rev = FC_CT_REV;
+       ct->ct_fs_type = FC_FST_DIR;
+       ct->ct_fs_subtype = FC_NS_SUBTYPE;
+       ct->ct_cmd = htons((u16) op);
 }
 
 static inline void fc_lport_state_enter(struct fc_lport *lp,
                                        enum fc_lport_state state)
 {
-       WARN_ON(!fc_lport_locked(lp));
-       del_timer(&lp->state_timer);
        if (state != lp->state)
                lp->retry_count = 0;
        lp->state = state;
@@ -543,7 +573,7 @@ int fc_lport_config(struct fc_lport *);
 /*
  * Reset the local port.
  */
-int fc_lport_enter_reset(struct fc_lport *);
+int fc_lport_reset(struct fc_lport *);
 
 /*
  * Set the mfs or reset
@@ -555,12 +585,14 @@ int fc_set_mfs(struct fc_lport *lp, u32 mfs);
  * REMOTE PORT LAYER
  *****************************/
 int fc_rport_init(struct fc_lport *lp);
+void fc_rport_terminate_io(struct fc_rport *rp);
+void fc_block_rports(struct fc_lport *lp);
 
 
 /**
  * DISCOVERY LAYER
  *****************************/
-int fc_ns_init(struct fc_lport *lp);
+int fc_disc_init(struct fc_lport *lp);
 
 
 /**
@@ -670,10 +702,12 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
  */
 struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
                                struct fc_frame *fp,
-                               void (*resp)(struct fc_seq *,
+                               void (*resp)(struct fc_seq *sp,
                                             struct fc_frame *fp,
                                             void *arg),
-                               void *resp_arg, u32 timer_msec,
+                               void (*destructor)(struct fc_seq *sp,
+                                                  void *arg),
+                               void *arg, u32 timer_msec,
                                u32 sid, u32 did, u32 f_ctl);
 
 /*
@@ -738,15 +772,11 @@ void fc_seq_get_xids(struct fc_seq *sp, u16 *oxid, u16 *rxid);
  */
 void fc_seq_set_rec_data(struct fc_seq *sp, u32 rec_data);
 
-/**
- * fc_functions_template
- *****************************/
-void fc_attr_init(struct fc_lport *);
-void fc_get_host_port_id(struct Scsi_Host *shost);
+/*
+ * Functions for fc_functions_template
+ */
 void fc_get_host_speed(struct Scsi_Host *shost);
-void fc_get_host_port_type(struct Scsi_Host *shost);
 void fc_get_host_port_state(struct Scsi_Host *shost);
-void fc_get_host_fabric_name(struct Scsi_Host *shost);
 void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout);
 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *);