1 files changed, 605 insertions, 259 deletions

diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index bd2f77197447..d126ecfff704 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -56,7 +56,7 @@
  * at the same time.
  *
  * When discovery succeeds or fails a callback is made to the lport as
- * notification. Currently, succesful discovery causes the lport to take no
+ * notification. Currently, successful discovery causes the lport to take no
  * action. A failure will cause the lport to reset. There is likely a circular
  * locking problem with this implementation.
  */
@@ -88,12 +88,16 @@
  */
 
 #include <linux/timer.h>
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 
 #include <scsi/fc/fc_gs.h>
 
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
+#include <linux/scatterlist.h>
+
+#include "fc_libfc.h"
 
 /* Fabric IDs to use for point-to-point mode, chosen on whims. */
 #define FC_LOCAL_PTP_FID_LO   0x010101
@@ -106,8 +110,7 @@ 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_ns(struct fc_lport *, enum fc_lport_state);
 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 *);
@@ -116,14 +119,40 @@ static const char *fc_lport_state_names[] = {
         [LPORT_ST_DISABLED] = "disabled",
         [LPORT_ST_FLOGI] =    "FLOGI",
         [LPORT_ST_DNS] =      "dNS",
-        [LPORT_ST_RPN_ID] =   "RPN_ID",
+        [LPORT_ST_RNN_ID] =   "RNN_ID",
+        [LPORT_ST_RSNN_NN] =  "RSNN_NN",
+        [LPORT_ST_RSPN_ID] =  "RSPN_ID",
         [LPORT_ST_RFT_ID] =   "RFT_ID",
+        [LPORT_ST_RFF_ID] =   "RFF_ID",
         [LPORT_ST_SCR] =      "SCR",
         [LPORT_ST_READY] =    "Ready",
         [LPORT_ST_LOGO] =     "LOGO",
         [LPORT_ST_RESET] =    "reset",
 };
 
+/**
+ * struct fc_bsg_info - FC Passthrough managemet structure
+ * @job:      The passthrough job
+ * @lport:    The local port to pass through a command
+ * @rsp_code: The expected response code
+ * @sg:       job->reply_payload.sg_list
+ * @nents:    job->reply_payload.sg_cnt
+ * @offset:   The offset into the response data
+ */
+struct fc_bsg_info {
+        struct fc_bsg_job *job;
+        struct fc_lport *lport;
+        u16 rsp_code;
+        struct scatterlist *sg;
+        u32 nents;
+        size_t offset;
+};
+
+/**
+ * fc_frame_drop() - Dummy frame handler
+ * @lport: The local port the frame was received on
+ * @fp:    The received frame
+ */
 static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
 {
         fc_frame_free(fp);
@@ -150,8 +179,8 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
         switch (event) {
         case RPORT_EV_READY:
                 if (lport->state == LPORT_ST_DNS) {
-                        lport->dns_rp = rdata;
-                        fc_lport_enter_rpn_id(lport);
+                        lport->dns_rdata = rdata;
+                        fc_lport_enter_ns(lport, LPORT_ST_RNN_ID);
                 } else {
                         FC_LPORT_DBG(lport, "Received an READY event "
                                      "on port (%6x) for the directory "
@@ -165,7 +194,7 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
         case RPORT_EV_LOGO:
         case RPORT_EV_FAILED:
         case RPORT_EV_STOP:
-                lport->dns_rp = NULL;
+                lport->dns_rdata = NULL;
                 break;
         case RPORT_EV_NONE:
                 break;
@@ -189,8 +218,8 @@ static const char *fc_lport_state(struct fc_lport *lport)
 
 /**
  * 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
+ * @lport:       The lport to attach the ptp rport to
+ * @remote_fid:  The FID of the ptp rport
  * @remote_wwpn: The WWPN of the ptp rport
  * @remote_wwnn: The WWNN of the ptp rport
  */
@@ -199,18 +228,22 @@ static void fc_lport_ptp_setup(struct fc_lport *lport,
                                u64 remote_wwnn)
 {
         mutex_lock(&lport->disc.disc_mutex);
-        if (lport->ptp_rp)
-                lport->tt.rport_logoff(lport->ptp_rp);
-        lport->ptp_rp = lport->tt.rport_create(lport, remote_fid);
-        lport->ptp_rp->ids.port_name = remote_wwpn;
-        lport->ptp_rp->ids.node_name = remote_wwnn;
+        if (lport->ptp_rdata)
+                lport->tt.rport_logoff(lport->ptp_rdata);
+        lport->ptp_rdata = lport->tt.rport_create(lport, remote_fid);
+        lport->ptp_rdata->ids.port_name = remote_wwpn;
+        lport->ptp_rdata->ids.node_name = remote_wwnn;
         mutex_unlock(&lport->disc.disc_mutex);
 
-        lport->tt.rport_login(lport->ptp_rp);
+        lport->tt.rport_login(lport->ptp_rdata);
 
         fc_lport_enter_ready(lport);
 }
 
+/**
+ * fc_get_host_port_type() - Return the port type of the given Scsi_Host
+ * @shost: The SCSI host whose port type is to be determined
+ */
 void fc_get_host_port_type(struct Scsi_Host *shost)
 {
         /* TODO - currently just NPORT */
@@ -218,17 +251,33 @@ void fc_get_host_port_type(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_port_type);
 
+/**
+ * fc_get_host_port_state() - Return the port state of the given Scsi_Host
+ * @shost:  The SCSI host whose port state is to be determined
+ */
 void fc_get_host_port_state(struct Scsi_Host *shost)
 {
-        struct fc_lport *lp = shost_priv(shost);
+        struct fc_lport *lport = shost_priv(shost);
 
-        if (lp->link_up)
-                fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
+        mutex_lock(&lport->lp_mutex);
+        if (!lport->link_up)
+                fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
         else
-                fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
+                switch (lport->state) {
+                case LPORT_ST_READY:
+                        fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
+                        break;
+                default:
+                        fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
+                }
+        mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_get_host_port_state);
 
+/**
+ * fc_get_host_speed() - Return the speed of the given Scsi_Host
+ * @shost: The SCSI host whose port speed is to be determined
+ */
 void fc_get_host_speed(struct Scsi_Host *shost)
 {
         struct fc_lport *lport = shost_priv(shost);
@@ -237,24 +286,28 @@ void fc_get_host_speed(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_speed);
 
+/**
+ * fc_get_host_stats() - Return the Scsi_Host's statistics
+ * @shost: The SCSI host whose statistics are to be returned
+ */
 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
 {
         struct fc_host_statistics *fcoe_stats;
-        struct fc_lport *lp = shost_priv(shost);
+        struct fc_lport *lport = shost_priv(shost);
         struct timespec v0, v1;
         unsigned int cpu;
 
-        fcoe_stats = &lp->host_stats;
+        fcoe_stats = &lport->host_stats;
         memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
 
         jiffies_to_timespec(jiffies, &v0);
-        jiffies_to_timespec(lp->boot_time, &v1);
+        jiffies_to_timespec(lport->boot_time, &v1);
         fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
 
         for_each_possible_cpu(cpu) {
                 struct fcoe_dev_stats *stats;
 
-                stats = per_cpu_ptr(lp->dev_stats, cpu);
+                stats = per_cpu_ptr(lport->dev_stats, cpu);
 
                 fcoe_stats->tx_frames += stats->TxFrames;
                 fcoe_stats->tx_words += stats->TxWords;
@@ -279,12 +332,15 @@ struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_stats);
 
-/*
- * Fill in FLOGI command for request.
+/**
+ * fc_lport_flogi_fill() - Fill in FLOGI command for request
+ * @lport: The local port the FLOGI is for
+ * @flogi: The FLOGI command
+ * @op:    The opcode
  */
-static void
-fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
-                    unsigned int op)
+static void 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;
@@ -312,8 +368,10 @@ fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
         }
 }
 
-/*
- * Add a supported FC-4 type.
+/**
+ * fc_lport_add_fc4_type() - Add a supported FC-4 type to a local port
+ * @lport: The local port to add a new FC-4 type to
+ * @type:  The new FC-4 type
  */
 static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 {
@@ -325,11 +383,11 @@ static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 
 /**
  * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report.
+ * @sp:    The sequence in the RLIR exchange
+ * @fp:    The RLIR request frame
  * @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
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
@@ -344,11 +402,11 @@ static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * 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
+ * @sp:    The sequence in the ECHO exchange
+ * @fp:    ECHO request frame
+ * @lport: The local port recieving the ECHO
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
@@ -361,7 +419,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
         void *dp;
         u32 f_ctl;
 
-        FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
+        FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n",
                      fc_lport_state(lport));
 
         len = fr_len(in_fp) - sizeof(struct fc_frame_header);
@@ -374,7 +432,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
         if (fp) {
                 dp = fc_frame_payload_get(fp, len);
                 memcpy(dp, pp, len);
-                *((u32 *)dp) = htonl(ELS_LS_ACC << 24);
+                *((__be32 *)dp) = htonl(ELS_LS_ACC << 24);
                 sp = lport->tt.seq_start_next(sp);
                 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
@@ -385,12 +443,12 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
 }
 
 /**
- * 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
+ * fc_lport_recv_rnid_req() - Handle received Request Node ID data request
+ * @sp:    The sequence in the RNID exchange
+ * @fp:    The RNID request frame
+ * @lport: The local port recieving the RNID
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
@@ -453,9 +511,9 @@ static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
 
 /**
  * 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
+ * @sp:    The sequence in the LOGO exchange
+ * @fp:    The LOGO request frame
+ * @lport: The local port recieving the LOGO
  *
  * Locking Note: The lport lock is exected to be held before calling
  * this function.
@@ -470,7 +528,7 @@ static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * fc_fabric_login() - Start the lport state machine
- * @lport: The lport that should log into the fabric
+ * @lport: The local port that should log into the fabric
  *
  * Locking Note: This function should not be called
  *               with the lport lock held.
@@ -480,7 +538,9 @@ int fc_fabric_login(struct fc_lport *lport)
         int rc = -1;
 
         mutex_lock(&lport->lp_mutex);
-        if (lport->state == LPORT_ST_DISABLED) {
+        if (lport->state == LPORT_ST_DISABLED ||
+            lport->state == LPORT_ST_LOGO) {
+                fc_lport_state_enter(lport, LPORT_ST_RESET);
                 fc_lport_enter_reset(lport);
                 rc = 0;
         }
@@ -491,47 +551,69 @@ int fc_fabric_login(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_fabric_login);
 
 /**
- * fc_linkup() - Handler for transport linkup events
+ * __fc_linkup() - Handler for transport linkup events
  * @lport: The lport whose link is up
+ *
+ * Locking: must be called with the lp_mutex held
  */
-void fc_linkup(struct fc_lport *lport)
+void __fc_linkup(struct fc_lport *lport)
 {
-        printk(KERN_INFO "libfc: Link up on port (%6x)\n",
-               fc_host_port_id(lport->host));
-
-        mutex_lock(&lport->lp_mutex);
         if (!lport->link_up) {
                 lport->link_up = 1;
 
                 if (lport->state == LPORT_ST_RESET)
                         fc_lport_enter_flogi(lport);
         }
+}
+
+/**
+ * fc_linkup() - Handler for transport linkup events
+ * @lport: The local port whose link is up
+ */
+void fc_linkup(struct fc_lport *lport)
+{
+        printk(KERN_INFO "host%d: libfc: Link up on port (%6x)\n",
+               lport->host->host_no, fc_host_port_id(lport->host));
+
+        mutex_lock(&lport->lp_mutex);
+        __fc_linkup(lport);
         mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkup);
 
 /**
- * fc_linkdown() - Handler for transport linkdown events
+ * __fc_linkdown() - Handler for transport linkdown events
  * @lport: The lport whose link is down
+ *
+ * Locking: must be called with the lp_mutex held
  */
-void fc_linkdown(struct fc_lport *lport)
+void __fc_linkdown(struct fc_lport *lport)
 {
-        mutex_lock(&lport->lp_mutex);
-        printk(KERN_INFO "libfc: Link down on port (%6x)\n",
-               fc_host_port_id(lport->host));
-
         if (lport->link_up) {
                 lport->link_up = 0;
                 fc_lport_enter_reset(lport);
                 lport->tt.fcp_cleanup(lport);
         }
+}
+
+/**
+ * fc_linkdown() - Handler for transport linkdown events
+ * @lport: The local port whose link is down
+ */
+void fc_linkdown(struct fc_lport *lport)
+{
+        printk(KERN_INFO "host%d: libfc: Link down on port (%6x)\n",
+               lport->host->host_no, fc_host_port_id(lport->host));
+
+        mutex_lock(&lport->lp_mutex);
+        __fc_linkdown(lport);
         mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkdown);
 
 /**
  * fc_fabric_logoff() - Logout of the fabric
- * @lport:            fc_lport pointer to logoff the fabric
+ * @lport: The local port to logoff the fabric
  *
  * Return value:
  *      0 for success, -1 for failure
@@ -540,8 +622,8 @@ int fc_fabric_logoff(struct fc_lport *lport)
 {
         lport->tt.disc_stop_final(lport);
         mutex_lock(&lport->lp_mutex);
-        if (lport->dns_rp)
-                lport->tt.rport_logoff(lport->dns_rp);
+        if (lport->dns_rdata)
+                lport->tt.rport_logoff(lport->dns_rdata);
         mutex_unlock(&lport->lp_mutex);
         lport->tt.rport_flush_queue();
         mutex_lock(&lport->lp_mutex);
@@ -553,11 +635,9 @@ int fc_fabric_logoff(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_fabric_logoff);
 
 /**
- * fc_lport_destroy() - unregister a fc_lport
- * @lport:            fc_lport pointer to unregister
+ * fc_lport_destroy() - Unregister a fc_lport
+ * @lport: The local port to unregister
  *
- * Return value:
- *      None
  * Note:
  * exit routine for fc_lport instance
  * clean-up all the allocated memory
@@ -580,13 +660,9 @@ int fc_lport_destroy(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_lport_destroy);
 
 /**
- * fc_set_mfs() - sets up the mfs for the corresponding fc_lport
- * @lport: fc_lport pointer to unregister
- * @mfs: the new mfs for fc_lport
- *
- * Set mfs for the given fc_lport to the new mfs.
- *
- * Return: 0 for success
+ * fc_set_mfs() - Set the maximum frame size for a local port
+ * @lport: The local port to set the MFS for
+ * @mfs:   The new MFS
  */
 int fc_set_mfs(struct fc_lport *lport, u32 mfs)
 {
@@ -617,7 +693,7 @@ EXPORT_SYMBOL(fc_set_mfs);
 
 /**
  * fc_lport_disc_callback() - Callback for discovery events
- * @lport: FC local port
+ * @lport: The local port receiving the event
  * @event: The discovery event
  */
 void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
@@ -627,8 +703,9 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
                 FC_LPORT_DBG(lport, "Discovery succeeded\n");
                 break;
         case DISC_EV_FAILED:
-                printk(KERN_ERR "libfc: Discovery failed for port (%6x)\n",
-                       fc_host_port_id(lport->host));
+                printk(KERN_ERR "host%d: libfc: "
+                       "Discovery failed for port (%6x)\n",
+                       lport->host->host_no, fc_host_port_id(lport->host));
                 mutex_lock(&lport->lp_mutex);
                 fc_lport_enter_reset(lport);
                 mutex_unlock(&lport->lp_mutex);
@@ -641,7 +718,7 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
 
 /**
  * fc_rport_enter_ready() - Enter the ready state and start discovery
- * @lport: Fibre Channel local port that is ready
+ * @lport: The local port that is ready
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -652,22 +729,46 @@ static void fc_lport_enter_ready(struct fc_lport *lport)
                      fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_READY);
+        if (lport->vport)
+                fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE);
+        fc_vports_linkchange(lport);
 
-        if (!lport->ptp_rp)
+        if (!lport->ptp_rdata)
                 lport->tt.disc_start(fc_lport_disc_callback, lport);
 }
 
 /**
+ * fc_lport_set_port_id() - set the local port Port ID
+ * @lport: The local port which will have its Port ID set.
+ * @port_id: The new port ID.
+ * @fp: The frame containing the incoming request, or NULL.
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this function.
+ */
+static void fc_lport_set_port_id(struct fc_lport *lport, u32 port_id,
+                                 struct fc_frame *fp)
+{
+        if (port_id)
+                printk(KERN_INFO "host%d: Assigned Port ID %6x\n",
+                       lport->host->host_no, port_id);
+
+        fc_host_port_id(lport->host) = port_id;
+        if (lport->tt.lport_set_port_id)
+                lport->tt.lport_set_port_id(lport, port_id, fp);
+}
+
+/**
  * 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
+ * @rx_fp: The FLOGI frame
+ * @lport: The local port 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
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
@@ -695,8 +796,9 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                 goto out;
         remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
         if (remote_wwpn == lport->wwpn) {
-                printk(KERN_WARNING "libfc: Received FLOGI from port "
-                       "with same WWPN %llx\n", remote_wwpn);
+                printk(KERN_WARNING "host%d: libfc: Received FLOGI from port "
+                       "with same WWPN %llx\n",
+                       lport->host->host_no, remote_wwpn);
                 goto out;
         }
         FC_LPORT_DBG(lport, "FLOGI from port WWPN %llx\n", remote_wwpn);
@@ -715,7 +817,7 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                 remote_fid = FC_LOCAL_PTP_FID_HI;
         }
 
-        fc_host_port_id(lport->host) = local_fid;
+        fc_lport_set_port_id(lport, local_fid, rx_fp);
 
         fp = fc_frame_alloc(lport, sizeof(*flp));
         if (fp) {
@@ -747,9 +849,9 @@ out:
 
 /**
  * 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
+ * @lport: The local port that received the request
+ * @sp:    The sequence the request is on
+ * @fp:    The request frame
  *
  * This function will see if the lport handles the request or
  * if an rport should handle the request.
@@ -817,8 +919,8 @@ static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
 }
 
 /**
- * fc_lport_reset() - Reset an lport
- * @lport: The lport which should be reset
+ * fc_lport_reset() - Reset a local port
+ * @lport: The local port which should be reset
  *
  * Locking Note: This functions should not be called with the
  *               lport lock held.
@@ -834,29 +936,31 @@ int fc_lport_reset(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_lport_reset);
 
 /**
- * fc_lport_reset_locked() - Reset the local port
- * @lport: Fibre Channel local port to be reset
+ * fc_lport_reset_locked() - Reset the local port w/ the lport lock held
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
  */
 static void fc_lport_reset_locked(struct fc_lport *lport)
 {
-        if (lport->dns_rp)
-                lport->tt.rport_logoff(lport->dns_rp);
+        if (lport->dns_rdata)
+                lport->tt.rport_logoff(lport->dns_rdata);
 
-        lport->ptp_rp = NULL;
+        lport->ptp_rdata = NULL;
 
         lport->tt.disc_stop(lport);
 
         lport->tt.exch_mgr_reset(lport, 0, 0);
         fc_host_fabric_name(lport->host) = 0;
-        fc_host_port_id(lport->host) = 0;
+
+        if (fc_host_port_id(lport->host))
+                fc_lport_set_port_id(lport, 0, NULL);
 }
 
 /**
  * fc_lport_enter_reset() - Reset the local port
- * @lport: Fibre Channel local port to be reset
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -866,15 +970,25 @@ static void fc_lport_enter_reset(struct fc_lport *lport)
         FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
                      fc_lport_state(lport));
 
+        if (lport->state == LPORT_ST_DISABLED || lport->state == LPORT_ST_LOGO)
+                return;
+
+        if (lport->vport) {
+                if (lport->link_up)
+                        fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING);
+                else
+                        fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN);
+        }
         fc_lport_state_enter(lport, LPORT_ST_RESET);
+        fc_vports_linkchange(lport);
         fc_lport_reset_locked(lport);
         if (lport->link_up)
                 fc_lport_enter_flogi(lport);
 }
 
 /**
- * fc_lport_enter_disabled() - disable the local port
- * @lport: Fibre Channel local port to be reset
+ * fc_lport_enter_disabled() - Disable the local port
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -885,13 +999,14 @@ static void fc_lport_enter_disabled(struct fc_lport *lport)
                      fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_DISABLED);
+        fc_vports_linkchange(lport);
         fc_lport_reset_locked(lport);
 }
 
 /**
  * fc_lport_error() - Handler for any errors
- * @lport: The fc_lport object
- * @fp: The frame pointer
+ * @lport: The local port that the error was on
+ * @fp:    The error code encoded in a frame pointer
  *
  * If the error was caused by a resource allocation failure
  * then wait for half a second and retry, otherwise retry
@@ -922,8 +1037,11 @@ static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
                         case LPORT_ST_DISABLED:
                         case LPORT_ST_READY:
                         case LPORT_ST_RESET:
-                        case LPORT_ST_RPN_ID:
+                        case LPORT_ST_RNN_ID:
+                        case LPORT_ST_RSNN_NN:
+                        case LPORT_ST_RSPN_ID:
                         case LPORT_ST_RFT_ID:
+                        case LPORT_ST_RFF_ID:
                         case LPORT_ST_SCR:
                         case LPORT_ST_DNS:
                         case LPORT_ST_FLOGI:
@@ -936,33 +1054,33 @@ static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
 }
 
 /**
- * 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
+ * fc_lport_ns_resp() - Handle response to a name server
+ *                      registration exchange
+ * @sp:     current sequence in 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
+ * 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)
+static void fc_lport_ns_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;
 
-        FC_LPORT_DBG(lport, "Received a RFT_ID %s\n", fc_els_resp_type(fp));
+        FC_LPORT_DBG(lport, "Received a ns %s\n", fc_els_resp_type(fp));
 
         if (fp == ERR_PTR(-FC_EX_CLOSED))
                 return;
 
         mutex_lock(&lport->lp_mutex);
 
-        if (lport->state != LPORT_ST_RFT_ID) {
-                FC_LPORT_DBG(lport, "Received a RFT_ID response, but in state "
-                             "%s\n", fc_lport_state(lport));
+        if (lport->state < LPORT_ST_RNN_ID || lport->state > LPORT_ST_RFF_ID) {
+                FC_LPORT_DBG(lport, "Received a name server response, "
+                             "but in state %s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -980,63 +1098,28 @@ static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
             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:
-        fc_frame_free(fp);
-err:
-        mutex_unlock(&lport->lp_mutex);
-}
-
-/**
- * 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;
-
-        FC_LPORT_DBG(lport, "Received a RPN_ID %s\n", fc_els_resp_type(fp));
-
-        if (fp == ERR_PTR(-FC_EX_CLOSED))
-                return;
-
-        mutex_lock(&lport->lp_mutex);
-
-        if (lport->state != LPORT_ST_RPN_ID) {
-                FC_LPORT_DBG(lport, "Received a RPN_ID response, but in state "
-                             "%s\n", fc_lport_state(lport));
-                if (IS_ERR(fp))
-                        goto err;
-                goto out;
-        }
-
-        if (IS_ERR(fp)) {
-                fc_lport_error(lport, fp);
-                goto err;
-        }
-
-        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);
+                switch (lport->state) {
+                case LPORT_ST_RNN_ID:
+                        fc_lport_enter_ns(lport, LPORT_ST_RSNN_NN);
+                        break;
+                case LPORT_ST_RSNN_NN:
+                        fc_lport_enter_ns(lport, LPORT_ST_RSPN_ID);
+                        break;
+                case LPORT_ST_RSPN_ID:
+                        fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+                        break;
+                case LPORT_ST_RFT_ID:
+                        fc_lport_enter_ns(lport, LPORT_ST_RFF_ID);
+                        break;
+                case LPORT_ST_RFF_ID:
+                        fc_lport_enter_scr(lport);
+                        break;
+                default:
+                        /* should have already been caught by state checks */
+                        break;
+                }
         else
                 fc_lport_error(lport, fp);
-
 out:
         fc_frame_free(fp);
 err:
@@ -1045,8 +1128,8 @@ err:
 
 /**
  * fc_lport_scr_resp() - Handle response to State Change Register (SCR) request
- * @sp: current sequence in SCR exchange
- * @fp: response frame
+ * @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
@@ -1092,8 +1175,8 @@ err:
 }
 
 /**
- * fc_lport_enter_scr() - Send a State Change Register (SCR) request
- * @lport: Fibre Channel local port to register for state changes
+ * fc_lport_enter_scr() - Send a SCR (State Change Register) request
+ * @lport: The local port to register for state changes
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1114,78 +1197,74 @@ static void fc_lport_enter_scr(struct fc_lport *lport)
         }
 
         if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR,
-                                  fc_lport_scr_resp, lport, lport->e_d_tov))
-                fc_lport_error(lport, fp);
+                                  fc_lport_scr_resp, lport,
+                                  2 * lport->r_a_tov))
+                fc_lport_error(lport, NULL);
 }
 
 /**
- * fc_lport_enter_rft_id() - Register FC4-types with the name server
+ * fc_lport_enter_ns() - register some object 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)
+static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state)
 {
         struct fc_frame *fp;
-        struct fc_ns_fts *lps;
-        int i;
+        enum fc_ns_req cmd;
+        int size = sizeof(struct fc_ct_hdr);
+        size_t len;
 
-        FC_LPORT_DBG(lport, "Entered RFT_ID state from %s state\n",
+        FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
+                     fc_lport_state_names[state],
                      fc_lport_state(lport));
 
-        fc_lport_state_enter(lport, LPORT_ST_RFT_ID);
+        fc_lport_state_enter(lport, state);
 
-        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);
-                return;
-        }
-
-        fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
-                            sizeof(struct fc_ns_rft));
-        if (!fp) {
-                fc_lport_error(lport, fp);
+        switch (state) {
+        case LPORT_ST_RNN_ID:
+                cmd = FC_NS_RNN_ID;
+                size += sizeof(struct fc_ns_rn_id);
+                break;
+        case LPORT_ST_RSNN_NN:
+                len = strnlen(fc_host_symbolic_name(lport->host), 255);
+                /* if there is no symbolic name, skip to RFT_ID */
+                if (!len)
+                        return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+                cmd = FC_NS_RSNN_NN;
+                size += sizeof(struct fc_ns_rsnn) + len;
+                break;
+        case LPORT_ST_RSPN_ID:
+                len = strnlen(fc_host_symbolic_name(lport->host), 255);
+                /* if there is no symbolic name, skip to RFT_ID */
+                if (!len)
+                        return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+                cmd = FC_NS_RSPN_ID;
+                size += sizeof(struct fc_ns_rspn) + len;
+                break;
+        case LPORT_ST_RFT_ID:
+                cmd = FC_NS_RFT_ID;
+                size += sizeof(struct fc_ns_rft);
+                break;
+        case LPORT_ST_RFF_ID:
+                cmd = FC_NS_RFF_ID;
+                size += sizeof(struct fc_ns_rff_id);
+                break;
+        default:
+                fc_lport_error(lport, NULL);
                 return;
         }
 
-        if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RFT_ID,
-                                  fc_lport_rft_id_resp,
-                                  lport, lport->e_d_tov))
-                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;
-
-        FC_LPORT_DBG(lport, "Entered RPN_ID state from %s state\n",
-                     fc_lport_state(lport));
-
-        fc_lport_state_enter(lport, LPORT_ST_RPN_ID);
-
-        fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
-                            sizeof(struct fc_ns_rn_id));
+        fp = fc_frame_alloc(lport, size);
         if (!fp) {
                 fc_lport_error(lport, fp);
                 return;
         }
 
-        if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RPN_ID,
-                                  fc_lport_rpn_id_resp,
-                                  lport, lport->e_d_tov))
+        if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd,
+                                  fc_lport_ns_resp,
+                                  lport, 3 * lport->r_a_tov))
                 fc_lport_error(lport, fp);
 }
 
@@ -1194,8 +1273,8 @@ static struct fc_rport_operations fc_lport_rport_ops = {
 };
 
 /**
- * fc_rport_enter_dns() - Create a rport to the name server
- * @lport: Fibre Channel local port requesting a rport for the name server
+ * fc_rport_enter_dns() - Create a fc_rport for the name server
+ * @lport: The local port requesting a remote port for the name server
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1224,8 +1303,8 @@ err:
 }
 
 /**
- * fc_lport_timeout() - Handler for the retry_work timer.
- * @work: The work struct of the fc_lport
+ * fc_lport_timeout() - Handler for the retry_work timer
+ * @work: The work struct of the local port
  */
 static void fc_lport_timeout(struct work_struct *work)
 {
@@ -1237,21 +1316,25 @@ static void fc_lport_timeout(struct work_struct *work)
 
         switch (lport->state) {
         case LPORT_ST_DISABLED:
+                WARN_ON(1);
+                break;
         case LPORT_ST_READY:
-        case LPORT_ST_RESET:
                 WARN_ON(1);
                 break;
+        case LPORT_ST_RESET:
+                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_RNN_ID:
+        case LPORT_ST_RSNN_NN:
+        case LPORT_ST_RSPN_ID:
         case LPORT_ST_RFT_ID:
-                fc_lport_enter_rft_id(lport);
+        case LPORT_ST_RFF_ID:
+                fc_lport_enter_ns(lport, lport->state);
                 break;
         case LPORT_ST_SCR:
                 fc_lport_enter_scr(lport);
@@ -1266,16 +1349,16 @@ static void fc_lport_timeout(struct work_struct *work)
 
 /**
  * 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
+ * @sp:     The sequence that the LOGO was on
+ * @fp:     The LOGO frame
+ * @lp_arg: The lport port that received 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
+ * 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)
+void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
+                        void *lp_arg)
 {
         struct fc_lport *lport = lp_arg;
         u8 op;
@@ -1311,10 +1394,11 @@ out:
 err:
         mutex_unlock(&lport->lp_mutex);
 }
+EXPORT_SYMBOL(fc_lport_logo_resp);
 
 /**
  * fc_rport_enter_logo() - Logout of the fabric
- * @lport: Fibre Channel local port to be logged out
+ * @lport: The local port to be logged out
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1328,6 +1412,7 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
                      fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_LOGO);
+        fc_vports_linkchange(lport);
 
         fp = fc_frame_alloc(lport, sizeof(*logo));
         if (!fp) {
@@ -1336,22 +1421,23 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
         }
 
         if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO,
-                                  fc_lport_logo_resp, lport, lport->e_d_tov))
-                fc_lport_error(lport, fp);
+                                  fc_lport_logo_resp, lport,
+                                  2 * lport->r_a_tov))
+                fc_lport_error(lport, NULL);
 }
 
 /**
  * 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
+ * @sp:     The sequence that the FLOGI was on
+ * @fp:     The FLOGI response frame
+ * @lp_arg: The lport port that received the FLOGI response
  *
  * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
+ * 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)
+void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
+                         void *lp_arg)
 {
         struct fc_lport *lport = lp_arg;
         struct fc_frame_header *fh;
@@ -1385,11 +1471,6 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
         fh = fc_frame_header_get(fp);
         did = ntoh24(fh->fh_d_id);
         if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
-
-                printk(KERN_INFO "libfc: Assigned FID (%6x) in FLOGI response\n",
-                       did);
-                fc_host_port_id(lport->host) = did;
-
                 flp = fc_frame_payload_get(fp, sizeof(*flp));
                 if (flp) {
                         mfs = ntohs(flp->fl_csp.sp_bb_data) &
@@ -1402,12 +1483,18 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                         e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
                         if (csp_flags & FC_SP_FT_EDTR)
                                 e_d_tov /= 1000000;
+
+                        lport->npiv_enabled = !!(csp_flags & FC_SP_FT_NPIV_ACC);
+
                         if ((csp_flags & FC_SP_FT_FPORT) == 0) {
                                 if (e_d_tov > lport->e_d_tov)
                                         lport->e_d_tov = e_d_tov;
                                 lport->r_a_tov = 2 * e_d_tov;
-                                printk(KERN_INFO "libfc: Port (%6x) entered "
-                                       "point to point mode\n", did);
+                                fc_lport_set_port_id(lport, did, fp);
+                                printk(KERN_INFO "host%d: libfc: "
+                                       "Port (%6x) entered "
+                                       "point-to-point mode\n",
+                                       lport->host->host_no, did);
                                 fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
                                                    get_unaligned_be64(
                                                            &flp->fl_wwpn),
@@ -1418,6 +1505,7 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                                 lport->r_a_tov = r_a_tov;
                                 fc_host_fabric_name(lport->host) =
                                         get_unaligned_be64(&flp->fl_wwnn);
+                                fc_lport_set_port_id(lport, did, fp);
                                 fc_lport_enter_dns(lport);
                         }
                 }
@@ -1430,6 +1518,7 @@ out:
 err:
         mutex_unlock(&lport->lp_mutex);
 }
+EXPORT_SYMBOL(fc_lport_flogi_resp);
 
 /**
  * fc_rport_enter_flogi() - Send a FLOGI request to the fabric manager
@@ -1451,12 +1540,18 @@ void fc_lport_enter_flogi(struct fc_lport *lport)
         if (!fp)
                 return fc_lport_error(lport, fp);
 
-        if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_FLOGI,
-                                  fc_lport_flogi_resp, lport, lport->e_d_tov))
-                fc_lport_error(lport, fp);
+        if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
+                                  lport->vport ? ELS_FDISC : ELS_FLOGI,
+                                  fc_lport_flogi_resp, lport,
+                                  lport->vport ? 2 * lport->r_a_tov :
+                                  lport->e_d_tov))
+                fc_lport_error(lport, NULL);
 }
 
-/* Configure a fc_lport */
+/**
+ * fc_lport_config() - Configure a fc_lport
+ * @lport: The local port to be configured
+ */
 int fc_lport_config(struct fc_lport *lport)
 {
         INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
@@ -1471,6 +1566,10 @@ int fc_lport_config(struct fc_lport *lport)
 }
 EXPORT_SYMBOL(fc_lport_config);
 
+/**
+ * fc_lport_init() - Initialize the lport layer for a local port
+ * @lport: The local port to initialize the exchange layer for
+ */
 int fc_lport_init(struct fc_lport *lport)
 {
         if (!lport->tt.lport_recv)
@@ -1500,7 +1599,254 @@ int fc_lport_init(struct fc_lport *lport)
         if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
                 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
 
-        INIT_LIST_HEAD(&lport->ema_list);
         return 0;
 }
 EXPORT_SYMBOL(fc_lport_init);
+
+/**
+ * fc_lport_bsg_resp() - The common response handler for FC Passthrough requests
+ * @sp:       The sequence for the FC Passthrough response
+ * @fp:       The response frame
+ * @info_arg: The BSG info that the response is for
+ */
+static void fc_lport_bsg_resp(struct fc_seq *sp, struct fc_frame *fp,
+                              void *info_arg)
+{
+        struct fc_bsg_info *info = info_arg;
+        struct fc_bsg_job *job = info->job;
+        struct fc_lport *lport = info->lport;
+        struct fc_frame_header *fh;
+        size_t len;
+        void *buf;
+
+        if (IS_ERR(fp)) {
+                job->reply->result = (PTR_ERR(fp) == -FC_EX_CLOSED) ?
+                        -ECONNABORTED : -ETIMEDOUT;
+                job->reply_len = sizeof(uint32_t);
+                job->state_flags |= FC_RQST_STATE_DONE;
+                job->job_done(job);
+                kfree(info);
+                return;
+        }
+
+        mutex_lock(&lport->lp_mutex);
+        fh = fc_frame_header_get(fp);
+        len = fr_len(fp) - sizeof(*fh);
+        buf = fc_frame_payload_get(fp, 0);
+
+        if (fr_sof(fp) == FC_SOF_I3 && !ntohs(fh->fh_seq_cnt)) {
+                /* Get the response code from the first frame payload */
+                unsigned short cmd = (info->rsp_code == FC_FS_ACC) ?
+                        ntohs(((struct fc_ct_hdr *)buf)->ct_cmd) :
+                        (unsigned short)fc_frame_payload_op(fp);
+
+                /* Save the reply status of the job */
+                job->reply->reply_data.ctels_reply.status =
+                        (cmd == info->rsp_code) ?
+                        FC_CTELS_STATUS_OK : FC_CTELS_STATUS_REJECT;
+        }
+
+        job->reply->reply_payload_rcv_len +=
+                fc_copy_buffer_to_sglist(buf, len, info->sg, &info->nents,
+                                         &info->offset, KM_BIO_SRC_IRQ, NULL);
+
+        if (fr_eof(fp) == FC_EOF_T &&
+            (ntoh24(fh->fh_f_ctl) & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
+            (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
+                if (job->reply->reply_payload_rcv_len >
+                    job->reply_payload.payload_len)
+                        job->reply->reply_payload_rcv_len =
+                                job->reply_payload.payload_len;
+                job->reply->result = 0;
+                job->state_flags |= FC_RQST_STATE_DONE;
+                job->job_done(job);
+                kfree(info);
+        }
+        fc_frame_free(fp);
+        mutex_unlock(&lport->lp_mutex);
+}
+
+/**
+ * fc_lport_els_request() - Send ELS passthrough request
+ * @job:   The BSG Passthrough job
+ * @lport: The local port sending the request
+ * @did:   The destination port id
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static int fc_lport_els_request(struct fc_bsg_job *job,
+                                struct fc_lport *lport,
+                                u32 did, u32 tov)
+{
+        struct fc_bsg_info *info;
+        struct fc_frame *fp;
+        struct fc_frame_header *fh;
+        char *pp;
+        int len;
+
+        fp = fc_frame_alloc(lport, job->request_payload.payload_len);
+        if (!fp)
+                return -ENOMEM;
+
+        len = job->request_payload.payload_len;
+        pp = fc_frame_payload_get(fp, len);
+
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                          job->request_payload.sg_cnt,
+                          pp, len);
+
+        fh = fc_frame_header_get(fp);
+        fh->fh_r_ctl = FC_RCTL_ELS_REQ;
+        hton24(fh->fh_d_id, did);
+        hton24(fh->fh_s_id, fc_host_port_id(lport->host));
+        fh->fh_type = FC_TYPE_ELS;
+        hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
+               FC_FC_END_SEQ | FC_FC_SEQ_INIT);
+        fh->fh_cs_ctl = 0;
+        fh->fh_df_ctl = 0;
+        fh->fh_parm_offset = 0;
+
+        info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
+        if (!info) {
+                fc_frame_free(fp);
+                return -ENOMEM;
+        }
+
+        info->job = job;
+        info->lport = lport;
+        info->rsp_code = ELS_LS_ACC;
+        info->nents = job->reply_payload.sg_cnt;
+        info->sg = job->reply_payload.sg_list;
+
+        if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
+                                     NULL, info, tov))
+                return -ECOMM;
+        return 0;
+}
+
+/**
+ * fc_lport_ct_request() - Send CT Passthrough request
+ * @job:   The BSG Passthrough job
+ * @lport: The local port sending the request
+ * @did:   The destination FC-ID
+ * @tov:   The timeout period to wait for the response
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static int fc_lport_ct_request(struct fc_bsg_job *job,
+                               struct fc_lport *lport, u32 did, u32 tov)
+{
+        struct fc_bsg_info *info;
+        struct fc_frame *fp;
+        struct fc_frame_header *fh;
+        struct fc_ct_req *ct;
+        size_t len;
+
+        fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
+                            job->request_payload.payload_len);
+        if (!fp)
+                return -ENOMEM;
+
+        len = job->request_payload.payload_len;
+        ct = fc_frame_payload_get(fp, len);
+
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                          job->request_payload.sg_cnt,
+                          ct, len);
+
+        fh = fc_frame_header_get(fp);
+        fh->fh_r_ctl = FC_RCTL_DD_UNSOL_CTL;
+        hton24(fh->fh_d_id, did);
+        hton24(fh->fh_s_id, fc_host_port_id(lport->host));
+        fh->fh_type = FC_TYPE_CT;
+        hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
+               FC_FC_END_SEQ | FC_FC_SEQ_INIT);
+        fh->fh_cs_ctl = 0;
+        fh->fh_df_ctl = 0;
+        fh->fh_parm_offset = 0;
+
+        info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
+        if (!info) {
+                fc_frame_free(fp);
+                return -ENOMEM;
+        }
+
+        info->job = job;
+        info->lport = lport;
+        info->rsp_code = FC_FS_ACC;
+        info->nents = job->reply_payload.sg_cnt;
+        info->sg = job->reply_payload.sg_list;
+
+        if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
+                                     NULL, info, tov))
+                return -ECOMM;
+        return 0;
+}
+
+/**
+ * fc_lport_bsg_request() - The common entry point for sending
+ *                          FC Passthrough requests
+ * @job: The BSG passthrough job
+ */
+int fc_lport_bsg_request(struct fc_bsg_job *job)
+{
+        struct request *rsp = job->req->next_rq;
+        struct Scsi_Host *shost = job->shost;
+        struct fc_lport *lport = shost_priv(shost);
+        struct fc_rport *rport;
+        struct fc_rport_priv *rdata;
+        int rc = -EINVAL;
+        u32 did;
+
+        job->reply->reply_payload_rcv_len = 0;
+        if (rsp)
+                rsp->resid_len = job->reply_payload.payload_len;
+
+        mutex_lock(&lport->lp_mutex);
+
+        switch (job->request->msgcode) {
+        case FC_BSG_RPT_ELS:
+                rport = job->rport;
+                if (!rport)
+                        break;
+
+                rdata = rport->dd_data;
+                rc = fc_lport_els_request(job, lport, rport->port_id,
+                                          rdata->e_d_tov);
+                break;
+
+        case FC_BSG_RPT_CT:
+                rport = job->rport;
+                if (!rport)
+                        break;
+
+                rdata = rport->dd_data;
+                rc = fc_lport_ct_request(job, lport, rport->port_id,
+                                         rdata->e_d_tov);
+                break;
+
+        case FC_BSG_HST_CT:
+                did = ntoh24(job->request->rqst_data.h_ct.port_id);
+                if (did == FC_FID_DIR_SERV)
+                        rdata = lport->dns_rdata;
+                else
+                        rdata = lport->tt.rport_lookup(lport, did);
+
+                if (!rdata)
+                        break;
+
+                rc = fc_lport_ct_request(job, lport, did, rdata->e_d_tov);
+                break;
+
+        case FC_BSG_HST_ELS_NOLOGIN:
+                did = ntoh24(job->request->rqst_data.h_els.port_id);
+                rc = fc_lport_els_request(job, lport, did, lport->e_d_tov);
+                break;
+        }
+
+        mutex_unlock(&lport->lp_mutex);
+        return rc;
+}
+EXPORT_SYMBOL(fc_lport_bsg_request);