--- /dev/null
+From: Hannes Reinecke <hare@suse.de>
+Date: Wed, 17 Sep 2008 16:24:37 +0200
+Subject: libfc: a modular software Fibre Channel implementation
+References: FATE#303913
+
+Signed-off-by: Robert Love <robert.w.love@intel.com>
+Signed-off-by: Chris Leech <christopher.leech@intel.com>
+Signed-off-by: Vasu Dev <vasu.dev@intel.com>
+Signed-off-by: Yi Zou <yi.zou@intel.com>
+Signed-off-by: Steve Ma <steve.ma@intel.com>
+Signed-off-by: Hannes Reinecke <hare@suse.de>
+---
+ drivers/scsi/Kconfig | 6 +
+ drivers/scsi/Makefile | 1 +
+ drivers/scsi/libfc/Makefile | 12 +
+ drivers/scsi/libfc/fc_attr.c | 129 +++
+ drivers/scsi/libfc/fc_exch.c | 2028 ++++++++++++++++++++++++++++++++++++++
+ drivers/scsi/libfc/fc_fcp.c | 2173 +++++++++++++++++++++++++++++++++++++++++
+ drivers/scsi/libfc/fc_frame.c | 88 ++
+ drivers/scsi/libfc/fc_lport.c | 926 ++++++++++++++++++
+ drivers/scsi/libfc/fc_ns.c | 1283 ++++++++++++++++++++++++
+ drivers/scsi/libfc/fc_rport.c | 1301 ++++++++++++++++++++++++
+ 10 files changed, 7947 insertions(+), 0 deletions(-)
+ create mode 100644 drivers/scsi/libfc/Makefile
+ create mode 100644 drivers/scsi/libfc/fc_attr.c
+ create mode 100644 drivers/scsi/libfc/fc_exch.c
+ create mode 100644 drivers/scsi/libfc/fc_fcp.c
+ create mode 100644 drivers/scsi/libfc/fc_frame.c
+ create mode 100644 drivers/scsi/libfc/fc_lport.c
+ create mode 100644 drivers/scsi/libfc/fc_ns.c
+ create mode 100644 drivers/scsi/libfc/fc_rport.c
+
+diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
+index 4e0322b..bd480d2 100644
+--- a/drivers/scsi/Kconfig
++++ b/drivers/scsi/Kconfig
+@@ -328,6 +328,12 @@ menuconfig SCSI_LOWLEVEL
+
+ if SCSI_LOWLEVEL && SCSI
+
++config LIBFC
++ tristate "LibFC module"
++ depends on SCSI && SCSI_FC_ATTRS
++ ---help---
++ Fibre Channel library module
++
+ config ISCSI_TCP
+ tristate "iSCSI Initiator over TCP/IP"
+ depends on SCSI && INET
+diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
+index 72fd504..9158dc6 100644
+--- a/drivers/scsi/Makefile
++++ b/drivers/scsi/Makefile
+@@ -36,6 +36,7 @@ obj-$(CONFIG_SCSI_SAS_LIBSAS) += libsas/
+ obj-$(CONFIG_SCSI_SRP_ATTRS) += scsi_transport_srp.o
+ obj-$(CONFIG_SCSI_DH) += device_handler/
+
++obj-$(CONFIG_LIBFC) += libfc/
+ obj-$(CONFIG_ISCSI_TCP) += libiscsi.o iscsi_tcp.o
+ obj-$(CONFIG_INFINIBAND_ISER) += libiscsi.o
+ obj-$(CONFIG_SCSI_A4000T) += 53c700.o a4000t.o
+diff --git a/drivers/scsi/libfc/Makefile b/drivers/scsi/libfc/Makefile
+new file mode 100644
+index 0000000..0a31ca2
+--- /dev/null
++++ b/drivers/scsi/libfc/Makefile
+@@ -0,0 +1,12 @@
++# $Id: Makefile
++
++obj-$(CONFIG_LIBFC) += libfc.o
++
++libfc-objs := \
++ fc_ns.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
+new file mode 100644
+index 0000000..d73f39e
+--- /dev/null
++++ b/drivers/scsi/libfc/fc_attr.c
+@@ -0,0 +1,129 @@
++/*
++ * 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_exch.c b/drivers/scsi/libfc/fc_exch.c
+new file mode 100644
+index 0000000..11a03bd
+--- /dev/null
++++ b/drivers/scsi/libfc/fc_exch.c
+@@ -0,0 +1,2028 @@
++/*
++ * 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
++ */
++
++/*
++ * Fibre Channel exchange and sequence handling.
++ */
++
++#include <linux/timer.h>
++#include <linux/gfp.h>
++#include <linux/err.h>
++
++#include <scsi/fc/fc_fc2.h>
++
++#include <scsi/libfc/libfc.h>
++
++#define FC_DEF_R_A_TOV (10 * 1000) /* resource allocation timeout */
++
++/*
++ * fc_exch_debug can be set in debugger or at compile time to get more logs.
++ */
++static int fc_exch_debug;
++static struct kmem_cache *fc_em_cachep; /* cache for exchanges */
++
++/*
++ * Structure and function definitions for managing Fibre Channel Exchanges
++ * and Sequences.
++ *
++ * The three primary structures used here are fc_exch_mgr, fc_exch, and fc_seq.
++ *
++ * fc_exch_mgr holds the exchange state for an N port
++ *
++ * fc_exch holds state for one exchange and links to its active sequence.
++ *
++ * fc_seq holds the state for an individual sequence.
++ */
++
++/*
++ * Sequence.
++ */
++struct fc_seq {
++ u8 id; /* seq ID */
++ u16 ssb_stat; /* status flags for sequence status block */
++ u16 cnt; /* frames sent so far on sequence */
++ u32 f_ctl; /* F_CTL flags for frames */
++ u32 rec_data; /* FC-4 value for REC */
++};
++
++struct fc_exch;
++
++#define FC_EX_DONE (1 << 0) /* ep is completed */
++#define FC_EX_RST_CLEANUP (1 << 1) /* reset is forcing completion */
++
++/*
++ * Exchange.
++ *
++ * Locking notes: The ex_lock protects changes to the following fields:
++ * esb_stat, f_ctl, seq.ssb_stat, seq.f_ctl.
++ * seq_id
++ * sequence allocation
++ */
++struct fc_exch {
++ struct fc_exch_mgr *em; /* exchange manager */
++ u32 state; /* internal driver state */
++ u16 xid; /* our exchange ID */
++ struct list_head ex_list; /* free or busy list linkage */
++ spinlock_t ex_lock; /* lock covering exchange state */
++ atomic_t ex_refcnt; /* reference counter */
++ struct timer_list ex_timer; /* timer for upper level protocols */
++ struct fc_lport *lp; /* fc device instance */
++ u16 oxid; /* originator's exchange ID */
++ u16 rxid; /* responder's exchange ID */
++ u32 oid; /* originator's FCID */
++ u32 sid; /* source FCID */
++ u32 did; /* destination FCID */
++ u32 esb_stat; /* exchange status for ESB */
++ u32 r_a_tov; /* r_a_tov from rport (msec) */
++ u8 seq_id; /* next sequence ID to use */
++ u32 f_ctl; /* F_CTL flags for sequences */
++ 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 */
++};
++
++/*
++ * Exchange manager.
++ *
++ * This structure is the center for creating exchanges and sequences.
++ * It manages the allocation of exchange IDs.
++ */
++struct fc_exch_mgr {
++ enum fc_class class; /* default class for sequences */
++ spinlock_t em_lock; /* exchange manager lock */
++ u16 last_xid; /* last allocated exchange ID */
++ u16 min_xid; /* min exchange ID */
++ u16 max_xid; /* max exchange ID */
++ u32 total_exches; /* total allocated exchanges */
++ struct list_head ex_list; /* allocated exchanges list */
++ struct fc_lport *lp; /* fc device instance */
++ mempool_t *ep_pool; /* reserve ep's */
++
++ /*
++ * currently exchange mgr stats are updated but not used.
++ * either stats can be expose via sysfs or remove them
++ * all together if not used XXX
++ */
++ struct {
++ atomic_t no_free_exch;
++ atomic_t no_free_exch_xid;
++ atomic_t xid_not_found;
++ atomic_t xid_busy;
++ atomic_t seq_not_found;
++ atomic_t non_bls_resp;
++ } stats;
++ struct fc_exch **exches; /* for exch pointers indexed by xid */
++};
++
++#define fc_seq_exch(sp) container_of(sp, struct fc_exch, seq)
++#define fc_exch_next_xid(mp, id) ((id == mp->max_xid) ? mp->min_xid : id + 1)
++
++static void fc_exch_rrq(struct fc_exch *);
++static void fc_seq_ls_acc(struct fc_seq *);
++static void fc_seq_ls_rjt(struct fc_seq *, enum fc_els_rjt_reason,
++ enum fc_els_rjt_explan);
++static void fc_exch_els_rec(struct fc_seq *, struct fc_frame *);
++static void fc_exch_els_rrq(struct fc_seq *, struct fc_frame *);
++static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp);
++
++/*
++ * Internal implementation notes.
++ *
++ * The exchange manager is one by default in libfc but LLD may choose
++ * to have one per CPU. The sequence manager is one per exchange manager
++ * and currently never separated.
++ *
++ * Section 9.8 in FC-FS-2 specifies: "The SEQ_ID is a one-byte field
++ * assigned by the Sequence Initiator that shall be unique for a specific
++ * D_ID and S_ID pair while the Sequence is open." Note that it isn't
++ * qualified by exchange ID, which one might think it would be.
++ * In practice this limits the number of open sequences and exchanges to 256
++ * per session. For most targets we could treat this limit as per exchange.
++ *
++ * The exchange and its sequence are freed when the last sequence is received.
++ * It's possible for the remote port to leave an exchange open without
++ * sending any sequences.
++ *
++ * Notes on reference counts:
++ *
++ * Exchanges are reference counted and exchange gets freed when the reference
++ * count becomes zero.
++ *
++ * Timeouts:
++ * Sequences are timed out for E_D_TOV and R_A_TOV.
++ *
++ * Sequence event handling:
++ *
++ * The following events may occur on initiator sequences:
++ *
++ * Send.
++ * For now, the whole thing is sent.
++ * Receive ACK
++ * This applies only to class F.
++ * The sequence is marked complete.
++ * ULP completion.
++ * The upper layer calls fc_exch_done() when done
++ * with exchange and sequence tuple.
++ * RX-inferred completion.
++ * When we receive the next sequence on the same exchange, we can
++ * retire the previous sequence ID. (XXX not implemented).
++ * Timeout.
++ * R_A_TOV frees the sequence ID. If we're waiting for ACK,
++ * E_D_TOV causes abort and calls upper layer response handler
++ * with FC_EX_TIMEOUT error.
++ * Receive RJT
++ * XXX defer.
++ * Send ABTS
++ * On timeout.
++ *
++ * The following events may occur on recipient sequences:
++ *
++ * Receive
++ * Allocate sequence for first frame received.
++ * Hold during receive handler.
++ * Release when final frame received.
++ * Keep status of last N of these for the ELS RES command. XXX TBD.
++ * Receive ABTS
++ * Deallocate sequence
++ * Send RJT
++ * Deallocate
++ *
++ * For now, we neglect conditions where only part of a sequence was
++ * received or transmitted, or where out-of-order receipt is detected.
++ */
++
++/*
++ * Locking notes:
++ *
++ * The EM code run in a per-CPU worker thread.
++ *
++ * To protect against concurrency between a worker thread code and timers,
++ * sequence allocation and deallocation must be locked.
++ * - exchange refcnt can be done atomicly without locks.
++ * - sequence allocation must be locked by exch lock.
++ */
++
++/*
++ * opcode names for debugging.
++ */
++static char *fc_exch_rctl_names[] = FC_RCTL_NAMES_INIT;
++
++#define FC_TABLE_SIZE(x) (sizeof(x) / sizeof(x[0]))
++
++static inline const char *fc_exch_name_lookup(unsigned int op, char **table,
++ unsigned int max_index)
++{
++ const char *name = NULL;
++
++ if (op < max_index)
++ name = table[op];
++ if (!name)
++ name = "unknown";
++ return name;
++}
++
++static const char *fc_exch_rctl_name(unsigned int op)
++{
++ return fc_exch_name_lookup(op, fc_exch_rctl_names,
++ FC_TABLE_SIZE(fc_exch_rctl_names));
++}
++
++/*
++ * Hold an exchange - keep it from being freed.
++ */
++static void fc_exch_hold(struct fc_exch *ep)
++{
++ atomic_inc(&ep->ex_refcnt);
++}
++
++/*
++ * Fill in frame header.
++ *
++ * The following fields are the responsibility of this routine:
++ * d_id, s_id, df_ctl, oxid, rxid, cs_ctl, seq_id
++ *
++ * The following fields are handled by the caller.
++ * r_ctl, type, f_ctl, seq_cnt, parm_offset
++ *
++ * That should be a complete list.
++ *
++ * We may be the originator or responder to the sequence.
++ */
++static void fc_seq_fill_hdr(struct fc_seq *sp, struct fc_frame *fp)
++{
++ struct fc_frame_header *fh = fc_frame_header_get(fp);
++ struct fc_exch *ep;
++
++ ep = fc_seq_exch(sp);
++
++ hton24(fh->fh_s_id, ep->sid);
++ hton24(fh->fh_d_id, ep->did);
++ fh->fh_ox_id = htons(ep->oxid);
++ fh->fh_rx_id = htons(ep->rxid);
++ fh->fh_seq_id = sp->id;
++ fh->fh_cs_ctl = 0;
++ fh->fh_df_ctl = 0;
++}
++
++/*
++ * Release a reference to an exchange.
++ * If the refcnt goes to zero and the exchange is complete, it is freed.
++ */
++static void fc_exch_release(struct fc_exch *ep)
++{
++ struct fc_exch_mgr *mp;
++
++ if (atomic_dec_and_test(&ep->ex_refcnt)) {
++ mp = ep->em;
++ if (ep->lp->tt.exch_put)
++ ep->lp->tt.exch_put(ep->lp, mp, ep->xid);
++ WARN_ON(!ep->esb_stat & ESB_ST_COMPLETE);
++ WARN_ON(timer_pending(&ep->ex_timer));
++ mempool_free(ep, mp->ep_pool);
++ }
++}
++
++static int fc_exch_done_locked(struct fc_exch *ep)
++{
++ int rc = 1;
++
++ /*
++ * We must check for completion in case there are two threads
++ * tyring to complete this. But the rrq code will reuse the
++ * ep, and in that case we only clear the resp and set it as
++ * complete, so it can be reused by the timer to send the rrq.
++ */
++ ep->resp = NULL;
++ if (ep->state & FC_EX_DONE)
++ return rc;
++ ep->esb_stat |= ESB_ST_COMPLETE;
++
++ if (!(ep->esb_stat & ESB_ST_REC_QUAL)) {
++ 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;
++}
++
++static void fc_exch_mgr_delete_ep(struct fc_exch *ep)
++{
++ struct fc_exch_mgr *mp;
++
++ mp = ep->em;
++ spin_lock_bh(&mp->em_lock);
++ WARN_ON(mp->total_exches <= 0);
++ mp->total_exches--;
++ mp->exches[ep->xid - mp->min_xid] = NULL;
++ list_del(&ep->ex_list);
++ spin_unlock_bh(&mp->em_lock);
++}
++
++/*
++ * Internal version of fc_exch_timer_set - used with lock held.
++ */
++static inline void fc_exch_timer_set_locked(struct fc_exch *ep,
++ unsigned int timer_msec)
++{
++ if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
++ return;
++
++ if (!mod_timer(&ep->ex_timer, jiffies + msecs_to_jiffies(timer_msec)))
++ fc_exch_hold(ep); /* hold for timer */
++}
++
++/*
++ * Set timer for an exchange.
++ * The time is a minimum delay in milliseconds until the timer fires.
++ * Used for upper level protocols to time out the exchange.
++ * The timer is cancelled when it fires or when the exchange completes.
++ * Returns non-zero if a timer couldn't be allocated.
++ */
++static void fc_exch_timer_set(struct fc_exch *ep, unsigned int timer_msec)
++{
++ spin_lock_bh(&ep->ex_lock);
++ fc_exch_timer_set_locked(ep, timer_msec);
++ spin_unlock_bh(&ep->ex_lock);
++}
++
++int fc_seq_exch_abort(const struct fc_seq *req_sp, unsigned int timer_msec)
++{
++ struct fc_seq *sp;
++ struct fc_exch *ep;
++ struct fc_frame *fp;
++ int error;
++
++ ep = fc_seq_exch(req_sp);
++
++ spin_lock_bh(&ep->ex_lock);
++ if (ep->esb_stat & (ESB_ST_COMPLETE | ESB_ST_ABNORMAL) ||
++ ep->state & (FC_EX_DONE | FC_EX_RST_CLEANUP)) {
++ spin_unlock_bh(&ep->ex_lock);
++ return -ENXIO;
++ }
++
++ /*
++ * Send the abort on a new sequence if possible.
++ */
++ sp = fc_seq_start_next_locked(&ep->seq);
++ if (!sp) {
++ spin_unlock_bh(&ep->ex_lock);
++ return -ENOMEM;
++ }
++
++ sp->f_ctl |= FC_FC_SEQ_INIT;
++ ep->esb_stat |= ESB_ST_SEQ_INIT | ESB_ST_ABNORMAL;
++ if (timer_msec)
++ fc_exch_timer_set_locked(ep, timer_msec);
++ spin_unlock_bh(&ep->ex_lock);
++
++ /*
++ * If not logged into the fabric, don't send ABTS but leave
++ * sequence active until next timeout.
++ */
++ if (!ep->sid)
++ return 0;
++
++ /*
++ * Send an abort for the sequence that timed out.
++ */
++ fp = fc_frame_alloc(ep->lp, 0);
++ if (fp) {
++ fc_frame_setup(fp, FC_RCTL_BA_ABTS, FC_TYPE_BLS);
++ error = fc_seq_send(ep->lp, sp, fp, FC_FC_END_SEQ);
++ } else
++ error = -ENOBUFS;
++ return error;
++}
++EXPORT_SYMBOL(fc_seq_exch_abort);
++
++/*
++ * Exchange timeout - handle exchange timer expiration.
++ * The timer will have been cancelled before this is called.
++ */
++static void fc_exch_timeout(unsigned long ep_arg)
++{
++ struct fc_exch *ep = (struct fc_exch *)ep_arg;
++ struct fc_seq *sp = &ep->seq;
++ void (*resp)(struct fc_seq *, struct fc_frame *fp, void *arg);
++ void *arg;
++ u32 e_stat;
++ int rc = 1;
++
++ spin_lock_bh(&ep->ex_lock);
++ if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
++ goto unlock;
++
++ 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);
++ goto done;
++ } else {
++ resp = ep->resp;
++ arg = ep->resp_arg;
++ ep->resp = NULL;
++ if (e_stat & ESB_ST_ABNORMAL)
++ rc = fc_exch_done_locked(ep);
++ spin_unlock_bh(&ep->ex_lock);
++ if (!rc)
++ fc_exch_mgr_delete_ep(ep);
++ if (resp)
++ resp(sp, ERR_PTR(-FC_EX_TIMEOUT), arg);
++ fc_seq_exch_abort(sp, 2 * ep->r_a_tov);
++ goto done;
++ }
++unlock:
++ spin_unlock_bh(&ep->ex_lock);
++done:
++ /*
++ * This release matches the hold taken when the timer was set.
++ */
++ fc_exch_release(ep);
++}
++
++/*
++ * Allocate a sequence.
++ *
++ * We don't support multiple originated sequences on the same exchange.
++ * By implication, any previously originated sequence on this exchange
++ * is complete, and we reallocate the same sequence.
++ */
++static struct fc_seq *fc_seq_alloc(struct fc_exch *ep, u8 seq_id)
++{
++ struct fc_seq *sp;
++
++ sp = &ep->seq;
++ sp->ssb_stat = 0;
++ sp->f_ctl = 0;
++ sp->cnt = 0;
++ sp->id = seq_id;
++ return sp;
++}
++
++/*
++ * Allocate an exchange.
++ *
++ * if xid is supplied zero then assign next free exchange ID
++ * from exchange manager, otherwise use supplied xid.
++ */
++struct fc_exch *fc_exch_alloc(struct fc_exch_mgr *mp, u16 xid)
++{
++ struct fc_exch *ep = NULL;
++ u16 min_xid, max_xid;
++
++ min_xid = mp->min_xid;
++ max_xid = mp->max_xid;
++ /*
++ * if xid is supplied then verify its xid range
++ */
++ if (xid) {
++ if (unlikely((xid < min_xid) || (xid > max_xid))) {
++ FC_DBG("Invalid xid 0x:%x\n", xid);
++ goto out;
++ }
++ if (unlikely(mp->exches[xid - min_xid] != NULL)) {
++ FC_DBG("xid 0x:%x is already in use\n", xid);
++ goto out;
++ }
++ }
++
++ /*
++ * Allocate new exchange
++ */
++ ep = mempool_alloc(mp->ep_pool, GFP_ATOMIC);
++ if (!ep) {
++ atomic_inc(&mp->stats.no_free_exch);
++ goto out;
++ }
++ memset(ep, 0, sizeof(*ep));
++
++ spin_lock_bh(&mp->em_lock);
++
++ /*
++ * if xid is zero then assign next free exchange ID
++ */
++ if (!xid) {
++ xid = fc_exch_next_xid(mp, mp->last_xid);
++ /*
++ * find next free xid using linear search
++ */
++ while (mp->exches[xid - min_xid] != NULL) {
++ if (xid == mp->last_xid)
++ break;
++ 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;
++ }
++ }
++
++ mp->exches[xid - min_xid] = ep;
++ list_add_tail(&ep->ex_list, &mp->ex_list);
++ fc_seq_alloc(ep, ep->seq_id++);
++ mp->total_exches++;
++ spin_unlock_bh(&mp->em_lock);
++
++ /*
++ * update exchange
++ */
++ ep->oxid = ep->xid = xid;
++ ep->em = mp;
++ ep->lp = mp->lp;
++ 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;
++}
++EXPORT_SYMBOL(fc_exch_alloc);
++
++/*
++ * Lookup and hold an exchange.
++ */
++static struct fc_exch *fc_exch_find(struct fc_exch_mgr *mp, u16 xid)
++{
++ struct fc_exch *ep = NULL;
++
++ if ((xid >= mp->min_xid) && (xid <= mp->max_xid)) {
++ spin_lock_bh(&mp->em_lock);
++ ep = mp->exches[xid - mp->min_xid];
++ if (ep) {
++ fc_exch_hold(ep);
++ WARN_ON(ep->xid != xid);
++ }
++ spin_unlock_bh(&mp->em_lock);
++ }
++ return ep;
++}
++
++void fc_exch_done(struct fc_seq *sp)
++{
++ struct fc_exch *ep = fc_seq_exch(sp);
++ int rc;
++
++ spin_lock_bh(&ep->ex_lock);
++ rc = fc_exch_done_locked(ep);
++ spin_unlock_bh(&ep->ex_lock);
++ if (!rc)
++ fc_exch_mgr_delete_ep(ep);
++}
++EXPORT_SYMBOL(fc_exch_done);
++
++/*
++ * Allocate a new exchange as responder.
++ * Sets the responder ID in the frame header.
++ */
++static struct fc_exch *fc_exch_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
++{
++ struct fc_exch *ep;
++ struct fc_frame_header *fh;
++ u16 rxid;
++
++ ep = mp->lp->tt.exch_get(mp->lp, fp);
++ if (ep) {
++ ep->class = fc_frame_class(fp);
++
++ /*
++ * Set EX_CTX indicating we're responding on this exchange.
++ */
++ ep->f_ctl |= FC_FC_EX_CTX; /* we're responding */
++ ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not new */
++ fh = fc_frame_header_get(fp);
++ ep->sid = ntoh24(fh->fh_d_id);
++ ep->did = ntoh24(fh->fh_s_id);
++ ep->oid = ep->did;
++
++ /*
++ * Allocated exchange has placed the XID in the
++ * originator field. Move it to the responder field,
++ * and set the originator XID from the frame.
++ */
++ ep->rxid = ep->xid;
++ ep->oxid = ntohs(fh->fh_ox_id);
++ ep->esb_stat |= ESB_ST_RESP | ESB_ST_SEQ_INIT;
++ if ((ntoh24(fh->fh_f_ctl) & FC_FC_SEQ_INIT) == 0)
++ ep->esb_stat &= ~ESB_ST_SEQ_INIT;
++
++ /*
++ * Set the responder ID in the frame header.
++ * The old one should've been 0xffff.
++ * If it isn't, don't assign one.
++ * Incoming basic link service frames may specify
++ * a referenced RX_ID.
++ */
++ if (fh->fh_type != FC_TYPE_BLS) {
++ rxid = ntohs(fh->fh_rx_id);
++ WARN_ON(rxid != FC_XID_UNKNOWN);
++ fh->fh_rx_id = htons(ep->rxid);
++ }
++ }
++ return ep;
++}
++
++/*
++ * Find a sequence for receive where the other end is originating the sequence.
++ * If fc_pf_rjt_reason is FC_RJT_NONE then this function will have a hold
++ * on the ep that should be released by the caller.
++ */
++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_seq *sp = NULL;
++ enum fc_pf_rjt_reason reject = FC_RJT_NONE;
++ u32 f_ctl;
++ u16 xid;
++
++ f_ctl = ntoh24(fh->fh_f_ctl);
++ WARN_ON((f_ctl & FC_FC_SEQ_CTX) != 0);
++
++ /*
++ * Lookup or create the exchange if we will be creating the sequence.
++ */
++ if (f_ctl & FC_FC_EX_CTX) {
++ xid = ntohs(fh->fh_ox_id); /* we originated exch */
++ ep = fc_exch_find(mp, xid);
++ if (!ep) {
++ atomic_inc(&mp->stats.xid_not_found);
++ reject = FC_RJT_OX_ID;
++ goto out;
++ }
++ if (ep->rxid == FC_XID_UNKNOWN)
++ ep->rxid = ntohs(fh->fh_rx_id);
++ else if (ep->rxid != ntohs(fh->fh_rx_id)) {
++ reject = FC_RJT_OX_ID;
++ goto rel;
++ }
++ } else {
++ xid = ntohs(fh->fh_rx_id); /* we are the responder */
++
++ /*
++ * Special case for MDS issuing an ELS TEST with a
++ * bad rxid of 0.
++ * XXX take this out once we do the proper reject.
++ */
++ if (xid == 0 && fh->fh_r_ctl == FC_RCTL_ELS_REQ &&
++ fc_frame_payload_op(fp) == ELS_TEST) {
++ fh->fh_rx_id = htons(FC_XID_UNKNOWN);
++ xid = FC_XID_UNKNOWN;
++ }
++
++ /*
++ * new sequence - find the exchange
++ */
++ ep = fc_exch_find(mp, xid);
++ if ((f_ctl & FC_FC_FIRST_SEQ) && fc_sof_is_init(fr_sof(fp))) {
++ if (ep) {
++ atomic_inc(&mp->stats.xid_busy);
++ reject = FC_RJT_RX_ID;
++ goto rel;
++ }
++ new_ep = 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);
++ reject = FC_RJT_RX_ID; /* XID not found */
++ goto out;
++ }
++ }
++
++ /*
++ * At this point, we have the exchange held.
++ * Find or create the sequence.
++ */
++ if (fc_sof_is_init(fr_sof(fp))) {
++ sp = fc_seq_start_next(&ep->seq);
++ if (!sp) {
++ reject = FC_RJT_SEQ_XS; /* exchange shortage */
++ goto rel;
++ }
++ sp->id = fh->fh_seq_id;
++ sp->ssb_stat |= SSB_ST_RESP;
++ } else {
++ sp = &ep->seq;
++ if (sp->id != fh->fh_seq_id) {
++ atomic_inc(&mp->stats.seq_not_found);
++ reject = FC_RJT_SEQ_ID; /* sequence/exch should exist */
++ goto rel;
++ }
++ }
++ WARN_ON(ep != fc_seq_exch(sp));
++
++ if (f_ctl & FC_FC_SEQ_INIT)
++ ep->esb_stat |= ESB_ST_SEQ_INIT;
++
++ fr_seq(fp) = sp;
++out:
++ return reject;
++rel:
++ fc_exch_release(ep);
++ if (new_ep)
++ fc_exch_release(new_ep);
++ return reject;
++}
++
++/*
++ * Find the sequence for a frame being received.
++ * We originated the sequence, so it should be found.
++ * We may or may not have originated the exchange.
++ * Does not hold the sequence for the caller.
++ */
++static struct fc_seq *fc_seq_lookup_orig(struct fc_exch_mgr *mp,
++ struct fc_frame *fp)
++{
++ struct fc_frame_header *fh = fc_frame_header_get(fp);
++ struct fc_exch *ep;
++ struct fc_seq *sp = NULL;
++ u32 f_ctl;
++ u16 xid;
++
++ f_ctl = ntoh24(fh->fh_f_ctl);
++ WARN_ON((f_ctl & FC_FC_SEQ_CTX) != FC_FC_SEQ_CTX);
++ xid = ntohs((f_ctl & FC_FC_EX_CTX) ? fh->fh_ox_id : fh->fh_rx_id);
++ ep = fc_exch_find(mp, xid);
++ if (!ep)
++ return NULL;
++ if (ep->seq.id == fh->fh_seq_id) {
++ /*
++ * Save the RX_ID if we didn't previously know it.
++ */
++ sp = &ep->seq;
++ if ((f_ctl & FC_FC_EX_CTX) != 0 &&
++ ep->rxid == FC_XID_UNKNOWN) {
++ ep->rxid = ntohs(fh->fh_rx_id);
++ }
++ }
++ fc_exch_release(ep);
++ return sp;
++}
++
++/*
++ * Set addresses for an exchange.
++ * Note this must be done before the first sequence of the exchange is sent.
++ */
++static void fc_exch_set_addr(struct fc_exch *ep,
++ u32 orig_id, u32 resp_id)
++{
++ ep->oid = orig_id;
++ if (ep->esb_stat & ESB_ST_RESP) {
++ ep->sid = resp_id;
++ ep->did = orig_id;
++ } else {
++ ep->sid = orig_id;
++ ep->did = resp_id;
++ }
++}
++
++static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp)
++{
++ struct fc_exch *ep = fc_seq_exch(sp);
++
++ sp = fc_seq_alloc(ep, ep->seq_id++);
++ if (fc_exch_debug)
++ FC_DBG("exch %4x f_ctl %6x seq %2x f_ctl %6x\n",
++ ep->xid, ep->f_ctl, sp->id, sp->f_ctl);
++ return sp;
++}
++/*
++ * Allocate a new sequence on the same exchange as the supplied sequence.
++ * This will never return NULL.
++ */
++struct fc_seq *fc_seq_start_next(struct fc_seq *sp)
++{
++ struct fc_exch *ep = fc_seq_exch(sp);
++
++ spin_lock_bh(&ep->ex_lock);
++ WARN_ON((ep->esb_stat & ESB_ST_COMPLETE) != 0);
++ sp = fc_seq_start_next_locked(sp);
++ spin_unlock_bh(&ep->ex_lock);
++
++ return sp;
++}
++EXPORT_SYMBOL(fc_seq_start_next);
++
++int fc_seq_send(struct fc_lport *lp, struct fc_seq *sp,
++ struct fc_frame *fp, u32 f_ctl)
++{
++ struct fc_exch *ep;
++ struct fc_frame_header *fh;
++ enum fc_class class;
++ u16 fill = 0;
++ int error;
++
++ ep = fc_seq_exch(sp);
++ WARN_ON((ep->esb_stat & ESB_ST_SEQ_INIT) != ESB_ST_SEQ_INIT);
++
++ fc_seq_fill_hdr(sp, fp);
++ fh = fc_frame_header_get(fp);
++ class = ep->class;
++ fr_sof(fp) = class;
++ if (sp->cnt)
++ fr_sof(fp) = fc_sof_normal(class);
++
++ if (f_ctl & FC_FC_END_SEQ) {
++ fr_eof(fp) = FC_EOF_T;
++ if (fc_sof_needs_ack(class))
++ fr_eof(fp) = FC_EOF_N;
++ /*
++ * Form f_ctl.
++ * The number of fill bytes to make the length a 4-byte
++ * multiple is the low order 2-bits of the f_ctl.
++ * The fill itself will have been cleared by the frame
++ * allocation.
++ * After this, the length will be even, as expected by
++ * the transport. Don't include the fill in the f_ctl
++ * saved in the sequence.
++ */
++ fill = fr_len(fp) & 3;
++ if (fill) {
++ fill = 4 - fill;
++ /* TODO, this may be a problem with fragmented skb */
++ skb_put(fp_skb(fp), fill);
++ }
++ f_ctl |= sp->f_ctl | ep->f_ctl;
++ } else {
++ WARN_ON(fr_len(fp) % 4 != 0); /* no pad to non last frame */
++ f_ctl |= sp->f_ctl | ep->f_ctl;
++ f_ctl &= ~FC_FC_SEQ_INIT;
++ fr_eof(fp) = FC_EOF_N;
++ }
++
++ hton24(fh->fh_f_ctl, f_ctl | fill);
++ fh->fh_seq_cnt = htons(sp->cnt++);
++
++ /*
++ * Send the frame.
++ */
++ error = lp->tt.frame_send(lp, fp);
++
++ /*
++ * Update the exchange and sequence flags,
++ * assuming all frames for the sequence have been sent.
++ * We can only be called to send once for each sequence.
++ */
++ spin_lock_bh(&ep->ex_lock);
++ sp->f_ctl = f_ctl; /* save for possible abort */
++ ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not first seq */
++ if (f_ctl & FC_FC_END_SEQ) {
++ if (f_ctl & FC_FC_SEQ_INIT)
++ ep->esb_stat &= ~ESB_ST_SEQ_INIT;
++ }
++ spin_unlock_bh(&ep->ex_lock);
++ return error;
++}
++EXPORT_SYMBOL(fc_seq_send);
++
++void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd,
++ struct fc_seq_els_data *els_data)
++{
++ switch (els_cmd) {
++ case ELS_LS_RJT:
++ fc_seq_ls_rjt(sp, els_data->reason, els_data->explan);
++ break;
++ case ELS_LS_ACC:
++ fc_seq_ls_acc(sp);
++ break;
++ case ELS_RRQ:
++ fc_exch_els_rrq(sp, els_data->fp);
++ break;
++ case ELS_REC:
++ fc_exch_els_rec(sp, els_data->fp);
++ break;
++ default:
++ FC_DBG("Invalid ELS CMD:%x\n", els_cmd);
++ }
++}
++EXPORT_SYMBOL(fc_seq_els_rsp_send);
++
++/*
++ * Send a sequence, which is also the last sequence in the exchange.
++ */
++static void fc_seq_send_last(struct fc_seq *sp, struct fc_frame *fp,
++ enum fc_rctl rctl, enum fc_fh_type fh_type)
++{
++ u32 f_ctl;
++
++ fc_frame_setup(fp, rctl, fh_type);
++ f_ctl = FC_FC_SEQ_INIT | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
++ fc_seq_send(fc_seq_exch(sp)->lp, sp, fp, f_ctl);
++}
++
++/*
++ * Send ACK_1 (or equiv.) indicating we received something.
++ * The frame we're acking is supplied.
++ */
++static void fc_seq_send_ack(struct fc_seq *sp, const struct fc_frame *rx_fp)
++{
++ struct fc_frame *fp;
++ struct fc_frame_header *rx_fh;
++ struct fc_frame_header *fh;
++ struct fc_lport *lp = fc_seq_exch(sp)->lp;
++ unsigned int f_ctl;
++
++ /*
++ * Don't send ACKs for class 3.
++ */
++ if (fc_sof_needs_ack(fr_sof(rx_fp))) {
++ fp = fc_frame_alloc(lp, 0);
++ BUG_ON(!fp);
++ if (!fp)
++ return;
++
++ fc_seq_fill_hdr(sp, fp);
++ fh = fc_frame_header_get(fp);
++ fh->fh_r_ctl = FC_RCTL_ACK_1;
++ fh->fh_type = FC_TYPE_BLS;
++
++ /*
++ * Form f_ctl by inverting EX_CTX and SEQ_CTX (bits 23, 22).
++ * Echo FIRST_SEQ, LAST_SEQ, END_SEQ, END_CONN, SEQ_INIT.
++ * Bits 9-8 are meaningful (retransmitted or unidirectional).
++ * Last ACK uses bits 7-6 (continue sequence),
++ * bits 5-4 are meaningful (what kind of ACK to use).
++ */
++ rx_fh = fc_frame_header_get(rx_fp);
++ f_ctl = ntoh24(rx_fh->fh_f_ctl);
++ f_ctl &= FC_FC_EX_CTX | FC_FC_SEQ_CTX |
++ FC_FC_FIRST_SEQ | FC_FC_LAST_SEQ |
++ FC_FC_END_SEQ | FC_FC_END_CONN | FC_FC_SEQ_INIT |
++ FC_FC_RETX_SEQ | FC_FC_UNI_TX;
++ f_ctl ^= FC_FC_EX_CTX | FC_FC_SEQ_CTX;
++ hton24(fh->fh_f_ctl, f_ctl);
++
++ fh->fh_seq_id = rx_fh->fh_seq_id;
++ fh->fh_seq_cnt = rx_fh->fh_seq_cnt;
++ fh->fh_parm_offset = htonl(1); /* ack single frame */
++
++ fr_sof(fp) = fr_sof(rx_fp);
++ if (f_ctl & FC_FC_END_SEQ)
++ fr_eof(fp) = FC_EOF_T;
++ else
++ fr_eof(fp) = FC_EOF_N;
++
++ (void) lp->tt.frame_send(lp, fp);
++ }
++}
++
++/*
++ * Send BLS Reject.
++ * This is for rejecting BA_ABTS only.
++ */
++static void
++fc_exch_send_ba_rjt(struct fc_frame *rx_fp, enum fc_ba_rjt_reason reason,
++ enum fc_ba_rjt_explan explan)
++{
++ struct fc_frame *fp;
++ struct fc_frame_header *rx_fh;
++ struct fc_frame_header *fh;
++ struct fc_ba_rjt *rp;
++ struct fc_lport *lp;
++ unsigned int f_ctl;
++
++ lp = fr_dev(rx_fp);
++ fp = fc_frame_alloc(lp, sizeof(*rp));
++ if (!fp)
++ return;
++ fh = fc_frame_header_get(fp);
++ rx_fh = fc_frame_header_get(rx_fp);
++
++ memset(fh, 0, sizeof(*fh) + sizeof(*rp));
++
++ rp = fc_frame_payload_get(fp, sizeof(*rp));
++ rp->br_reason = reason;
++ rp->br_explan = explan;
++
++ /*
++ * seq_id, cs_ctl, df_ctl and param/offset are zero.
++ */
++ memcpy(fh->fh_s_id, rx_fh->fh_d_id, 3);
++ memcpy(fh->fh_d_id, rx_fh->fh_s_id, 3);
++ fh->fh_ox_id = rx_fh->fh_rx_id;
++ fh->fh_rx_id = rx_fh->fh_ox_id;
++ fh->fh_seq_cnt = rx_fh->fh_seq_cnt;
++ fh->fh_r_ctl = FC_RCTL_BA_RJT;
++ fh->fh_type = FC_TYPE_BLS;
++
++ /*
++ * Form f_ctl by inverting EX_CTX and SEQ_CTX (bits 23, 22).
++ * Echo FIRST_SEQ, LAST_SEQ, END_SEQ, END_CONN, SEQ_INIT.
++ * Bits 9-8 are meaningful (retransmitted or unidirectional).
++ * Last ACK uses bits 7-6 (continue sequence),
++ * bits 5-4 are meaningful (what kind of ACK to use).
++ * Always set LAST_SEQ, END_SEQ.
++ */
++ f_ctl = ntoh24(rx_fh->fh_f_ctl);
++ f_ctl &= FC_FC_EX_CTX | FC_FC_SEQ_CTX |
++ FC_FC_END_CONN | FC_FC_SEQ_INIT |
++ FC_FC_RETX_SEQ | FC_FC_UNI_TX;
++ f_ctl ^= FC_FC_EX_CTX | FC_FC_SEQ_CTX;
++ f_ctl |= FC_FC_LAST_SEQ | FC_FC_END_SEQ;
++ f_ctl &= ~FC_FC_FIRST_SEQ;
++ hton24(fh->fh_f_ctl, f_ctl);
++
++ fr_sof(fp) = fc_sof_class(fr_sof(rx_fp));
++ fr_eof(fp) = FC_EOF_T;
++ if (fc_sof_needs_ack(fr_sof(fp)))
++ fr_eof(fp) = FC_EOF_N;
++
++ (void) lp->tt.frame_send(lp, fp);
++}
++
++/*
++ * Handle an incoming ABTS. This would be for target mode usually,
++ * but could be due to lost FCP transfer ready, confirm or RRQ.
++ * We always handle this as an exchange abort, ignoring the parameter.
++ */
++static void fc_exch_recv_abts(struct fc_exch *ep, struct fc_frame *rx_fp)
++{
++ struct fc_frame *fp;
++ struct fc_ba_acc *ap;
++ struct fc_frame_header *fh;
++ struct fc_seq *sp;
++
++ if (!ep)
++ goto reject;
++ spin_lock_bh(&ep->ex_lock);
++ if (ep->esb_stat & ESB_ST_COMPLETE) {
++ spin_unlock_bh(&ep->ex_lock);
++ goto reject;
++ }
++ if (!(ep->esb_stat & ESB_ST_REC_QUAL))
++ fc_exch_hold(ep); /* hold for REC_QUAL */
++ ep->esb_stat |= ESB_ST_ABNORMAL | ESB_ST_REC_QUAL;
++ fc_exch_timer_set_locked(ep, ep->r_a_tov);
++
++ fp = fc_frame_alloc(ep->lp, sizeof(*ap));
++ if (!fp) {
++ spin_unlock_bh(&ep->ex_lock);
++ goto free;
++ }
++ fh = fc_frame_header_get(fp);
++ ap = fc_frame_payload_get(fp, sizeof(*ap));
++ memset(ap, 0, sizeof(*ap));
++ sp = &ep->seq;
++ ap->ba_high_seq_cnt = htons(0xffff);
++ if (sp->ssb_stat & SSB_ST_RESP) {
++ ap->ba_seq_id = sp->id;
++ ap->ba_seq_id_val = FC_BA_SEQ_ID_VAL;
++ ap->ba_high_seq_cnt = fh->fh_seq_cnt;
++ ap->ba_low_seq_cnt = htons(sp->cnt);
++ }
++ sp = fc_seq_start_next(sp);
++ spin_unlock_bh(&ep->ex_lock);
++ fc_seq_send_last(sp, fp, FC_RCTL_BA_ACC, FC_TYPE_BLS);
++ fc_frame_free(rx_fp);
++ return;
++
++reject:
++ fc_exch_send_ba_rjt(rx_fp, FC_BA_RJT_UNABLE, FC_BA_RJT_INV_XID);
++free:
++ fc_frame_free(rx_fp);
++}
++
++/*
++ * Handle receive where the other end is originating the sequence.
++ */
++static void fc_exch_recv_req(struct fc_lport *lp, struct fc_exch_mgr *mp,
++ struct fc_frame *fp)
++{
++ struct fc_frame_header *fh = fc_frame_header_get(fp);
++ struct fc_seq *sp = NULL;
++ struct fc_exch *ep = NULL;
++ enum fc_sof sof;
++ enum fc_eof eof;
++ u32 f_ctl;
++ enum fc_pf_rjt_reason reject;
++
++ fr_seq(fp) = NULL;
++ reject = fc_seq_lookup_recip(mp, fp);
++ if (reject == FC_RJT_NONE) {
++ sp = fr_seq(fp); /* sequence will be held */
++ ep = fc_seq_exch(sp);
++ sof = fr_sof(fp);
++ eof = fr_eof(fp);
++ f_ctl = ntoh24(fh->fh_f_ctl);
++ fc_seq_send_ack(sp, fp);
++
++ /*
++ * Call the receive function.
++ *
++ * The receive function may allocate a new sequence
++ * over the old one, so we shouldn't change the
++ * sequence after this.
++ *
++ * The frame will be freed by the receive function.
++ * If new exch resp handler is valid then call that
++ * first.
++ */
++ if (ep->resp)
++ ep->resp(sp, fp, ep->resp_arg);
++ else
++ lp->tt.lport_recv(lp, sp, fp);
++ fc_exch_release(ep); /* release from lookup */
++ } else {
++ if (fc_exch_debug)
++ FC_DBG("exch/seq lookup failed: reject %x\n", reject);
++ fc_frame_free(fp);
++ }
++}
++
++/*
++ * Handle receive where the other end is originating the sequence in
++ * response to our exchange.
++ */
++static void fc_exch_recv_seq_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
++{
++ struct fc_frame_header *fh = fc_frame_header_get(fp);
++ struct fc_seq *sp;
++ struct fc_exch *ep;
++ enum fc_sof sof;
++ u32 f_ctl;
++ void (*resp)(struct fc_seq *, struct fc_frame *fp, void *arg);
++ void *ex_resp_arg;
++ int rc;
++
++ ep = fc_exch_find(mp, ntohs(fh->fh_ox_id));
++ if (!ep) {
++ atomic_inc(&mp->stats.xid_not_found);
++ goto out;
++ }
++ if (ep->rxid == FC_XID_UNKNOWN)
++ ep->rxid = ntohs(fh->fh_rx_id);
++ if (ep->sid != 0 && ep->sid != ntoh24(fh->fh_d_id)) {
++ atomic_inc(&mp->stats.xid_not_found);
++ goto rel;
++ }
++ if (ep->did != ntoh24(fh->fh_s_id) &&
++ ep->did != FC_FID_FLOGI) {
++ atomic_inc(&mp->stats.xid_not_found);
++ goto rel;
++ }
++ sof = fr_sof(fp);
++ if (fc_sof_is_init(sof)) {
++ sp = fc_seq_start_next(&ep->seq);
++ sp->id = fh->fh_seq_id;
++ sp->ssb_stat |= SSB_ST_RESP;
++ } else {
++ sp = &ep->seq;
++ if (sp->id != fh->fh_seq_id) {
++ atomic_inc(&mp->stats.seq_not_found);
++ goto rel;
++ }
++ }
++ f_ctl = ntoh24(fh->fh_f_ctl);
++ fr_seq(fp) = sp;
++ if (f_ctl & FC_FC_SEQ_INIT)
++ ep->esb_stat |= ESB_ST_SEQ_INIT;
++
++ if (fc_sof_needs_ack(sof))
++ fc_seq_send_ack(sp, fp);
++ resp = ep->resp;
++ ex_resp_arg = ep->resp_arg;
++
++ if (fh->fh_type != FC_TYPE_FCP && fr_eof(fp) == FC_EOF_T &&
++ (f_ctl & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
++ (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
++ spin_lock_bh(&ep->ex_lock);
++ rc = fc_exch_done_locked(ep);
++ WARN_ON(fc_seq_exch(sp) != ep);
++ spin_unlock_bh(&ep->ex_lock);
++ if (!rc)
++ fc_exch_mgr_delete_ep(ep);
++ }
++
++ /*
++ * Call the receive function.
++ * The sequence is held (has a refcnt) for us,
++ * but not for the receive function.
++ *
++ * The receive function may allocate a new sequence
++ * over the old one, so we shouldn't change the
++ * sequence after this.
++ *
++ * The frame will be freed by the receive function.
++ * If new exch resp handler is valid then call that
++ * first.
++ */
++ if (resp)
++ resp(sp, fp, ex_resp_arg);
++ else
++ fc_frame_free(fp);
++ fc_exch_release(ep);
++ return;
++rel:
++ fc_exch_release(ep);
++out:
++ fc_frame_free(fp);
++}
++
++/*
++ * Handle receive for a sequence where other end is responding to our sequence.
++ */
++static void fc_exch_recv_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
++{
++ struct fc_seq *sp;
++
++ sp = fc_seq_lookup_orig(mp, fp); /* doesn't hold sequence */
++ if (!sp) {
++ atomic_inc(&mp->stats.xid_not_found);
++ if (fc_exch_debug)
++ FC_DBG("seq lookup failed\n");
++ } else {
++ atomic_inc(&mp->stats.non_bls_resp);
++ if (fc_exch_debug)
++ FC_DBG("non-BLS response to sequence");
++ }
++ fc_frame_free(fp);
++}
++
++/*
++ * Handle the response to an ABTS for exchange or sequence.
++ * This can be BA_ACC or BA_RJT.
++ */
++static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
++{
++ void (*resp)(struct fc_seq *, struct fc_frame *fp, void *arg);
++ void *ex_resp_arg;
++ struct fc_frame_header *fh;
++ struct fc_ba_acc *ap;
++ struct fc_seq *sp;
++ u16 low;
++ u16 high;
++ int rc = 1, has_rec = 0;
++
++ fh = fc_frame_header_get(fp);
++ if (fc_exch_debug)
++ FC_DBG("exch: BLS rctl %x - %s\n",
++ fh->fh_r_ctl, fc_exch_rctl_name(fh->fh_r_ctl));
++
++ if (del_timer_sync(&ep->ex_timer))
++ fc_exch_release(ep); /* release from pending timer hold */
++
++ spin_lock_bh(&ep->ex_lock);
++ switch (fh->fh_r_ctl) {
++ case FC_RCTL_BA_ACC:
++ ap = fc_frame_payload_get(fp, sizeof(*ap));
++ if (!ap)
++ break;
++
++ /*
++ * Decide whether to establish a Recovery Qualifier.
++ * We do this if there is a non-empty SEQ_CNT range and
++ * SEQ_ID is the same as the one we aborted.
++ */
++ low = ntohs(ap->ba_low_seq_cnt);
++ high = ntohs(ap->ba_high_seq_cnt);
++ if ((ep->esb_stat & ESB_ST_REC_QUAL) == 0 &&
++ (ap->ba_seq_id_val != FC_BA_SEQ_ID_VAL ||
++ ap->ba_seq_id == ep->seq_id) && low != high) {
++ ep->esb_stat |= ESB_ST_REC_QUAL;
++ fc_exch_hold(ep); /* hold for recovery qualifier */
++ has_rec = 1;
++ }
++ break;
++ case FC_RCTL_BA_RJT:
++ break;
++ default:
++ break;
++ }
++
++ resp = ep->resp;
++ ex_resp_arg = ep->resp_arg;
++
++ /* do we need to do some other checks here. Can we reuse more of
++ * fc_exch_recv_seq_resp
++ */
++ sp = &ep->seq;
++ /*
++ * do we want to check END_SEQ as well as LAST_SEQ here?
++ */
++ if (fh->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);
++ if (!rc)
++ fc_exch_mgr_delete_ep(ep);
++
++ if (resp)
++ resp(sp, fp, ex_resp_arg);
++ else
++ fc_frame_free(fp);
++
++ if (has_rec)
++ fc_exch_timer_set(ep, ep->r_a_tov);
++
++}
++
++/*
++ * Receive BLS sequence.
++ * This is always a sequence initiated by the remote side.
++ * We may be either the originator or recipient of the exchange.
++ */
++static void fc_exch_recv_bls(struct fc_exch_mgr *mp, struct fc_frame *fp)
++{
++ struct fc_frame_header *fh;
++ struct fc_exch *ep;
++ u32 f_ctl;
++
++ fh = fc_frame_header_get(fp);
++ f_ctl = ntoh24(fh->fh_f_ctl);
++ fr_seq(fp) = NULL;
++
++ ep = fc_exch_find(mp, (f_ctl & FC_FC_EX_CTX) ?
++ ntohs(fh->fh_ox_id) : ntohs(fh->fh_rx_id));
++ if (ep && (f_ctl & FC_FC_SEQ_INIT)) {
++ spin_lock_bh(&ep->ex_lock);
++ ep->esb_stat |= ESB_ST_SEQ_INIT;
++ spin_unlock_bh(&ep->ex_lock);
++ }
++ if (f_ctl & FC_FC_SEQ_CTX) {
++ /*
++ * A response to a sequence we initiated.
++ * This should only be ACKs for class 2 or F.
++ */
++ switch (fh->fh_r_ctl) {
++ case FC_RCTL_ACK_1:
++ case FC_RCTL_ACK_0:
++ break;
++ default:
++ if (fc_exch_debug)
++ FC_DBG("BLS rctl %x - %s received",
++ fh->fh_r_ctl,
++ fc_exch_rctl_name(fh->fh_r_ctl));
++ break;
++ }
++ fc_frame_free(fp);
++ } else {
++ switch (fh->fh_r_ctl) {
++ case FC_RCTL_BA_RJT:
++ case FC_RCTL_BA_ACC:
++ if (ep)
++ fc_exch_abts_resp(ep, fp);
++ else
++ fc_frame_free(fp);
++ break;
++ case FC_RCTL_BA_ABTS:
++ fc_exch_recv_abts(ep, fp);
++ break;
++ default: /* ignore junk */
++ fc_frame_free(fp);
++ break;
++ }
++ }
++ if (ep)
++ fc_exch_release(ep); /* release hold taken by fc_exch_find */
++}
++
++/*
++ * Accept sequence with LS_ACC.
++ * If this fails due to allocation or transmit congestion, assume the
++ * originator will repeat the sequence.
++ */
++static void fc_seq_ls_acc(struct fc_seq *req_sp)
++{
++ struct fc_seq *sp;
++ struct fc_els_ls_acc *acc;
++ struct fc_frame *fp;
++
++ sp = fc_seq_start_next(req_sp);
++ fp = fc_frame_alloc(fc_seq_exch(sp)->lp, sizeof(*acc));
++ if (fp) {
++ acc = fc_frame_payload_get(fp, sizeof(*acc));
++ memset(acc, 0, sizeof(*acc));
++ acc->la_cmd = ELS_LS_ACC;
++ fc_seq_send_last(sp, fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
++ }
++}
++
++/*
++ * Reject sequence with ELS LS_RJT.
++ * If this fails due to allocation or transmit congestion, assume the
++ * originator will repeat the sequence.
++ */
++static void fc_seq_ls_rjt(struct fc_seq *req_sp, enum fc_els_rjt_reason reason,
++ enum fc_els_rjt_explan explan)
++{
++ struct fc_seq *sp;
++ struct fc_els_ls_rjt *rjt;
++ struct fc_frame *fp;
++
++ sp = fc_seq_start_next(req_sp);
++ fp = fc_frame_alloc(fc_seq_exch(sp)->lp, sizeof(*rjt));
++ if (fp) {
++ rjt = fc_frame_payload_get(fp, sizeof(*rjt));
++ memset(rjt, 0, sizeof(*rjt));
++ rjt->er_cmd = ELS_LS_RJT;
++ rjt->er_reason = reason;
++ rjt->er_explan = explan;
++ fc_seq_send_last(sp, fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
++ }
++}
++
++static void fc_exch_reset(struct fc_exch *ep)
++{
++ struct fc_seq *sp;
++ void (*resp)(struct fc_seq *, struct fc_frame *, void *);
++ void *arg;
++ int rc = 1;
++
++ spin_lock_bh(&ep->ex_lock);
++ ep->state |= FC_EX_RST_CLEANUP;
++ /*
++ * we really want to call del_timer_sync, but cannot due
++ * to the lport calling with the lport lock held (some resp
++ * functions can also grab the lport lock which could cause
++ * a deadlock).
++ */
++ if (del_timer(&ep->ex_timer))
++ atomic_dec(&ep->ex_refcnt); /* drop hold for timer */
++ resp = ep->resp;
++ ep->resp = NULL;
++ 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;
++ sp = &ep->seq;
++
++ if (ep->fh_type != FC_TYPE_FCP)
++ rc = fc_exch_done_locked(ep);
++ spin_unlock_bh(&ep->ex_lock);
++ if (!rc)
++ fc_exch_mgr_delete_ep(ep);
++
++ if (resp)
++ resp(sp, ERR_PTR(-FC_EX_CLOSED), arg);
++}
++
++/*
++ * Reset an exchange manager, releasing all sequences and exchanges.
++ * If sid is non-zero, reset only exchanges we source from that FID.
++ * If did is non-zero, reset only exchanges destined to that FID.
++ */
++void fc_exch_mgr_reset(struct fc_exch_mgr *mp, u32 sid, u32 did)
++{
++ struct fc_exch *ep;
++ struct fc_exch *next;
++
++ spin_lock_bh(&mp->em_lock);
++restart:
++ list_for_each_entry_safe(ep, next, &mp->ex_list, ex_list) {
++ if ((sid == 0 || sid == ep->sid) &&
++ (did == 0 || did == ep->did)) {
++ fc_exch_hold(ep);
++ spin_unlock_bh(&mp->em_lock);
++
++ fc_exch_reset(ep);
++
++ fc_exch_release(ep);
++ spin_lock_bh(&mp->em_lock);
++
++ /*
++ * must restart loop incase while lock was down
++ * multiple eps were released.
++ */
++ goto restart;
++ }
++ }
++ spin_unlock_bh(&mp->em_lock);
++}
++EXPORT_SYMBOL(fc_exch_mgr_reset);
++
++void fc_seq_get_xids(struct fc_seq *sp, u16 *oxid, u16 *rxid)
++{
++ struct fc_exch *ep;
++
++ ep = fc_seq_exch(sp);
++ *oxid = ep->oxid;
++ *rxid = ep->rxid;
++}
++EXPORT_SYMBOL(fc_seq_get_xids);
++
++void fc_seq_set_rec_data(struct fc_seq *sp, u32 rec_data)
++{
++ sp->rec_data = rec_data;
++}
++EXPORT_SYMBOL(fc_seq_set_rec_data);
++
++/*
++ * Handle incoming ELS REC - Read Exchange Concise.
++ * Note that the requesting port may be different than the S_ID in the request.
++ */
++static void fc_exch_els_rec(struct fc_seq *sp, struct fc_frame *rfp)
++{
++ struct fc_frame *fp;
++ struct fc_exch *ep;
++ struct fc_exch_mgr *em;
++ struct fc_els_rec *rp;
++ struct fc_els_rec_acc *acc;
++ enum fc_els_rjt_reason reason = ELS_RJT_LOGIC;
++ enum fc_els_rjt_explan explan;
++ u32 sid;
++ u16 rxid;
++ u16 oxid;
++
++ rp = fc_frame_payload_get(rfp, sizeof(*rp));
++ explan = ELS_EXPL_INV_LEN;
++ if (!rp)
++ goto reject;
++ sid = ntoh24(rp->rec_s_id);
++ rxid = ntohs(rp->rec_rx_id);
++ oxid = ntohs(rp->rec_ox_id);
++
++ /*
++ * Currently it's hard to find the local S_ID from the exchange
++ * manager. This will eventually be fixed, but for now it's easier
++ * to lookup the subject exchange twice, once as if we were
++ * the initiator, and then again if we weren't.
++ */
++ em = fc_seq_exch(sp)->em;
++ ep = fc_exch_find(em, oxid);
++ explan = ELS_EXPL_OXID_RXID;
++ if (ep && ep->oid == sid) {
++ if (ep->rxid != FC_XID_UNKNOWN &&
++ rxid != FC_XID_UNKNOWN &&
++ ep->rxid != rxid)
++ goto rel;
++ } else {
++ if (ep)
++ fc_exch_release(ep);
++ ep = NULL;
++ if (rxid != FC_XID_UNKNOWN)
++ ep = fc_exch_find(em, rxid);
++ if (!ep)
++ goto reject;
++ }
++
++ fp = fc_frame_alloc(fc_seq_exch(sp)->lp, sizeof(*acc));
++ if (!fp) {
++ fc_exch_done(sp);
++ goto out;
++ }
++ sp = fc_seq_start_next(sp);
++ acc = fc_frame_payload_get(fp, sizeof(*acc));
++ memset(acc, 0, sizeof(*acc));
++ acc->reca_cmd = ELS_LS_ACC;
++ acc->reca_ox_id = rp->rec_ox_id;
++ memcpy(acc->reca_ofid, rp->rec_s_id, 3);
++ acc->reca_rx_id = htons(ep->rxid);
++ if (ep->sid == ep->oid)
++ hton24(acc->reca_rfid, ep->did);
++ else
++ hton24(acc->reca_rfid, ep->sid);
++ acc->reca_fc4value = htonl(ep->seq.rec_data);
++ acc->reca_e_stat = htonl(ep->esb_stat & (ESB_ST_RESP |
++ ESB_ST_SEQ_INIT |
++ ESB_ST_COMPLETE));
++ sp = fc_seq_start_next(sp);
++ fc_seq_send_last(sp, fp, FC_RCTL_ELS_REP, FC_TYPE_ELS);
++out:
++ fc_exch_release(ep);
++ fc_frame_free(rfp);
++ return;
++
++rel:
++ fc_exch_release(ep);
++reject:
++ fc_seq_ls_rjt(sp, reason, explan);
++ fc_frame_free(rfp);
++}
++
++/*
++ * Handle response from RRQ.
++ * Not much to do here, really.
++ * Should report errors.
++ *
++ * TODO: fix error handler.
++ */
++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;
++
++ unsigned int op;
++
++ if (IS_ERR(fp)) {
++ int err = PTR_ERR(fp);
++
++ if (err == -FC_EX_CLOSED)
++ goto cleanup;
++ FC_DBG("Cannot process RRQ, because of frame error %d\n", err);
++ return;
++ }
++
++ op = fc_frame_payload_op(fp);
++ fc_frame_free(fp);
++
++ switch (op) {
++ case ELS_LS_RJT:
++ FC_DBG("LS_RJT for RRQ");
++ /* fall through */
++ case ELS_LS_ACC:
++ goto cleanup;
++ default:
++ FC_DBG("unexpected response op %x for RRQ", op);
++ return;
++ }
++
++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);
++ }
++}
++
++/*
++ * Send ELS RRQ - Reinstate Recovery Qualifier.
++ * This tells the remote port to stop blocking the use of
++ * the exchange and the seq_cnt range.
++ */
++static void fc_exch_rrq(struct fc_exch *ep)
++{
++ struct fc_lport *lp;
++ struct fc_els_rrq *rrq;
++ struct fc_frame *fp;
++ struct fc_seq *rrq_sp;
++ struct fc_exch *rrq_ep;
++ u32 did;
++
++ lp = ep->lp;
++
++ fp = fc_frame_alloc(lp, sizeof(*rrq));
++ if (!fp)
++ return;
++ fc_frame_setup(fp, FC_RCTL_ELS_REQ, FC_TYPE_ELS);
++ rrq = fc_frame_payload_get(fp, sizeof(*rrq));
++ memset(rrq, 0, sizeof(*rrq));
++ rrq->rrq_cmd = ELS_RRQ;
++ hton24(rrq->rrq_s_id, ep->sid);
++ rrq->rrq_ox_id = htons(ep->oxid);
++ rrq->rrq_rx_id = htons(ep->rxid);
++
++ 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);
++ 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;
++}
++
++
++/*
++ * Handle incoming ELS RRQ - Reset Recovery Qualifier.
++ */
++static void fc_exch_els_rrq(struct fc_seq *sp, struct fc_frame *fp)
++{
++ struct fc_exch *ep; /* request or subject exchange */
++ struct fc_els_rrq *rp;
++ u32 sid;
++ u16 xid;
++ enum fc_els_rjt_explan explan;
++
++ rp = fc_frame_payload_get(fp, sizeof(*rp));
++ explan = ELS_EXPL_INV_LEN;
++ if (!rp)
++ goto reject;
++
++ /*
++ * lookup subject exchange.
++ */
++ ep = fc_seq_exch(sp);
++ sid = ntoh24(rp->rrq_s_id); /* subject source */
++ xid = ep->did == sid ? ntohs(rp->rrq_ox_id) : ntohs(rp->rrq_rx_id);
++ ep = fc_exch_find(ep->em, xid);
++
++ explan = ELS_EXPL_OXID_RXID;
++ if (!ep)
++ goto reject;
++ spin_lock_bh(&ep->ex_lock);
++ if (ep->oxid != ntohs(rp->rrq_ox_id))
++ goto unlock_reject;
++ if (ep->rxid != ntohs(rp->rrq_rx_id) &&
++ ep->rxid != FC_XID_UNKNOWN)
++ goto unlock_reject;
++ explan = ELS_EXPL_SID;
++ if (ep->sid != sid)
++ goto unlock_reject;
++
++ /*
++ * Clear Recovery Qualifier state, and cancel timer if complete.
++ */
++ if (ep->esb_stat & ESB_ST_REC_QUAL) {
++ ep->esb_stat &= ~ESB_ST_REC_QUAL;
++ atomic_dec(&ep->ex_refcnt); /* drop hold for rec qual */
++ }
++ if ((ep->esb_stat & ESB_ST_COMPLETE) && (del_timer(&ep->ex_timer)))
++ atomic_dec(&ep->ex_refcnt); /* drop hold for timer */
++
++ spin_unlock_bh(&ep->ex_lock);
++
++ /*
++ * Send LS_ACC.
++ */
++ fc_seq_ls_acc(sp);
++ fc_frame_free(fp);
++ return;
++
++unlock_reject:
++ spin_unlock_bh(&ep->ex_lock);
++ fc_exch_release(ep); /* drop hold from fc_exch_find */
++reject:
++ fc_seq_ls_rjt(sp, ELS_RJT_LOGIC, explan);
++ fc_frame_free(fp);
++}
++
++struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lp,
++ enum fc_class class,
++ u16 min_xid, u16 max_xid)
++{
++ struct fc_exch_mgr *mp;
++ size_t len;
++
++ if (max_xid <= min_xid || min_xid == 0 || max_xid == FC_XID_UNKNOWN) {
++ FC_DBG("Invalid min_xid 0x:%x and max_xid 0x:%x\n",
++ min_xid, max_xid);
++ return NULL;
++ }
++
++ /*
++ * Memory need for EM
++ */
++ len = (max_xid - min_xid + 1) * (sizeof(struct fc_exch *));
++ len += sizeof(struct fc_exch_mgr);
++
++ mp = kzalloc(len, GFP_ATOMIC);
++ if (mp) {
++ mp->class = class;
++ mp->total_exches = 0;
++ mp->exches = (struct fc_exch **)(mp + 1);
++ mp->last_xid = min_xid - 1;
++ mp->min_xid = min_xid;
++ mp->max_xid = max_xid;
++ mp->lp = lp;
++ INIT_LIST_HEAD(&mp->ex_list);
++ spin_lock_init(&mp->em_lock);
++ }
++
++ mp->ep_pool = mempool_create_slab_pool(2, fc_em_cachep);
++ if (!mp->ep_pool)
++ goto free_mp;
++
++ return mp;
++
++free_mp:
++ kfree(mp);
++ return NULL;
++}
++EXPORT_SYMBOL(fc_exch_mgr_alloc);
++
++void fc_exch_mgr_free(struct fc_exch_mgr *mp)
++{
++ WARN_ON(!mp);
++ /*
++ * The total exch count must be zero
++ * before freeing exchange manager.
++ */
++ WARN_ON(mp->total_exches != 0);
++ mempool_destroy(mp->ep_pool);
++ kfree(mp);
++}
++EXPORT_SYMBOL(fc_exch_mgr_free);
++
++struct fc_exch *fc_exch_get(struct fc_lport *lp, struct fc_frame *fp)
++{
++ if (!lp || !lp->emp)
++ return NULL;
++ return fc_exch_alloc(lp->emp, 0);
++}
++EXPORT_SYMBOL(fc_exch_get);
++
++struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
++ struct fc_frame *fp,
++ void (*resp)(struct fc_seq *,
++ struct fc_frame *fp,
++ void *arg),
++ void *resp_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;
++
++ ep = lp->tt.exch_get(lp, fp);
++ if (!ep) {
++ fc_frame_free(fp);
++ return NULL;
++ }
++ ep->esb_stat |= ESB_ST_SEQ_INIT;
++ fc_exch_set_addr(ep, sid, did);
++ ep->resp = resp;
++ ep->resp_arg = resp_arg;
++ ep->r_a_tov = FC_DEF_R_A_TOV;
++ ep->lp = lp;
++ sp = &ep->seq;
++ WARN_ON((sp->f_ctl & FC_FC_END_SEQ) != 0);
++
++ fr_sof(fp) = ep->class;
++ if (sp->cnt)
++ fr_sof(fp) = fc_sof_normal(ep->class);
++ fr_eof(fp) = FC_EOF_T;
++ if (fc_sof_needs_ack(ep->class))
++ fr_eof(fp) = FC_EOF_N;
++
++ fc_seq_fill_hdr(sp, fp);
++ /*
++ * Form f_ctl.
++ * The number of fill bytes to make the length a 4-byte multiple is
++ * the low order 2-bits of the f_ctl. The fill itself will have been
++ * cleared by the frame allocation.
++ * After this, the length will be even, as expected by the transport.
++ * Don't include the fill in the f_ctl saved in the sequence.
++ */
++ fill = fr_len(fp) & 3;
++ if (fill) {
++ fill = 4 - fill;
++ /* TODO, this may be a problem with fragmented skb */
++ skb_put(fp_skb(fp), fill);
++ }
++ f_ctl |= ep->f_ctl;
++ fh = fc_frame_header_get(fp);
++ hton24(fh->fh_f_ctl, f_ctl | fill);
++ fh->fh_seq_cnt = htons(sp->cnt++);
++
++ 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 */
++ ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not first seq */
++ ep->fh_type = fh->fh_type; /* save for possbile timeout handling */
++
++ if (f_ctl & FC_FC_SEQ_INIT)
++ ep->esb_stat &= ~ESB_ST_SEQ_INIT;
++ spin_unlock_bh(&ep->ex_lock);
++ return sp;
++err:
++ fc_exch_done(sp);
++ return NULL;
++}
++EXPORT_SYMBOL(fc_exch_seq_send);
++
++/*
++ * Receive a frame
++ */
++void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
++ struct fc_frame *fp)
++{
++ struct fc_frame_header *fh = fc_frame_header_get(fp);
++ u32 f_ctl;
++
++ if (!lp || !mp || (lp->state == LPORT_ST_NONE)) {
++ FC_DBG("fc_lport or EM is not allocated and configured");
++ fc_frame_free(fp);
++ return;
++ }
++
++ /*
++ * If frame is marked invalid, just drop it.
++ */
++ f_ctl = ntoh24(fh->fh_f_ctl);
++ switch (fr_eof(fp)) {
++ case FC_EOF_T:
++ if (f_ctl & FC_FC_END_SEQ)
++ skb_trim(fp_skb(fp), fr_len(fp) - FC_FC_FILL(f_ctl));
++ /* fall through */
++ case FC_EOF_N:
++ if (fh->fh_type == FC_TYPE_BLS)
++ fc_exch_recv_bls(mp, fp);
++ else if ((f_ctl & (FC_FC_EX_CTX | FC_FC_SEQ_CTX)) ==
++ FC_FC_EX_CTX)
++ fc_exch_recv_seq_resp(mp, fp);
++ else if (f_ctl & FC_FC_SEQ_CTX)
++ fc_exch_recv_resp(mp, fp);
++ else
++ fc_exch_recv_req(lp, mp, fp);
++ break;
++ default:
++ FC_DBG("dropping invalid frame (eof %x)", fr_eof(fp));
++ fc_frame_free(fp);
++ break;
++ }
++}
++EXPORT_SYMBOL(fc_exch_recv);
++
++int fc_exch_init(struct fc_lport *lp)
++{
++ if (!lp->tt.exch_get) {
++ /*
++ * exch_put() should be NULL if
++ * exch_get() is NULL
++ */
++ WARN_ON(lp->tt.exch_put);
++ lp->tt.exch_get = fc_exch_get;
++ }
++
++ if (!lp->tt.seq_start_next)
++ lp->tt.seq_start_next = fc_seq_start_next;
++
++ if (!lp->tt.exch_seq_send)
++ lp->tt.exch_seq_send = fc_exch_seq_send;
++
++ if (!lp->tt.seq_send)
++ lp->tt.seq_send = fc_seq_send;
++
++ if (!lp->tt.seq_els_rsp_send)
++ lp->tt.seq_els_rsp_send = fc_seq_els_rsp_send;
++
++ if (!lp->tt.exch_done)
++ lp->tt.exch_done = fc_exch_done;
++
++ if (!lp->tt.exch_mgr_reset)
++ lp->tt.exch_mgr_reset = fc_exch_mgr_reset;
++
++ if (!lp->tt.seq_exch_abort)
++ lp->tt.seq_exch_abort = fc_seq_exch_abort;
++
++ if (!lp->tt.seq_get_xids)
++ lp->tt.seq_get_xids = fc_seq_get_xids;
++
++ if (!lp->tt.seq_set_rec_data)
++ lp->tt.seq_set_rec_data = fc_seq_set_rec_data;
++ return 0;
++}
++EXPORT_SYMBOL(fc_exch_init);
++
++int fc_setup_exch_mgr(void)
++{
++ fc_em_cachep = kmem_cache_create("libfc_em", sizeof(struct fc_exch),
++ 0, SLAB_HWCACHE_ALIGN, NULL);
++ if (!fc_em_cachep)
++ return -ENOMEM;
++ return 0;
++}
++
++void fc_destroy_exch_mgr(void)
++{
++ kmem_cache_destroy(fc_em_cachep);
++}
+diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
+new file mode 100644
+index 0000000..9402eba
+--- /dev/null
++++ b/drivers/scsi/libfc/fc_fcp.c
+@@ -0,0 +1,2174 @@
++/*
++ * 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,
++ * 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/module.h>
++#include <linux/kernel.h>
++#include <linux/types.h>
++#include <linux/spinlock.h>
++#include <linux/scatterlist.h>
++#include <linux/err.h>
++#include <linux/crc32.h>
++#include <linux/delay.h>
++
++#include <scsi/scsi_tcq.h>
++#include <scsi/scsi.h>
++#include <scsi/scsi_host.h>
++#include <scsi/scsi_device.h>
++#include <scsi/scsi_cmnd.h>
++
++#include <scsi/fc/fc_fc2.h>
++
++#include <scsi/libfc/libfc.h>
++
++int fc_fcp_debug;
++static struct kmem_cache *scsi_pkt_cachep;
++
++/* SRB state definitions */
++#define FC_SRB_FREE 0 /* cmd is free */
++#define FC_SRB_CMD_SENT (1 << 0) /* cmd has been sent */
++#define FC_SRB_RCV_STATUS (1 << 1) /* response has arrived */
++#define FC_SRB_ABORT_PENDING (1 << 2) /* cmd abort sent to device */
++#define FC_SRB_ABORTED (1 << 3) /* abort acknowleged */
++#define FC_SRB_DISCONTIG (1 << 4) /* non-sequential data recvd */
++#define FC_SRB_COMPL (1 << 5) /* fc_io_compl has been run */
++#define FC_SRB_FCP_PROCESSING_TMO (1 << 6) /* timer function processing */
++#define FC_SRB_NOMEM (1 << 7) /* dropped to out of mem */
++
++#define FC_SRB_READ (1 << 1)
++#define FC_SRB_WRITE (1 << 0)
++
++/*
++ * scsi request structure, one for each scsi request
++ */
++struct fc_fcp_pkt {
++ /*
++ * housekeeping stuff
++ */
++ struct fc_lport *lp; /* handle to hba struct */
++ u16 state; /* scsi_pkt state state */
++ u16 tgt_flags; /* target flags */
++ atomic_t ref_cnt; /* only used byr REC ELS */
++ spinlock_t scsi_pkt_lock; /* Must be taken before the host lock
++ * if both are held at the same time */
++ /*
++ * SCSI I/O related stuff
++ */
++ struct scsi_cmnd *cmd; /* scsi command pointer. set/clear
++ * under host lock */
++ struct list_head list; /* tracks queued commands. access under
++ * host lock */
++ /*
++ * timeout related stuff
++ */
++ struct timer_list timer; /* command timer */
++ struct completion tm_done;
++ int wait_for_comp;
++ unsigned long start_time; /* start jiffie */
++ unsigned long end_time; /* end jiffie */
++ unsigned long last_pkt_time; /* jiffies of last frame received */
++
++ /*
++ * scsi cmd and data transfer information
++ */
++ u32 data_len;
++ /*
++ * transport related veriables
++ */
++ struct fcp_cmnd cdb_cmd;
++ size_t xfer_len;
++ u32 xfer_contig_end; /* offset of end of contiguous xfer */
++ u16 max_payload; /* max payload size in bytes */
++
++ /*
++ * scsi/fcp return status
++ */
++ u32 io_status; /* SCSI result upper 24 bits */
++ u8 cdb_status;
++ u8 status_code; /* FCP I/O status */
++ /* bit 3 Underrun bit 2: overrun */
++ u8 scsi_comp_flags;
++ u32 req_flags; /* bit 0: read bit:1 write */
++ u32 scsi_resid; /* residule length */
++
++ struct fc_rport *rport; /* remote port pointer */
++ struct fc_seq *seq_ptr; /* current sequence pointer */
++ /*
++ * Error Processing
++ */
++ u8 recov_retry; /* count of recovery retries */
++ struct fc_seq *recov_seq; /* sequence for REC or SRR */
++};
++
++/*
++ * The SCp.ptr should be tested and set under the host lock. NULL indicates
++ * that the command has been retruned to the scsi layer.
++ */
++#define CMD_SP(Cmnd) ((struct fc_fcp_pkt *)(Cmnd)->SCp.ptr)
++#define CMD_ENTRY_STATUS(Cmnd) ((Cmnd)->SCp.have_data_in)
++#define CMD_COMPL_STATUS(Cmnd) ((Cmnd)->SCp.this_residual)
++#define CMD_SCSI_STATUS(Cmnd) ((Cmnd)->SCp.Status)
++#define CMD_RESID_LEN(Cmnd) ((Cmnd)->SCp.buffers_residual)
++
++struct fc_fcp_internal {
++ mempool_t *scsi_pkt_pool;
++ struct list_head scsi_pkt_queue;
++ u8 throttled;
++};
++
++#define fc_get_scsi_internal(x) ((struct fc_fcp_internal *)(x)->scsi_priv)
++
++/*
++ * function prototypes
++ * FC scsi I/O related functions
++ */
++static void fc_fcp_recv_data(struct fc_fcp_pkt *, struct fc_frame *);
++static void fc_fcp_recv(struct fc_seq *, struct fc_frame *, void *);
++static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
++static void fc_fcp_complete(struct fc_fcp_pkt *);
++static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
++static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp);
++static void fc_timeout_error(struct fc_fcp_pkt *);
++static int fc_fcp_send_cmd(struct fc_fcp_pkt *);
++static void fc_fcp_timeout(unsigned long data);
++static void fc_fcp_rec(struct fc_fcp_pkt *);
++static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
++static void fc_fcp_rec_resp(struct fc_seq *, struct fc_frame *, void *);
++static void fc_io_compl(struct fc_fcp_pkt *);
++
++static void fc_fcp_srr(struct fc_fcp_pkt *, enum fc_rctl, u32);
++static void fc_fcp_srr_resp(struct fc_seq *, struct fc_frame *, void *);
++static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
++
++/*
++ * command status codes
++ */
++#define FC_COMPLETE 0
++#define FC_CMD_ABORTED 1
++#define FC_CMD_RESET 2
++#define FC_CMD_PLOGO 3
++#define FC_SNS_RCV 4
++#define FC_TRANS_ERR 5
++#define FC_DATA_OVRRUN 6
++#define FC_DATA_UNDRUN 7
++#define FC_ERROR 8
++#define FC_HRD_ERROR 9
++#define FC_CMD_TIME_OUT 10
++
++/*
++ * Error recovery timeout values.
++ */
++#define FC_SCSI_ER_TIMEOUT (10 * HZ)
++#define FC_SCSI_TM_TOV (10 * HZ)
++#define FC_SCSI_REC_TOV (2 * HZ)
++#define FC_HOST_RESET_TIMEOUT (30 * HZ)
++
++#define FC_MAX_ERROR_CNT 5
++#define FC_MAX_RECOV_RETRY 3
++
++#define FC_FCP_DFLT_QUEUE_DEPTH 32
++
++/**
++ * fc_fcp_pkt_alloc - allocation routine for scsi_pkt packet
++ * @lp: fc lport struct
++ * @gfp: gfp flags for allocation
++ *
++ * This is used by upper layer scsi driver.
++ * Return Value : scsi_pkt structure or null on allocation failure.
++ * Context : call from process context. no locking required.
++ */
++static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lp, gfp_t gfp)
++{
++ struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
++ struct fc_fcp_pkt *sp;
++
++ sp = mempool_alloc(si->scsi_pkt_pool, gfp);
++ if (sp) {
++ memset(sp, 0, sizeof(*sp));
++ sp->lp = lp;
++ atomic_set(&sp->ref_cnt, 1);
++ init_timer(&sp->timer);
++ INIT_LIST_HEAD(&sp->list);
++ }
++ return sp;
++}
++
++/**
++ * fc_fcp_pkt_release - release hold on scsi_pkt packet
++ * @sp: fcp packet struct
++ *
++ * This is used by upper layer scsi driver.
++ * Context : call from process and interrupt context.
++ * no locking required
++ */
++static void fc_fcp_pkt_release(struct fc_fcp_pkt *sp)
++{
++ if (atomic_dec_and_test(&sp->ref_cnt)) {
++ struct fc_fcp_internal *si = fc_get_scsi_internal(sp->lp);
++
++ mempool_free(sp, si->scsi_pkt_pool);
++ }
++}
++
++static void fc_fcp_pkt_hold(struct fc_fcp_pkt *sp)
++{
++ atomic_inc(&sp->ref_cnt);
++}
++
++/**
++ * fc_fcp_lock_pkt - lock a packet and get a ref to it.
++ * @fsp: fcp packet
++ *
++ * We should only return error if we return a command to scsi-ml before
++ * getting a response. This can happen in cases where we send a abort, but
++ * do not wait for the response and the abort and command can be passing
++ * each other on the wire/network-layer.
++ *
++ * Note: this function locks the packet and gets a reference to allow
++ * callers to call the completion function while the lock is held and
++ * not have to worry about the packets refcount.
++ *
++ * TODO: Maybe we should just have callers grab/release the lock and
++ * have a function that they call to verify the fsp and grab a ref if
++ * needed.
++ */
++static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
++{
++ spin_lock_bh(&fsp->scsi_pkt_lock);
++ if (!fsp->cmd) {
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++ FC_DBG("Invalid scsi cmd pointer on fcp packet.\n");
++ return -EINVAL;
++ }
++
++ fc_fcp_pkt_hold(fsp);
++ return 0;
++}
++
++static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
++{
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++ fc_fcp_pkt_release(fsp);
++}
++
++static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
++{
++ if (!(fsp->state & FC_SRB_COMPL))
++ mod_timer(&fsp->timer, jiffies + delay);
++}
++
++static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
++{
++ if (!fsp->seq_ptr)
++ return -EINVAL;
++
++ fsp->state |= FC_SRB_ABORT_PENDING;
++ return fsp->lp->tt.seq_exch_abort(fsp->seq_ptr, 0);
++}
++
++/*
++ * Retry command.
++ * An abort isn't needed.
++ */
++static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
++{
++ if (fsp->seq_ptr) {
++ fsp->lp->tt.exch_done(fsp->seq_ptr);
++ fsp->seq_ptr = NULL;
++ }
++
++ fsp->state &= ~FC_SRB_ABORT_PENDING;
++ fsp->io_status = SUGGEST_RETRY << 24;
++ fsp->status_code = FC_ERROR;
++ fc_fcp_complete(fsp);
++}
++
++/*
++ * Receive SCSI data from target.
++ * Called after receiving solicited data.
++ */
++static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
++{
++ struct scsi_cmnd *sc = fsp->cmd;
++ struct fc_lport *lp = fsp->lp;
++ struct fcoe_dev_stats *sp;
++ struct fc_frame_header *fh;
++ size_t start_offset;
++ size_t offset;
++ u32 crc;
++ u32 copy_len = 0;
++ size_t len;
++ void *buf;
++ struct scatterlist *sg;
++ size_t remaining;
++
++ fh = fc_frame_header_get(fp);
++ offset = ntohl(fh->fh_parm_offset);
++ start_offset = offset;
++ len = fr_len(fp) - sizeof(*fh);
++ buf = fc_frame_payload_get(fp, 0);
++
++ if (offset + len > fsp->data_len) {
++ /*
++ * this should never happen
++ */
++ if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&
++ fc_frame_crc_check(fp))
++ goto crc_err;
++ if (fc_fcp_debug) {
++ FC_DBG("data received past end. "
++ "len %zx offset %zx "
++ "data_len %x\n", len, offset, fsp->data_len);
++ }
++ fc_fcp_retry_cmd(fsp);
++ return;
++ }
++ if (offset != fsp->xfer_len)
++ fsp->state |= FC_SRB_DISCONTIG;
++
++ crc = 0;
++ if (fr_flags(fp) & FCPHF_CRC_UNCHECKED)
++ crc = crc32(~0, (u8 *) fh, sizeof(*fh));
++
++ sg = scsi_sglist(sc);
++ remaining = len;
++
++ while (remaining > 0 && sg) {
++ size_t off;
++ void *page_addr;
++ size_t sg_bytes;
++
++ if (offset >= sg->length) {
++ offset -= sg->length;
++ sg = sg_next(sg);
++ continue;
++ }
++ sg_bytes = min(remaining, sg->length - offset);
++
++ /*
++ * The scatterlist item may be bigger than PAGE_SIZE,
++ * but we are limited to mapping PAGE_SIZE at a time.
++ */
++ off = offset + sg->offset;
++ sg_bytes = min(sg_bytes, (size_t)
++ (PAGE_SIZE - (off & ~PAGE_MASK)));
++ page_addr = kmap_atomic(sg_page(sg) + (off >> PAGE_SHIFT),
++ KM_SOFTIRQ0);
++ if (!page_addr)
++ break; /* XXX panic? */
++
++ if (fr_flags(fp) & FCPHF_CRC_UNCHECKED)
++ crc = crc32(crc, buf, sg_bytes);
++ memcpy((char *)page_addr + (off & ~PAGE_MASK), buf,
++ sg_bytes);
++
++ kunmap_atomic(page_addr, KM_SOFTIRQ0);
++ buf += sg_bytes;
++ offset += sg_bytes;
++ remaining -= sg_bytes;
++ copy_len += sg_bytes;
++ }
++
++ if (fr_flags(fp) & FCPHF_CRC_UNCHECKED) {
++ buf = fc_frame_payload_get(fp, 0);
++ if (len % 4) {
++ crc = crc32(crc, buf + len, 4 - (len % 4));
++ len += 4 - (len % 4);
++ }
++
++ if (~crc != le32_to_cpu(*(__le32 *)(buf + len))) {
++crc_err:
++ sp = lp->dev_stats[smp_processor_id()];
++ sp->ErrorFrames++;
++ if (sp->InvalidCRCCount++ < 5)
++ FC_DBG("CRC error on data frame\n");
++ /*
++ * Assume the frame is total garbage.
++ * We may have copied it over the good part
++ * of the buffer.
++ * If so, we need to retry the entire operation.
++ * Otherwise, ignore it.
++ */
++ if (fsp->state & FC_SRB_DISCONTIG)
++ fc_fcp_retry_cmd(fsp);
++ return;
++ }
++ }
++
++ if (fsp->xfer_contig_end == start_offset)
++ fsp->xfer_contig_end += copy_len;
++ fsp->xfer_len += copy_len;
++
++ /*
++ * In the very rare event that this data arrived after the response
++ * and completes the transfer, call the completion handler.
++ */
++ if (unlikely(fsp->state & FC_SRB_RCV_STATUS) &&
++ fsp->xfer_len == fsp->data_len - fsp->scsi_resid)
++ fc_fcp_complete(fsp);
++}
++
++/*
++ * Send SCSI data to target.
++ * Called after receiving a Transfer Ready data descriptor.
++ */
++static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *sp,
++ size_t offset, size_t len,
++ struct fc_frame *oldfp, int sg_supp)
++{
++ struct scsi_cmnd *sc;
++ struct scatterlist *sg;
++ struct fc_frame *fp = NULL;
++ struct fc_lport *lp = fsp->lp;
++ size_t remaining;
++ size_t mfs;
++ size_t tlen;
++ size_t sg_bytes;
++ size_t frame_offset;
++ int error;
++ void *data = NULL;
++ void *page_addr;
++ int using_sg = sg_supp;
++ u32 f_ctl;
++
++ if (unlikely(offset + len > fsp->data_len)) {
++ /*
++ * this should never happen
++ */
++ if (fc_fcp_debug) {
++ FC_DBG("xfer-ready past end. len %zx offset %zx\n",
++ len, offset);
++ }
++ fc_fcp_send_abort(fsp);
++ return 0;
++ } else if (offset != fsp->xfer_len) {
++ /*
++ * Out of Order Data Request - no problem, but unexpected.
++ */
++ if (fc_fcp_debug) {
++ FC_DBG("xfer-ready non-contiguous. "
++ "len %zx offset %zx\n", len, offset);
++ }
++ }
++ mfs = fsp->max_payload;
++ WARN_ON(mfs > FC_MAX_PAYLOAD);
++ WARN_ON(mfs < FC_MIN_MAX_PAYLOAD);
++ if (mfs > 512)
++ mfs &= ~(512 - 1); /* round down to block size */
++ WARN_ON(mfs < FC_MIN_MAX_PAYLOAD); /* won't go below 256 */
++ WARN_ON(len <= 0);
++ sc = fsp->cmd;
++
++ remaining = len;
++ frame_offset = offset;
++ tlen = 0;
++ sp = lp->tt.seq_start_next(sp);
++ f_ctl = FC_FC_REL_OFF;
++ WARN_ON(!sp);
++
++ /*
++ * If a get_page()/put_page() will fail, don't use sg lists
++ * in the fc_frame structure.
++ *
++ * The put_page() may be long after the I/O has completed
++ * in the case of FCoE, since the network driver does it
++ * via free_skb(). See the test in free_pages_check().
++ *
++ * Test this case with 'dd </dev/zero >/dev/st0 bs=64k'.
++ */
++ if (using_sg) {
++ for (sg = scsi_sglist(sc); sg; sg = sg_next(sg)) {
++ if (page_count(sg_page(sg)) == 0 ||
++ (sg_page(sg)->flags & (1 << PG_lru |
++ 1 << PG_private |
++ 1 << PG_locked |
++ 1 << PG_active |
++ 1 << PG_slab |
++ 1 << PG_swapcache |
++ 1 << PG_writeback |
++ 1 << PG_reserved |
++ 1 << PG_buddy))) {
++ using_sg = 0;
++ break;
++ }
++ }
++ }
++ sg = scsi_sglist(sc);
++
++ while (remaining > 0 && sg) {
++ if (offset >= sg->length) {
++ offset -= sg->length;
++ sg = sg_next(sg);
++ continue;
++ }
++ if (!fp) {
++ tlen = min(mfs, remaining);
++
++ /*
++ * TODO. Temporary workaround. fc_seq_send() can't
++ * handle odd lengths in non-linear skbs.
++ * This will be the final fragment only.
++ */
++ if (tlen % 4)
++ using_sg = 0;
++ if (using_sg) {
++ fp = _fc_frame_alloc(lp, 0);
++ if (!fp)
++ return -ENOMEM;
++ } else {
++ fp = fc_frame_alloc(lp, tlen);
++ if (!fp)
++ return -ENOMEM;
++
++ data = (void *)(fr_hdr(fp)) +
++ sizeof(struct fc_frame_header);
++ }
++ fc_frame_setup(fp, FC_RCTL_DD_SOL_DATA, FC_TYPE_FCP);
++ fc_frame_set_offset(fp, frame_offset);
++ }
++ sg_bytes = min(tlen, sg->length - offset);
++ if (using_sg) {
++ WARN_ON(skb_shinfo(fp_skb(fp))->nr_frags >
++ FC_FRAME_SG_LEN);
++ get_page(sg_page(sg));
++ skb_fill_page_desc(fp_skb(fp),
++ skb_shinfo(fp_skb(fp))->nr_frags,
++ sg_page(sg), sg->offset + offset,
++ sg_bytes);
++ fp_skb(fp)->data_len += sg_bytes;
++ fr_len(fp) += sg_bytes;
++ fp_skb(fp)->truesize += PAGE_SIZE;
++ } else {
++ size_t off = offset + sg->offset;
++
++ /*
++ * The scatterlist item may be bigger than PAGE_SIZE,
++ * but we must not cross pages inside the kmap.
++ */
++ sg_bytes = min(sg_bytes, (size_t) (PAGE_SIZE -
++ (off & ~PAGE_MASK)));
++ page_addr = kmap_atomic(sg_page(sg) +
++ (off >> PAGE_SHIFT),
++ KM_SOFTIRQ0);
++ memcpy(data, (char *)page_addr + (off & ~PAGE_MASK),
++ sg_bytes);
++ kunmap_atomic(page_addr, KM_SOFTIRQ0);
++ data += sg_bytes;
++ }
++ offset += sg_bytes;
++ frame_offset += sg_bytes;
++ tlen -= sg_bytes;
++ remaining -= sg_bytes;
++
++ if (remaining == 0) {
++ /*
++ * Send a request sequence with
++ * transfer sequence initiative.
++ */
++ f_ctl |= FC_FC_SEQ_INIT | FC_FC_END_SEQ;
++ error = lp->tt.seq_send(lp, sp, fp, f_ctl);
++ } else if (tlen == 0) {
++ /*
++ * send fragment using for a sequence.
++ */
++ error = lp->tt.seq_send(lp, sp, fp, f_ctl);
++ } else {
++ continue;
++ }
++ fp = NULL;
++
++ if (error) {
++ WARN_ON(1); /* send error should be rare */
++ fc_fcp_retry_cmd(fsp);
++ return 0;
++ }
++ }
++ fsp->xfer_len += len; /* premature count? */
++ return 0;
++}
++
++static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame_header *fh)
++{
++ /*
++ * we will let the command timeout and scsi-ml escalate if
++ * the abort was rejected
++ */
++ if (fh->fh_r_ctl == FC_RCTL_BA_ACC) {
++ fsp->state |= FC_SRB_ABORTED;
++ fsp->state &= ~FC_SRB_ABORT_PENDING;
++
++ if (fsp->wait_for_comp)
++ complete(&fsp->tm_done);
++ else
++ fc_fcp_complete(fsp);
++ }
++}
++
++/*
++ * fc_fcp_reduce_can_queue - drop can_queue
++ * @lp: lport to drop queueing for
++ *
++ * If we are getting memory allocation failures, then we may
++ * be trying to execute too many commands. We let the running
++ * commands complete or timeout, then try again with a reduced
++ * can_queue. Eventually we will hit the point where we run
++ * on all reserved structs.
++ */
++static void fc_fcp_reduce_can_queue(struct fc_lport *lp)
++{
++ struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
++ unsigned long flags;
++ int can_queue;
++
++ spin_lock_irqsave(lp->host->host_lock, flags);
++ if (si->throttled)
++ goto done;
++ si->throttled = 1;
++
++ can_queue = lp->host->can_queue;
++ can_queue >>= 1;
++ if (!can_queue)
++ can_queue = 1;
++ lp->host->can_queue = can_queue;
++ shost_printk(KERN_ERR, lp->host, "Could not allocate frame.\n"
++ "Reducing can_queue to %d.\n", can_queue);
++done:
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++}
++
++/*
++ * exch mgr calls this routine to process scsi
++ * exchanges.
++ *
++ * Return : None
++ * Context : called from Soft IRQ context
++ * can not called holding list lock
++ */
++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;
++ u8 r_ctl;
++ int rc = 0;
++
++ if (IS_ERR(fp))
++ goto errout;
++
++ fh = fc_frame_header_get(fp);
++ r_ctl = fh->fh_r_ctl;
++ lp = fsp->lp;
++
++ if (!(lp->state & LPORT_ST_READY))
++ goto out;
++ if (fc_fcp_lock_pkt(fsp))
++ goto out;
++ fsp->last_pkt_time = jiffies;
++
++ if (fh->fh_type == FC_TYPE_BLS) {
++ fc_fcp_abts_resp(fsp, fh);
++ goto unlock;
++ }
++
++ if (fsp->state & (FC_SRB_ABORTED | FC_SRB_ABORT_PENDING))
++ goto unlock;
++
++ if (r_ctl == FC_RCTL_DD_DATA_DESC) {
++ /*
++ * received XFER RDY from the target
++ * need to send data to the target
++ */
++ WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
++ dd = fc_frame_payload_get(fp, sizeof(*dd));
++ WARN_ON(!dd);
++
++ rc = fc_fcp_send_data(fsp, sp,
++ (size_t) ntohl(dd->dd_offset),
++ (size_t) ntohl(dd->dd_len), fp,
++ lp->capabilities & TRANS_C_SG);
++ if (!rc)
++ lp->tt.seq_set_rec_data(sp, fsp->xfer_len);
++ else if (rc == -ENOMEM)
++ fsp->state |= FC_SRB_NOMEM;
++ } else if (r_ctl == FC_RCTL_DD_SOL_DATA) {
++ /*
++ * received a DATA frame
++ * next we will copy the data to the system buffer
++ */
++ WARN_ON(fr_len(fp) < sizeof(*fh)); /* len may be 0 */
++ fc_fcp_recv_data(fsp, fp);
++ lp->tt.seq_set_rec_data(sp, fsp->xfer_contig_end);
++ } else if (r_ctl == FC_RCTL_DD_CMD_STATUS) {
++ WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
++
++ fc_fcp_resp(fsp, fp);
++ } else {
++ FC_DBG("unexpected frame. r_ctl %x\n", r_ctl);
++ }
++unlock:
++ fc_fcp_unlock_pkt(fsp);
++out:
++ fc_frame_free(fp);
++errout:
++ if (IS_ERR(fp))
++ fc_fcp_error(fsp, fp);
++ else if (rc == -ENOMEM)
++ fc_fcp_reduce_can_queue(lp);
++}
++
++static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
++{
++ struct fc_frame_header *fh;
++ struct fcp_resp *fc_rp;
++ struct fcp_resp_ext *rp_ex;
++ struct fcp_resp_rsp_info *fc_rp_info;
++ u32 plen;
++ u32 expected_len;
++ u32 respl = 0;
++ u32 snsl = 0;
++ u8 flags = 0;
++
++ plen = fr_len(fp);
++ fh = (struct fc_frame_header *)fr_hdr(fp);
++ if (unlikely(plen < sizeof(*fh) + sizeof(*fc_rp)))
++ goto len_err;
++ plen -= sizeof(*fh);
++ fc_rp = (struct fcp_resp *)(fh + 1);
++ fsp->cdb_status = fc_rp->fr_status;
++ flags = fc_rp->fr_flags;
++ fsp->scsi_comp_flags = flags;
++ expected_len = fsp->data_len;
++
++ if (unlikely((flags & ~FCP_CONF_REQ) || fc_rp->fr_status)) {
++ rp_ex = (void *)(fc_rp + 1);
++ if (flags & (FCP_RSP_LEN_VAL | FCP_SNS_LEN_VAL)) {
++ if (plen < sizeof(*fc_rp) + sizeof(*rp_ex))
++ goto len_err;
++ fc_rp_info = (struct fcp_resp_rsp_info *)(rp_ex + 1);
++ if (flags & FCP_RSP_LEN_VAL) {
++ respl = ntohl(rp_ex->fr_rsp_len);
++ if (respl != sizeof(*fc_rp_info))
++ goto len_err;
++ if (fsp->wait_for_comp) {
++ /* Abuse cdb_status for rsp code */
++ fsp->cdb_status = fc_rp_info->rsp_code;
++ complete(&fsp->tm_done);
++ /*
++ * tmfs will not have any scsi cmd so
++ * exit here
++ */
++ return;
++ } else
++ goto err;
++ }
++ if (flags & FCP_SNS_LEN_VAL) {
++ snsl = ntohl(rp_ex->fr_sns_len);
++ if (snsl > SCSI_SENSE_BUFFERSIZE)
++ snsl = SCSI_SENSE_BUFFERSIZE;
++ memcpy(fsp->cmd->sense_buffer,
++ (char *)fc_rp_info + respl, snsl);
++ }
++ }
++ if (flags & (FCP_RESID_UNDER | FCP_RESID_OVER)) {
++ if (plen < sizeof(*fc_rp) + sizeof(rp_ex->fr_resid))
++ goto len_err;
++ if (flags & FCP_RESID_UNDER) {
++ fsp->scsi_resid = ntohl(rp_ex->fr_resid);
++ /*
++ * The cmnd->underflow is the minimum number of
++ * bytes that must be transfered for this
++ * command. Provided a sense condition is not
++ * present, make sure the actual amount
++ * transferred is at least the underflow value
++ * or fail.
++ */
++ if (!(flags & FCP_SNS_LEN_VAL) &&
++ (fc_rp->fr_status == 0) &&
++ (scsi_bufflen(fsp->cmd) -
++ fsp->scsi_resid) < fsp->cmd->underflow)
++ goto err;
++ expected_len -= fsp->scsi_resid;
++ } else {
++ fsp->status_code = FC_ERROR;
++ }
++ }
++ }
++ fsp->state |= FC_SRB_RCV_STATUS;
++
++ /*
++ * Check for missing or extra data frames.
++ */
++ if (unlikely(fsp->xfer_len != expected_len)) {
++ if (fsp->xfer_len < expected_len) {
++ /*
++ * Some data may be queued locally,
++ * Wait a at least one jiffy to see if it is delivered.
++ * If this expires without data, we may do SRR.
++ */
++ fc_fcp_timer_set(fsp, 2);
++ return;
++ }
++ fsp->status_code = FC_DATA_OVRRUN;
++ FC_DBG("tgt %6x xfer len %zx greater than expected len %x. "
++ "data len %x\n",
++ fsp->rport->port_id,
++ fsp->xfer_len, expected_len, fsp->data_len);
++ }
++ fc_fcp_complete(fsp);
++ return;
++
++len_err:
++ FC_DBG("short FCP response. flags 0x%x len %u respl %u snsl %u\n",
++ flags, fr_len(fp), respl, snsl);
++err:
++ fsp->status_code = FC_ERROR;
++ fc_fcp_complete(fsp);
++}
++
++/**
++ * fc_fcp_complete - complete processing of a fcp packet
++ * @fsp: fcp packet
++ *
++ * This function may sleep if a timer is pending. The packet lock must be
++ * held, and the host lock must not be held.
++ */
++static void fc_fcp_complete(struct fc_fcp_pkt *fsp)
++{
++ struct fc_lport *lp = fsp->lp;
++ struct fc_seq *sp;
++ u32 f_ctl;
++
++ if (fsp->state & FC_SRB_ABORT_PENDING)
++ return;
++
++ if (fsp->state & FC_SRB_ABORTED) {
++ if (!fsp->status_code)
++ fsp->status_code = FC_CMD_ABORTED;
++ } else {
++ /*
++ * Test for transport underrun, independent of response
++ * underrun status.
++ */
++ if (fsp->xfer_len < fsp->data_len && !fsp->io_status &&
++ (!(fsp->scsi_comp_flags & FCP_RESID_UNDER) ||
++ fsp->xfer_len < fsp->data_len - fsp->scsi_resid)) {
++ fsp->status_code = FC_DATA_UNDRUN;
++ fsp->io_status = SUGGEST_RETRY << 24;
++ }
++ }
++
++ sp = fsp->seq_ptr;
++ if (sp) {
++ fsp->seq_ptr = NULL;
++ if (unlikely(fsp->scsi_comp_flags & FCP_CONF_REQ)) {
++ struct fc_frame *conf_frame;
++ struct fc_seq *csp;
++
++ csp = lp->tt.seq_start_next(sp);
++ conf_frame = fc_frame_alloc(fsp->lp, 0);
++ if (conf_frame) {
++ fc_frame_setup(conf_frame,
++ FC_RCTL_DD_SOL_CTL, FC_TYPE_FCP);
++ f_ctl = FC_FC_SEQ_INIT;
++ f_ctl |= FC_FC_LAST_SEQ | FC_FC_END_SEQ;
++ lp->tt.seq_send(lp, csp, conf_frame, f_ctl);
++ }
++ }
++ lp->tt.exch_done(sp);
++ }
++ fc_io_compl(fsp);
++}
++
++static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
++{
++ struct fc_lport *lp = fsp->lp;
++
++ if (fsp->seq_ptr) {
++ lp->tt.exch_done(fsp->seq_ptr);
++ fsp->seq_ptr = NULL;
++ }
++ fsp->status_code = error;
++}
++
++/**
++ * fc_fcp_cleanup_each_cmd - run fn on each active command
++ * @lp: logical port
++ * @id: target id
++ * @lun: lun
++ * @error: fsp status code
++ *
++ * If lun or id is -1, they are ignored.
++ */
++static void fc_fcp_cleanup_each_cmd(struct fc_lport *lp, unsigned int id,
++ unsigned int lun, int error)
++{
++ struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
++ struct fc_fcp_pkt *fsp;
++ struct scsi_cmnd *sc_cmd;
++ unsigned long flags;
++
++ spin_lock_irqsave(lp->host->host_lock, flags);
++restart:
++ list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
++ sc_cmd = fsp->cmd;
++ if (id != -1 && scmd_id(sc_cmd) != id)
++ continue;
++
++ if (lun != -1 && sc_cmd->device->lun != lun)
++ continue;
++
++ fc_fcp_pkt_hold(fsp);
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++
++ if (!fc_fcp_lock_pkt(fsp)) {
++ fc_fcp_cleanup_cmd(fsp, error);
++ fc_io_compl(fsp);
++ fc_fcp_unlock_pkt(fsp);
++ }
++
++ fc_fcp_pkt_release(fsp);
++ spin_lock_irqsave(lp->host->host_lock, flags);
++ /*
++ * while we dropped the lock multiple pkts could
++ * have been released, so we have to start over.
++ */
++ goto restart;
++ }
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++}
++
++static void fc_fcp_abort_io(struct fc_lport *lp)
++{
++ fc_fcp_cleanup_each_cmd(lp, -1, -1, FC_HRD_ERROR);
++}
++
++/**
++ * fc_fcp_pkt_send - send a fcp packet to the lower level.
++ * @lp: fc lport
++ * @fsp: fc packet.
++ *
++ * This is called by upper layer protocol.
++ * Return : zero for success and -1 for failure
++ * Context : called from queuecommand which can be called from process
++ * or scsi soft irq.
++ * Locks : called with the host lock and irqs disabled.
++ */
++static int fc_fcp_pkt_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
++{
++ struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
++ int rc;
++
++ fsp->cmd->SCp.ptr = (char *)fsp;
++ fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
++ fsp->cdb_cmd.fc_flags = fsp->req_flags & ~FCP_CFL_LEN_MASK;
++
++ int_to_scsilun(fsp->cmd->device->lun,
++ (struct scsi_lun *)fsp->cdb_cmd.fc_lun);
++ memcpy(fsp->cdb_cmd.fc_cdb, fsp->cmd->cmnd, fsp->cmd->cmd_len);
++ list_add_tail(&fsp->list, &si->scsi_pkt_queue);
++
++ spin_unlock_irq(lp->host->host_lock);
++ rc = fc_fcp_send_cmd(fsp);
++ spin_lock_irq(lp->host->host_lock);
++ if (rc)
++ list_del(&fsp->list);
++
++ return rc;
++}
++
++static int fc_fcp_send_cmd(struct fc_fcp_pkt *fsp)
++{
++ struct fc_lport *lp;
++ struct fc_frame *fp;
++ struct fc_seq *sp;
++ struct fc_rport *rport;
++ struct fc_rport_libfc_priv *rp;
++ int rc = 0;
++
++ if (fc_fcp_lock_pkt(fsp))
++ return 0;
++
++ if (fsp->state & FC_SRB_COMPL)
++ goto unlock;
++
++ lp = fsp->lp;
++ fp = fc_frame_alloc(lp, sizeof(fsp->cdb_cmd));
++ if (!fp) {
++ rc = -1;
++ goto unlock;
++ }
++
++ memcpy(fc_frame_payload_get(fp, sizeof(fsp->cdb_cmd)),
++ &fsp->cdb_cmd, sizeof(fsp->cdb_cmd));
++ fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CMD, FC_TYPE_FCP);
++ fc_frame_set_offset(fp, 0);
++ rport = fsp->rport;
++ fsp->max_payload = rport->maxframe_size;
++ rp = rport->dd_data;
++ sp = lp->tt.exch_seq_send(lp, fp,
++ fc_fcp_recv,
++ fsp, 0,
++ rp->local_port->fid,
++ rport->port_id,
++ FC_FC_SEQ_INIT | FC_FC_END_SEQ);
++ if (!sp) {
++ fc_frame_free(fp);
++ rc = -1;
++ goto unlock;
++ }
++ fsp->seq_ptr = sp;
++
++ setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
++ fc_fcp_timer_set(fsp,
++ (fsp->tgt_flags & FC_RP_FLAGS_REC_SUPPORTED) ?
++ FC_SCSI_REC_TOV : FC_SCSI_ER_TIMEOUT);
++unlock:
++ fc_fcp_unlock_pkt(fsp);
++ return rc;
++}
++
++/*
++ * transport error handler
++ */
++static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
++{
++ int error = PTR_ERR(fp);
++
++ if (fc_fcp_lock_pkt(fsp))
++ return;
++
++ switch (error) {
++ case -FC_EX_CLOSED:
++ fc_fcp_retry_cmd(fsp);
++ goto unlock;
++ default:
++ FC_DBG("unknown error %ld\n", PTR_ERR(fp));
++ }
++ /*
++ * clear abort pending, because the lower layer
++ * decided to force completion.
++ */
++ fsp->state &= ~FC_SRB_ABORT_PENDING;
++ fsp->status_code = FC_CMD_PLOGO;
++ fc_fcp_complete(fsp);
++unlock:
++ fc_fcp_unlock_pkt(fsp);
++}
++
++/*
++ * Scsi abort handler- calls to send an abort
++ * and then wait for abort completion
++ */
++static int fc_fcp_pkt_abort(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
++{
++ int rc = FAILED;
++
++ if (fc_fcp_send_abort(fsp))
++ return FAILED;
++
++ init_completion(&fsp->tm_done);
++ fsp->wait_for_comp = 1;
++
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++ rc = wait_for_completion_timeout(&fsp->tm_done, FC_SCSI_TM_TOV);
++ spin_lock_bh(&fsp->scsi_pkt_lock);
++ fsp->wait_for_comp = 0;
++
++ if (!rc) {
++ FC_DBG("target abort cmd failed\n");
++ rc = FAILED;
++ } else if (fsp->state & FC_SRB_ABORTED) {
++ FC_DBG("target abort cmd passed\n");
++ rc = SUCCESS;
++ fc_fcp_complete(fsp);
++ }
++
++ return rc;
++}
++
++/*
++ * Retry LUN reset after resource allocation failed.
++ */
++static void fc_lun_reset_send(unsigned long data)
++{
++ struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
++ const size_t len = sizeof(fsp->cdb_cmd);
++ struct fc_lport *lp = fsp->lp;
++ struct fc_frame *fp;
++ struct fc_seq *sp;
++ struct fc_rport *rport;
++ struct fc_rport_libfc_priv *rp;
++
++ spin_lock_bh(&fsp->scsi_pkt_lock);
++ if (fsp->state & FC_SRB_COMPL)
++ goto unlock;
++
++ fp = fc_frame_alloc(lp, len);
++ if (!fp)
++ goto retry;
++ memcpy(fc_frame_payload_get(fp, len), &fsp->cdb_cmd, len);
++ fc_frame_setup(fp, FC_RCTL_DD_UNSOL_CMD, FC_TYPE_FCP);
++ fc_frame_set_offset(fp, 0);
++ rport = fsp->rport;
++ rp = rport->dd_data;
++ sp = lp->tt.exch_seq_send(lp, fp,
++ fc_tm_done,
++ fsp, 0,
++ rp->local_port->fid,
++ rport->port_id,
++ FC_FC_SEQ_INIT | FC_FC_END_SEQ);
++
++ if (sp) {
++ fsp->seq_ptr = sp;
++ goto unlock;
++ }
++ /*
++ * Exchange or frame allocation failed. Set timer and retry.
++ */
++ fc_frame_free(fp);
++retry:
++ setup_timer(&fsp->timer, fc_lun_reset_send, (unsigned long)fsp);
++ fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
++unlock:
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++}
++
++/*
++ * Scsi device reset handler- send a LUN RESET to the device
++ * and wait for reset reply
++ */
++static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
++ unsigned int id, unsigned int lun)
++{
++ int rc;
++
++ fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
++ fsp->cdb_cmd.fc_tm_flags = FCP_TMF_LUN_RESET;
++ int_to_scsilun(lun, (struct scsi_lun *)fsp->cdb_cmd.fc_lun);
++
++ fsp->wait_for_comp = 1;
++ init_completion(&fsp->tm_done);
++
++ fc_lun_reset_send((unsigned long)fsp);
++
++ /*
++ * wait for completion of reset
++ * after that make sure all commands are terminated
++ */
++ rc = wait_for_completion_timeout(&fsp->tm_done, FC_SCSI_TM_TOV);
++
++ spin_lock_bh(&fsp->scsi_pkt_lock);
++ fsp->state |= FC_SRB_COMPL;
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++
++ del_timer_sync(&fsp->timer);
++
++ 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;
++ }
++ fsp->wait_for_comp = 0;
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++
++ if (!rc) {
++ FC_DBG("lun reset failed\n");
++ return FAILED;
++ }
++
++ /* cdb_status holds the tmf's rsp code */
++ if (fsp->cdb_status != FCP_TMF_CMPL)
++ return FAILED;
++
++ FC_DBG("lun reset to lun %u completed\n", lun);
++ fc_fcp_cleanup_each_cmd(lp, id, lun, FC_CMD_ABORTED);
++ return SUCCESS;
++}
++
++/*
++ * Task Managment response handler
++ */
++static void fc_tm_done(struct fc_seq *sp, struct fc_frame *fp, void *arg)
++{
++ struct fc_fcp_pkt *fsp = arg;
++ struct fc_frame_header *fh;
++
++ spin_lock_bh(&fsp->scsi_pkt_lock);
++ if (IS_ERR(fp)) {
++ /*
++ * If there is an error just let it timeout or wait
++ * for TMF to be aborted if it timedout.
++ *
++ * scsi-eh will escalate for when either happens.
++ */
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++ return;
++ }
++
++ /*
++ * 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) {
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++ return;
++ }
++
++ fh = fc_frame_header_get(fp);
++ if (fh->fh_type != FC_TYPE_BLS)
++ fc_fcp_resp(fsp, fp);
++ fsp->seq_ptr = NULL;
++ fsp->lp->tt.exch_done(sp);
++ fc_frame_free(fp);
++ spin_unlock_bh(&fsp->scsi_pkt_lock);
++}
++
++static void fc_fcp_cleanup(struct fc_lport *lp)
++{
++ fc_fcp_cleanup_each_cmd(lp, -1, -1, FC_ERROR);
++}
++
++/*
++ * fc_fcp_timeout: called by OS timer function.
++ *
++ * The timer has been inactivated and must be reactivated if desired
++ * using fc_fcp_timer_set().
++ *
++ * Algorithm:
++ *
++ * If REC is supported, just issue it, and return. The REC exchange will
++ * complete or time out, and recovery can continue at that point.
++ *
++ * Otherwise, if the response has been received without all the data,
++ * it has been ER_TIMEOUT since the response was received.
++ *
++ * If the response has not been received,
++ * we see if data was received recently. If it has been, we continue waiting,
++ * otherwise, we abort the command.
++ */
++static void fc_fcp_timeout(unsigned long data)
++{
++ struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
++ struct fc_rport *rport = fsp->rport;
++ struct fc_rport_libfc_priv *rp = rport->dd_data;
++
++ if (fc_fcp_lock_pkt(fsp))
++ return;
++
++ if (fsp->state & FC_SRB_COMPL)
++ goto unlock;
++ fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
++
++ 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)
++ 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);
++}
++
++/*
++ * Send a REC ELS request
++ */
++static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
++{
++ struct fc_lport *lp;
++ struct fc_seq *sp;
++ struct fc_frame *fp;
++ struct fc_els_rec *rec;
++ struct fc_rport *rport;
++ struct fc_rport_libfc_priv *rp;
++ u16 ox_id;
++ u16 rx_id;
++
++ lp = fsp->lp;
++ rport = fsp->rport;
++ rp = rport->dd_data;
++ sp = fsp->seq_ptr;
++ if (!sp || rp->rp_state != RPORT_ST_READY) {
++ fsp->status_code = FC_HRD_ERROR;
++ fsp->io_status = SUGGEST_RETRY << 24;
++ fc_fcp_complete(fsp);
++ return;
++ }
++ lp->tt.seq_get_xids(sp, &ox_id, &rx_id);
++ fp = fc_frame_alloc(lp, sizeof(*rec));
++ if (!fp)
++ goto retry;
++
++ rec = fc_frame_payload_get(fp, sizeof(*rec));
++ memset(rec, 0, sizeof(*rec));
++ rec->rec_cmd = ELS_REC;
++ hton24(rec->rec_s_id, lp->fid);
++ rec->rec_ox_id = htons(ox_id);
++ rec->rec_rx_id = htons(rx_id);
++
++ 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,
++ fsp, jiffies_to_msecs(FC_SCSI_REC_TOV),
++ rp->local_port->fid,
++ rport->port_id,
++ FC_FC_SEQ_INIT | FC_FC_END_SEQ);
++
++ if (sp) {
++ fc_fcp_pkt_hold(fsp); /* hold while REC outstanding */
++ return;
++ } else
++ fc_frame_free(fp);
++retry:
++ if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
++ fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
++ else
++ fc_timeout_error(fsp);
++}
++
++/*
++ * Receive handler for REC ELS frame
++ * if it is a reject then let the scsi layer to handle
++ * the timeout. if it is a LS_ACC then if the io was not completed
++ * then set the timeout and return otherwise complete the exchange
++ * and tell the scsi layer to restart the I/O.
++ */
++static void fc_fcp_rec_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
++{
++ struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
++ struct fc_els_rec_acc *recp;
++ struct fc_els_ls_rjt *rjt;
++ u32 e_stat;
++ u8 opcode;
++ u32 offset;
++ enum dma_data_direction data_dir;
++ enum fc_rctl r_ctl;
++ struct fc_rport_libfc_priv *rp;
++
++ if (IS_ERR(fp)) {
++ fc_fcp_rec_error(fsp, fp);
++ return;
++ }
++
++ if (fc_fcp_lock_pkt(fsp))
++ goto out;
++
++ fsp->recov_retry = 0;
++ opcode = fc_frame_payload_op(fp);
++ if (opcode == ELS_LS_RJT) {
++ rjt = fc_frame_payload_get(fp, sizeof(*rjt));
++ switch (rjt->er_reason) {
++ default:
++ if (fc_fcp_debug)
++ FC_DBG("device %x unexpected REC reject "
++ "reason %d expl %d\n",
++ fsp->rport->port_id, rjt->er_reason,
++ rjt->er_explan);
++ /* fall through */
++
++ case ELS_RJT_UNSUP:
++ if (fc_fcp_debug)
++ FC_DBG("device does not support REC\n");
++ rp = fsp->rport->dd_data;
++ rp->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
++ /* fall through */
++
++ case ELS_RJT_LOGIC:
++ case ELS_RJT_UNAB:
++ /*
++ * If no data transfer, the command frame got dropped
++ * so we just retry. If data was transferred, we
++ * lost the response but the target has no record,
++ * so we abort and retry.
++ */
++ if (rjt->er_explan == ELS_EXPL_OXID_RXID &&
++ fsp->xfer_len == 0) {
++ fc_fcp_retry_cmd(fsp);
++ break;
++ }
++ fc_timeout_error(fsp);
++ break;
++ }
++ } else if (opcode == ELS_LS_ACC) {
++ if (fsp->state & FC_SRB_ABORTED)
++ goto unlock_out;
++
++ data_dir = fsp->cmd->sc_data_direction;
++ recp = fc_frame_payload_get(fp, sizeof(*recp));
++ offset = ntohl(recp->reca_fc4value);
++ e_stat = ntohl(recp->reca_e_stat);
++
++ if (e_stat & ESB_ST_COMPLETE) {
++
++ /*
++ * The exchange is complete.
++ *
++ * For output, we must've lost the response.
++ * For input, all data must've been sent.
++ * We lost may have lost the response
++ * (and a confirmation was requested) and maybe
++ * some data.
++ *
++ * If all data received, send SRR
++ * asking for response. If partial data received,
++ * or gaps, SRR requests data at start of gap.
++ * Recovery via SRR relies on in-order-delivery.
++ */
++ if (data_dir == DMA_TO_DEVICE) {
++ r_ctl = FC_RCTL_DD_CMD_STATUS;
++ } else if (fsp->xfer_contig_end == offset) {
++ r_ctl = FC_RCTL_DD_CMD_STATUS;
++ } else {
++ offset = fsp->xfer_contig_end;
++ r_ctl = FC_RCTL_DD_SOL_DATA;
++ }
++ fc_fcp_srr(fsp, r_ctl, offset);
++ } else if (e_stat & ESB_ST_SEQ_INIT) {
++
++ /*
++ * The remote port has the initiative, so just
++ * keep waiting for it to complete.
++ */
++ fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
++ } else {
++
++ /*
++ * The exchange is incomplete, we have seq. initiative.
++ * Lost response with requested confirmation,
++ * lost confirmation, lost transfer ready or
++ * lost write data.
++ *
++ * For output, if not all data was received, ask
++ * for transfer ready to be repeated.
++ *
++ * If we received or sent all the data, send SRR to
++ * request response.
++ *
++ * If we lost a response, we may have lost some read
++ * data as well.
++ */
++ r_ctl = FC_RCTL_DD_SOL_DATA;
++ if (data_dir == DMA_TO_DEVICE) {
++ r_ctl = FC_RCTL_DD_CMD_STATUS;
++ if (offset < fsp->data_len)
++ r_ctl = FC_RCTL_DD_DATA_DESC;
++ } else if (offset == fsp->xfer_contig_end) {
++ r_ctl = FC_RCTL_DD_CMD_STATUS;
++ } else if (fsp->xfer_contig_end < offset) {
++ offset = fsp->xfer_contig_end;
++ }
++ fc_fcp_srr(fsp, r_ctl, offset);
++ }
++ }
++unlock_out:
++ fc_fcp_unlock_pkt(fsp);
++out:
++ fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
++ fc_frame_free(fp);
++}
++
++/*
++ * Handle error response or timeout for REC exchange.
++ */
++static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
++{
++ int error = PTR_ERR(fp);
++
++ if (fc_fcp_lock_pkt(fsp))
++ goto out;
++
++ switch (error) {
++ case -FC_EX_CLOSED:
++ fc_fcp_retry_cmd(fsp);
++ break;
++
++ default:
++ FC_DBG("REC %p fid %x error unexpected error %d\n",
++ fsp, fsp->rport->port_id, error);
++ fsp->status_code = FC_CMD_PLOGO;
++ /* fall through */
++
++ case -FC_EX_TIMEOUT:
++ /*
++ * Assume REC or LS_ACC was lost.
++ * The exchange manager will have aborted REC, so retry.
++ */
++ FC_DBG("REC fid %x error error %d retry %d/%d\n",
++ fsp->rport->port_id, error, fsp->recov_retry,
++ FC_MAX_RECOV_RETRY);
++ if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
++ fc_fcp_rec(fsp);
++ else
++ fc_timeout_error(fsp);
++ break;
++ }
++ fc_fcp_unlock_pkt(fsp);
++out:
++ fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
++}
++
++/*
++ * Time out error routine:
++ * abort's the I/O close the exchange and
++ * send completion notification to scsi layer
++ */
++static void fc_timeout_error(struct fc_fcp_pkt *fsp)
++{
++ fsp->status_code = FC_CMD_TIME_OUT;
++ fsp->cdb_status = 0;
++ fsp->io_status = 0;
++ /*
++ * if this fails then we let the scsi command timer fire and
++ * scsi-ml escalate.
++ */
++ fc_fcp_send_abort(fsp);
++}
++
++/*
++ * Sequence retransmission request.
++ * This is called after receiving status but insufficient data, or
++ * when expecting status but the request has timed out.
++ */
++static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
++{
++ struct fc_lport *lp = fsp->lp;
++ struct fc_rport *rport;
++ struct fc_rport_libfc_priv *rp;
++ struct fc_seq *sp;
++ struct fcp_srr *srr;
++ struct fc_frame *fp;
++ u8 cdb_op;
++ u16 ox_id;
++ u16 rx_id;
++
++ rport = fsp->rport;
++ rp = rport->dd_data;
++ cdb_op = fsp->cdb_cmd.fc_cdb[0];
++ lp->tt.seq_get_xids(fsp->seq_ptr, &ox_id, &rx_id);
++
++ if (!(rp->flags & FC_RP_FLAGS_RETRY) || rp->rp_state != RPORT_ST_READY)
++ goto retry; /* shouldn't happen */
++ fp = fc_frame_alloc(lp, sizeof(*srr));
++ if (!fp)
++ goto retry;
++
++ srr = fc_frame_payload_get(fp, sizeof(*srr));
++ memset(srr, 0, sizeof(*srr));
++ srr->srr_op = ELS_SRR;
++ srr->srr_ox_id = htons(ox_id);
++ srr->srr_rx_id = htons(rx_id);
++ srr->srr_r_ctl = r_ctl;
++ srr->srr_rel_off = htonl(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,
++ fsp, jiffies_to_msecs(FC_SCSI_REC_TOV),
++ rp->local_port->fid,
++ rport->port_id,
++ FC_FC_SEQ_INIT | FC_FC_END_SEQ);
++ if (!sp) {
++ fc_frame_free(fp);
++ goto retry;
++ }
++ fsp->recov_seq = sp;
++ fsp->xfer_len = offset;
++ fsp->xfer_contig_end = offset;
++ fsp->state &= ~FC_SRB_RCV_STATUS;
++ fc_fcp_pkt_hold(fsp); /* hold for outstanding SRR */
++ return;
++retry:
++ fc_fcp_retry_cmd(fsp);
++}
++
++/*
++ * Handle response from SRR.
++ */
++static void fc_fcp_srr_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
++{
++ struct fc_fcp_pkt *fsp = arg;
++ struct fc_frame_header *fh;
++ u16 ox_id;
++ u16 rx_id;
++
++ if (IS_ERR(fp)) {
++ fc_fcp_srr_error(fsp, fp);
++ return;
++ }
++
++ if (fc_fcp_lock_pkt(fsp))
++ goto out;
++
++ fh = fc_frame_header_get(fp);
++ /*
++ * BUG? fc_fcp_srr_error calls exch_done which would release
++ * the ep. But if fc_fcp_srr_error had got -FC_EX_TIMEOUT,
++ * then fc_exch_timeout would be sending an abort. The exch_done
++ * call by fc_fcp_srr_error would prevent fc_exch.c from seeing
++ * an abort response though.
++ */
++ if (fh->fh_type == FC_TYPE_BLS) {
++ fc_fcp_unlock_pkt(fsp);
++ return;
++ }
++
++ fsp->recov_seq = NULL;
++
++ fsp->lp->tt.seq_get_xids(fsp->seq_ptr, &ox_id, &rx_id);
++ switch (fc_frame_payload_op(fp)) {
++ case ELS_LS_ACC:
++ fsp->recov_retry = 0;
++ fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
++ break;
++ case ELS_LS_RJT:
++ default:
++ fc_timeout_error(fsp);
++ break;
++ }
++ fc_fcp_unlock_pkt(fsp);
++ fsp->lp->tt.exch_done(sp);
++out:
++ fc_frame_free(fp);
++ fc_fcp_pkt_release(fsp); /* drop hold for outstanding SRR */
++}
++
++static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
++{
++ if (fc_fcp_lock_pkt(fsp))
++ goto out;
++ fsp->lp->tt.exch_done(fsp->recov_seq);
++ fsp->recov_seq = NULL;
++ switch (PTR_ERR(fp)) {
++ case -FC_EX_TIMEOUT:
++ if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
++ fc_fcp_rec(fsp);
++ else
++ fc_timeout_error(fsp);
++ break;
++ case -FC_EX_CLOSED: /* e.g., link failure */
++ /* fall through */
++ default:
++ fc_fcp_retry_cmd(fsp);
++ break;
++ }
++ fc_fcp_unlock_pkt(fsp);
++out:
++ fc_fcp_pkt_release(fsp); /* drop hold for outstanding SRR */
++}
++
++static inline int fc_fcp_lport_queue_ready(struct fc_lport *lp)
++{
++ /* lock ? */
++ return (lp->state == LPORT_ST_READY) && (lp->link_status & FC_LINK_UP);
++}
++
++/**
++ * fc_queuecommand - The queuecommand function of the scsi template
++ * @cmd: struct scsi_cmnd to be executed
++ * @done: Callback function to be called when cmd is completed
++ *
++ * this is the i/o strategy routine, called by the scsi layer
++ * this routine is called with holding the host_lock.
++ */
++int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
++{
++ struct fc_lport *lp;
++ struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
++ struct fc_fcp_pkt *sp;
++ struct fc_rport_libfc_priv *rp;
++ int rval;
++ int rc = 0;
++ struct fcoe_dev_stats *stats;
++
++ lp = shost_priv(sc_cmd->device->host);
++
++ rval = fc_remote_port_chkready(rport);
++ if (rval) {
++ sc_cmd->result = rval;
++ done(sc_cmd);
++ goto out;
++ }
++
++ if (!*(struct fc_remote_port **)rport->dd_data) {
++ /*
++ * rport is transitioning from blocked/deleted to
++ * online
++ */
++ sc_cmd->result = DID_IMM_RETRY << 16;
++ done(sc_cmd);
++ goto out;
++ }
++
++ rp = rport->dd_data;
++
++ if (!fc_fcp_lport_queue_ready(lp)) {
++ rc = SCSI_MLQUEUE_HOST_BUSY;
++ goto out;
++ }
++
++ sp = fc_fcp_pkt_alloc(lp, GFP_ATOMIC);
++ if (sp == NULL) {
++ rc = SCSI_MLQUEUE_HOST_BUSY;
++ goto out;
++ }
++
++ /*
++ * build the libfc request pkt
++ */
++ sp->cmd = sc_cmd; /* save the cmd */
++ sp->lp = lp; /* save the softc ptr */
++ sp->rport = rport; /* set the remote port ptr */
++ sc_cmd->scsi_done = done;
++
++ /*
++ * set up the transfer length
++ */
++ sp->data_len = scsi_bufflen(sc_cmd);
++ sp->xfer_len = 0;
++
++ /*
++ * setup the data direction
++ */
++ stats = lp->dev_stats[smp_processor_id()];
++ if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
++ sp->req_flags = FC_SRB_READ;
++ stats->InputRequests++;
++ stats->InputMegabytes = sp->data_len;
++ } else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
++ sp->req_flags = FC_SRB_WRITE;
++ stats->OutputRequests++;
++ stats->OutputMegabytes = sp->data_len;
++ } else {
++ sp->req_flags = 0;
++ stats->ControlRequests++;
++ }
++
++ sp->tgt_flags = rp->flags;
++
++ init_timer(&sp->timer);
++ sp->timer.data = (unsigned long)sp;
++
++ /*
++ * send it to the lower layer
++ * if we get -1 return then put the request in the pending
++ * queue.
++ */
++ rval = fc_fcp_pkt_send(lp, sp);
++ if (rval != 0) {
++ sp->state = FC_SRB_FREE;
++ fc_fcp_pkt_release(sp);
++ rc = SCSI_MLQUEUE_HOST_BUSY;
++ }
++out:
++ return rc;
++}
++EXPORT_SYMBOL(fc_queuecommand);
++
++/**
++ * fc_io_compl - Handle responses for completed commands
++ * @sp: scsi packet
++ *
++ * Translates a error to a Linux SCSI error.
++ *
++ * The fcp packet lock must be held when calling.
++ */
++static void fc_io_compl(struct fc_fcp_pkt *sp)
++{
++ struct fc_fcp_internal *si;
++ struct scsi_cmnd *sc_cmd;
++ struct fc_lport *lp;
++ unsigned long flags;
++
++ sp->state |= FC_SRB_COMPL;
++ if (!(sp->state & FC_SRB_FCP_PROCESSING_TMO)) {
++ spin_unlock_bh(&sp->scsi_pkt_lock);
++ del_timer_sync(&sp->timer);
++ spin_lock_bh(&sp->scsi_pkt_lock);
++ }
++
++ lp = sp->lp;
++ si = fc_get_scsi_internal(lp);
++ spin_lock_irqsave(lp->host->host_lock, flags);
++ if (!sp->cmd) {
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++ return;
++ }
++
++ /*
++ * if a command timed out while we had to try and throttle IO
++ * and it is now getting cleaned up, then we are about to
++ * try again so clear the throttled flag incase we get more
++ * time outs.
++ */
++ if (si->throttled && sp->state & FC_SRB_NOMEM)
++ si->throttled = 0;
++
++ sc_cmd = sp->cmd;
++ sp->cmd = NULL;
++
++ if (!sc_cmd->SCp.ptr) {
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++ return;
++ }
++
++ CMD_SCSI_STATUS(sc_cmd) = sp->cdb_status;
++ switch (sp->status_code) {
++ case FC_COMPLETE:
++ if (sp->cdb_status == 0) {
++ /*
++ * good I/O status
++ */
++ sc_cmd->result = DID_OK << 16;
++ if (sp->scsi_resid)
++ CMD_RESID_LEN(sc_cmd) = sp->scsi_resid;
++ } else if (sp->cdb_status == QUEUE_FULL) {
++ struct scsi_device *tmp_sdev;
++ struct scsi_device *sdev = sc_cmd->device;
++
++ shost_for_each_device(tmp_sdev, sdev->host) {
++ if (tmp_sdev->id != sdev->id)
++ continue;
++
++ if (tmp_sdev->queue_depth > 1) {
++ scsi_track_queue_full(tmp_sdev,
++ tmp_sdev->
++ queue_depth - 1);
++ }
++ }
++ sc_cmd->result = (DID_OK << 16) | sp->cdb_status;
++ } else {
++ /*
++ * transport level I/O was ok but scsi
++ * has non zero status
++ */
++ sc_cmd->result = (DID_OK << 16) | sp->cdb_status;
++ }
++ break;
++ case FC_ERROR:
++ if (sp->io_status & (SUGGEST_RETRY << 24))
++ sc_cmd->result = DID_IMM_RETRY << 16;
++ else
++ sc_cmd->result = (DID_ERROR << 16) | sp->io_status;
++ break;
++ case FC_DATA_UNDRUN:
++ if (sp->cdb_status == 0) {
++ /*
++ * scsi status is good but transport level
++ * underrun. for read it should be an error??
++ */
++ sc_cmd->result = (DID_OK << 16) | sp->cdb_status;
++ } else {
++ /*
++ * scsi got underrun, this is an error
++ */
++ CMD_RESID_LEN(sc_cmd) = sp->scsi_resid;
++ sc_cmd->result = (DID_ERROR << 16) | sp->cdb_status;
++ }
++ break;
++ case FC_DATA_OVRRUN:
++ /*
++ * overrun is an error
++ */
++ sc_cmd->result = (DID_ERROR << 16) | sp->cdb_status;
++ break;
++ case FC_CMD_ABORTED:
++ sc_cmd->result = (DID_ABORT << 16) | sp->io_status;
++ break;
++ case FC_CMD_TIME_OUT:
++ sc_cmd->result = (DID_BUS_BUSY << 16) | sp->io_status;
++ break;
++ case FC_CMD_RESET:
++ sc_cmd->result = (DID_RESET << 16);
++ break;
++ case FC_HRD_ERROR:
++ sc_cmd->result = (DID_NO_CONNECT << 16);
++ break;
++ default:
++ sc_cmd->result = (DID_ERROR << 16);
++ break;
++ }
++
++ list_del(&sp->list);
++ sc_cmd->SCp.ptr = NULL;
++ sc_cmd->scsi_done(sc_cmd);
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++
++ /* release ref from initial allocation in queue command */
++ fc_fcp_pkt_release(sp);
++}
++
++/**
++ * fc_eh_abort - Abort a command...from scsi host template
++ * @sc_cmd: scsi command to abort
++ *
++ * send ABTS to the target device and wait for the response
++ * sc_cmd is the pointer to the command to be aborted.
++ */
++int fc_eh_abort(struct scsi_cmnd *sc_cmd)
++{
++ struct fc_fcp_pkt *sp;
++ struct fc_lport *lp;
++ int rc = FAILED;
++ unsigned long flags;
++
++ lp = shost_priv(sc_cmd->device->host);
++ if (lp->state != LPORT_ST_READY)
++ return rc;
++ else if (!(lp->link_status & FC_LINK_UP))
++ return rc;
++
++ spin_lock_irqsave(lp->host->host_lock, flags);
++ sp = CMD_SP(sc_cmd);
++ if (!sp) {
++ /* command completed while scsi eh was setting up */
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++ return SUCCESS;
++ }
++ /* grab a ref so the sp and sc_cmd cannot be relased from under us */
++ fc_fcp_pkt_hold(sp);
++ spin_unlock_irqrestore(lp->host->host_lock, flags);
++
++ if (fc_fcp_lock_pkt(sp)) {
++ /* completed while we were waiting for timer to be deleted */
++ rc = SUCCESS;
++ goto release_pkt;
++ }
++
++ rc = fc_fcp_pkt_abort(lp, sp);
++ fc_fcp_unlock_pkt(sp);
++
++release_pkt:
++ fc_fcp_pkt_release(sp);
++ return rc;
++}
++EXPORT_SYMBOL(fc_eh_abort);
++
++/**
++ * fc_eh_device_reset: Reset a single LUN
++ * @sc_cmd: scsi command
++ *
++ * Set from scsi host template to send tm cmd to the target and wait for the
++ * response.
++ */
++int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
++{
++ struct fc_lport *lp;
++ struct fc_fcp_pkt *sp;
++ struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
++ int rc = FAILED;
++ struct fc_rport_libfc_priv *rp;
++ int rval;
++
++ rval = fc_remote_port_chkready(rport);
++ if (rval)
++ goto out;
++
++ rp = rport->dd_data;
++ lp = shost_priv(sc_cmd->device->host);
++
++ if (lp->state != LPORT_ST_READY)
++ return rc;
++
++ sp = fc_fcp_pkt_alloc(lp, GFP_NOIO);
++ if (sp == NULL) {
++ FC_DBG("could not allocate scsi_pkt\n");
++ sc_cmd->result = DID_NO_CONNECT << 16;
++ goto out;
++ }
++
++ /*
++ * Build the libfc request pkt. Do not set the scsi cmnd, because
++ * the sc passed in is not setup for execution like when sent
++ * through the queuecommand callout.
++ */
++ sp->lp = lp; /* save the softc ptr */
++ sp->rport = rport; /* set the remote port ptr */
++
++ /*
++ * flush outstanding commands
++ */
++ rc = fc_lun_reset(lp, sp, scmd_id(sc_cmd), sc_cmd->device->lun);
++ sp->state = FC_SRB_FREE;
++ fc_fcp_pkt_release(sp);
++
++out:
++ return rc;
++}
++EXPORT_SYMBOL(fc_eh_device_reset);
++
++/**
++ * fc_eh_host_reset - The reset function will reset the ports on the host.
++ * @sc_cmd: scsi command
++ */
++int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
++{
++ struct Scsi_Host *shost = sc_cmd->device->host;
++ struct fc_lport *lp = shost_priv(shost);
++ unsigned long wait_tmo;
++
++ lp->tt.lport_reset(lp);
++ wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
++ while (!fc_fcp_lport_queue_ready(lp) && time_before(jiffies, wait_tmo))
++ msleep(1000);
++
++ if (fc_fcp_lport_queue_ready(lp)) {
++ shost_printk(KERN_INFO, shost, "Host reset succeeded.\n");
++ return SUCCESS;
++ } else {
++ shost_printk(KERN_INFO, shost, "Host reset succeeded failed."
++ "lport not ready.\n");
++ return FAILED;
++ }
++}
++EXPORT_SYMBOL(fc_eh_host_reset);
++
++/**
++ * fc_slave_alloc - configure queue depth
++ * @sdev: scsi device
++ *
++ * Configures queue depth based on host's cmd_per_len. If not set
++ * then we use the libfc default.
++ */
++int fc_slave_alloc(struct scsi_device *sdev)
++{
++ struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
++ int queue_depth;
++
++ if (!rport || fc_remote_port_chkready(rport))
++ return -ENXIO;
++
++ if (sdev->tagged_supported) {
++ if (sdev->host->hostt->cmd_per_lun)
++ queue_depth = sdev->host->hostt->cmd_per_lun;
++ else
++ queue_depth = FC_FCP_DFLT_QUEUE_DEPTH;
++ scsi_activate_tcq(sdev, queue_depth);
++ }
++ return 0;
++}
++EXPORT_SYMBOL(fc_slave_alloc);
++
++int fc_change_queue_depth(struct scsi_device *sdev, int qdepth)
++{
++ scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
++ return sdev->queue_depth;
++}
++EXPORT_SYMBOL(fc_change_queue_depth);
++
++int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
++{
++ if (sdev->tagged_supported) {
++ scsi_set_tag_type(sdev, tag_type);
++ if (tag_type)
++ scsi_activate_tcq(sdev, sdev->queue_depth);
++ else
++ scsi_deactivate_tcq(sdev, sdev->queue_depth);
++ } else
++ tag_type = 0;
++
++ return tag_type;
++}
++EXPORT_SYMBOL(fc_change_queue_type);
++
++void fc_fcp_destroy(struct fc_lport *lp)
++{
++ struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
++
++ if (!list_empty(&si->scsi_pkt_queue))
++ printk(KERN_ERR "Leaked scsi packets.\n");
++
++ mempool_destroy(si->scsi_pkt_pool);
++ kfree(si);
++ lp->scsi_priv = NULL;
++}
++EXPORT_SYMBOL(fc_fcp_destroy);
++
++int fc_fcp_init(struct fc_lport *lp)
++{
++ int rc;
++ struct fc_fcp_internal *si;
++
++ if (!lp->tt.scsi_cleanup)
++ lp->tt.scsi_cleanup = fc_fcp_cleanup;
++
++ if (!lp->tt.scsi_abort_io)
++ lp->tt.scsi_abort_io = fc_fcp_abort_io;
++
++ si = kzalloc(sizeof(struct fc_fcp_internal), GFP_KERNEL);
++ if (!si)
++ return -ENOMEM;
++ lp->scsi_priv = si;
++ INIT_LIST_HEAD(&si->scsi_pkt_queue);
++
++ si->scsi_pkt_pool = mempool_create_slab_pool(2, scsi_pkt_cachep);
++ if (!si->scsi_pkt_pool) {
++ rc = -ENOMEM;
++ goto free_internal;
++ }
++ return 0;
++
++free_internal:
++ kfree(si);
++ return rc;
++}
++EXPORT_SYMBOL(fc_fcp_init);
++
++static int __init libfc_init(void)
++{
++ int rc;
++
++ scsi_pkt_cachep = kmem_cache_create("libfc_fcp_pkt",
++ sizeof(struct fc_fcp_pkt),
++ 0, SLAB_HWCACHE_ALIGN, NULL);
++ if (scsi_pkt_cachep == NULL) {
++ FC_DBG("Unable to allocate SRB cache...module load failed!");
++ return -ENOMEM;
++ }
++
++ rc = fc_setup_exch_mgr();
++ if (rc)
++ kmem_cache_destroy(scsi_pkt_cachep);
++ return rc;
++}
++
++static void __exit libfc_exit(void)
++{
++ kmem_cache_destroy(scsi_pkt_cachep);
++ fc_destroy_exch_mgr();
++}
++
++module_init(libfc_init);
++module_exit(libfc_exit);
+diff --git a/drivers/scsi/libfc/fc_frame.c b/drivers/scsi/libfc/fc_frame.c
+new file mode 100644
+index 0000000..7ba241e
+--- /dev/null
++++ b/drivers/scsi/libfc/fc_frame.c
+@@ -0,0 +1,88 @@
++/*
++ * 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
++ */
++
++/*
++ * Frame allocation.
++ */
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/skbuff.h>
++#include <linux/crc32.h>
++
++#include <scsi/libfc/fc_frame.h>
++
++/*
++ * Check the CRC in a frame.
++ */
++u32 fc_frame_crc_check(struct fc_frame *fp)
++{
++ u32 crc;
++ u32 error;
++ const u8 *bp;
++ unsigned int len;
++
++ WARN_ON(!fc_frame_is_linear(fp));
++ fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
++ len = (fr_len(fp) + 3) & ~3; /* round up length to include fill */
++ bp = (const u8 *) fr_hdr(fp);
++ crc = ~crc32(~0, bp, len);
++ error = crc ^ *(u32 *) (bp + len);
++ return error;
++}
++EXPORT_SYMBOL(fc_frame_crc_check);
++
++/*
++ * Allocate a frame intended to be sent via fcoe_xmit.
++ * Get an sk_buff for the frame and set the length.
++ */
++struct fc_frame *__fc_frame_alloc(size_t len)
++{
++ struct fc_frame *fp;
++ struct sk_buff *skb;
++
++ WARN_ON((len % sizeof(u32)) != 0);
++ len += sizeof(struct fc_frame_header);
++ skb = dev_alloc_skb(len + FC_FRAME_HEADROOM + FC_FRAME_TAILROOM);
++ if (!skb)
++ return NULL;
++ fp = (struct fc_frame *) skb;
++ fc_frame_init(fp);
++ skb_reserve(skb, FC_FRAME_HEADROOM);
++ skb_put(skb, len);
++ return fp;
++}
++EXPORT_SYMBOL(__fc_frame_alloc);
++
++
++struct fc_frame *fc_frame_alloc_fill(struct fc_lport *lp, size_t payload_len)
++{
++ struct fc_frame *fp;
++ size_t fill;
++
++ fill = payload_len % 4;
++ if (fill != 0)
++ fill = 4 - fill;
++ fp = __fc_frame_alloc(payload_len + fill);
++ if (fp) {
++ memset((char *) fr_hdr(fp) + payload_len, 0, fill);
++ /* trim is OK, we just allocated it so there are no fragments */
++ skb_trim(fp_skb(fp), payload_len);
++ }
++ return fp;
++}
+diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
+new file mode 100644
+index 0000000..b390a32
+--- /dev/null
++++ b/drivers/scsi/libfc/fc_lport.c
+@@ -0,0 +1,926 @@
++/*
++ * 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
++ */
++
++/*
++ * Logical interface support.
++ */
++
++#include <linux/timer.h>
++#include <asm/unaligned.h>
++
++#include <scsi/fc/fc_gs.h>
++
++#include <scsi/libfc/libfc.h>
++
++/* Fabric IDs to use for point-to-point mode, chosen on whims. */
++#define FC_LOCAL_PTP_FID_LO 0x010101
++#define FC_LOCAL_PTP_FID_HI 0x010102
++
++#define DNS_DELAY 3 /* Discovery delay after RSCN (in seconds)*/
++
++static int fc_lport_debug;
++
++static void fc_lport_enter_flogi(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_SCR] = "SCR",
++ [LPORT_ST_READY] = "ready",
++ [LPORT_ST_DNS_STOP] = "stop",
++ [LPORT_ST_LOGO] = "LOGO",
++ [LPORT_ST_RESET] = "reset",
++};
++
++static int fc_frame_drop(struct fc_lport *lp, struct fc_frame *fp)
++{
++ fc_frame_free(fp);
++ return 0;
++}
++
++static const char *fc_lport_state(struct fc_lport *lp)
++{
++ const char *cp;
++
++ cp = fc_lport_state_names[lp->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)
++{
++ 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);
++ }
++}
++
++static void fc_lport_ptp_clear(struct fc_lport *lp)
++{
++ if (lp->ptp_rp) {
++ fc_remote_port_delete(lp->ptp_rp);
++ lp->ptp_rp = NULL;
++ }
++}
++
++/*
++ * Routines to support struct fc_function_template
++ */
++void fc_get_host_port_state(struct Scsi_Host *shost)
++{
++ struct fc_lport *lp = shost_priv(shost);
++
++ if ((lp->link_status & FC_LINK_UP) == FC_LINK_UP)
++ fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
++ else
++ fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
++}
++EXPORT_SYMBOL(fc_get_host_port_state);
++
++/*
++ * Fill in FLOGI command for request.
++ */
++static void
++fc_lport_flogi_fill(struct fc_lport *lp,
++ 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);
++ 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);
++ 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);
++
++ cp->cp_rdfs = htons((u16) lp->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)
++{
++ __be32 *mp;
++
++ mp = &lp->fcts.ff_type_map[type / FC_NS_BPW];
++ *mp = htonl(ntohl(*mp) | 1UL << (type % FC_NS_BPW));
++}
++
++/*
++ * Handle received RLIR - registered link incident report.
++ */
++static void fc_lport_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
++ struct fc_lport *lp)
++{
++ lp->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
++ fc_frame_free(fp);
++}
++
++/*
++ * Handle received ECHO.
++ */
++static void fc_lport_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
++ struct fc_lport *lp)
++{
++ struct fc_frame *fp;
++ unsigned int len;
++ void *pp;
++ void *dp;
++ u32 f_ctl;
++
++ 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);
++ 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);
++ 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);
++ }
++ fc_frame_free(in_fp);
++}
++
++/*
++ * Handle received RNID.
++ */
++static void fc_lport_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
++ struct fc_lport *lp)
++{
++ struct fc_frame *fp;
++ struct fc_els_rnid *req;
++ struct {
++ struct fc_els_rnid_resp rnid;
++ struct fc_els_rnid_cid cid;
++ struct fc_els_rnid_gen gen;
++ } *rp;
++ struct fc_seq_els_data rjt_data;
++ u8 fmt;
++ size_t len;
++ u32 f_ctl;
++
++ 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);
++ } else {
++ fmt = req->rnid_fmt;
++ len = sizeof(*rp);
++ if (fmt != ELS_RNIDF_GEN ||
++ ntohl(lp->rnid_gen.rnid_atype) == 0) {
++ fmt = ELS_RNIDF_NONE; /* nothing to provide */
++ len -= sizeof(rp->gen);
++ }
++ fp = fc_frame_alloc(lp, 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);
++ if (fmt == ELS_RNIDF_GEN) {
++ rp->rnid.rnid_sid_len = sizeof(rp->gen);
++ memcpy(&rp->gen, &lp->rnid_gen,
++ sizeof(rp->gen));
++ }
++ sp = lp->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);
++ }
++ }
++ fc_frame_free(in_fp);
++}
++
++/*
++ * Handle received fabric logout request.
++ */
++static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp,
++ struct fc_lport *lp)
++{
++ lp->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
++ fc_lport_enter_reset(lp);
++ fc_frame_free(fp);
++}
++
++/*
++ * Receive request frame
++ */
++
++int fc_fabric_login(struct fc_lport *lp)
++{
++ int rc = -1;
++
++ if (lp->state == LPORT_ST_NONE) {
++ fc_lport_lock(lp);
++ fc_lport_enter_reset(lp);
++ fc_lport_unlock(lp);
++ rc = 0;
++ }
++ return rc;
++}
++EXPORT_SYMBOL(fc_fabric_login);
++
++/**
++ * fc_linkup - link up notification
++ * @dev: Pointer to fc_lport .
++ **/
++void fc_linkup(struct fc_lport *lp)
++{
++ 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);
++ }
++}
++EXPORT_SYMBOL(fc_linkup);
++
++/**
++ * fc_linkdown - link down notification
++ * @dev: Pointer to fc_lport .
++ **/
++void fc_linkdown(struct fc_lport *lp)
++{
++ 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);
++ }
++}
++EXPORT_SYMBOL(fc_linkdown);
++
++void fc_pause(struct fc_lport *lp)
++{
++ lp->link_status |= FC_PAUSE;
++}
++EXPORT_SYMBOL(fc_pause);
++
++void fc_unpause(struct fc_lport *lp)
++{
++ lp->link_status &= ~(FC_PAUSE);
++}
++EXPORT_SYMBOL(fc_unpause);
++
++int fc_fabric_logoff(struct fc_lport *lp)
++{
++ 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);
++
++ return 0;
++}
++EXPORT_SYMBOL(fc_fabric_logoff);
++
++/**
++ * fc_lport_destroy - unregister a fc_lport
++ * @lp: fc_lport pointer to unregister
++ *
++ * Return value:
++ * None
++ * Note:
++ * exit routine for fc_lport instance
++ * clean-up all the allocated memory
++ * and free up other system resources.
++ *
++ **/
++int fc_lport_destroy(struct fc_lport *lp)
++{
++ 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);
++
++ return 0;
++}
++EXPORT_SYMBOL(fc_lport_destroy);
++
++int fc_set_mfs(struct fc_lport *lp, u32 mfs)
++{
++ unsigned int old_mfs;
++ int rc = -1;
++
++ old_mfs = lp->mfs;
++
++ if (mfs >= FC_MIN_MAX_FRAME) {
++ mfs &= ~3;
++ WARN_ON((size_t) mfs < FC_MIN_MAX_FRAME);
++ if (mfs > FC_MAX_FRAME)
++ mfs = FC_MAX_FRAME;
++ mfs -= sizeof(struct fc_frame_header);
++ lp->mfs = mfs;
++ rc = 0;
++ }
++
++ if (!rc && mfs < old_mfs) {
++ lp->ns_disc_done = 0;
++ fc_lport_enter_reset(lp);
++ }
++ return rc;
++}
++EXPORT_SYMBOL(fc_set_mfs);
++
++/*
++ * re-enter state for retrying a request after a timeout or alloc failure.
++ */
++static void fc_lport_enter_retry(struct fc_lport *lp)
++{
++ 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;
++ }
++}
++
++/*
++ * 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;
++ }
++}
++
++/*
++ * 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);
++ }
++}
++
++/*
++ * 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.
++ */
++static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
++ struct fc_frame *rx_fp,
++ struct fc_lport *lp)
++{
++ struct fc_frame *fp;
++ struct fc_frame_header *fh;
++ struct fc_seq *sp;
++ struct fc_els_flogi *flp;
++ struct fc_els_flogi *new_flp;
++ u64 remote_wwpn;
++ u32 remote_fid;
++ u32 local_fid;
++ u32 f_ctl;
++
++ 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) {
++ 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?
++ * The originator might expect our S_ID to be 0xfffffe.
++ * 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) {
++ 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));
++ if (fp) {
++ sp = lp->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);
++ new_flp->fl_cmd = (u8) ELS_LS_ACC;
++
++ /*
++ * Send the response. If this fails, the originator should
++ * repeat the sequence.
++ */
++ 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);
++
++ } else {
++ fc_lport_retry(lp);
++ }
++ fc_lport_ptp_setup(lp, remote_fid, remote_wwpn,
++ get_unaligned_be64(&flp->fl_wwnn));
++ fc_lport_unlock(lp);
++ if (lp->tt.disc_start(lp))
++ 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)
++{
++ struct fc_frame_header *fh = fc_frame_header_get(fp);
++ void (*recv) (struct fc_seq *, struct fc_frame *, struct fc_lport *);
++ struct fc_rport *rport;
++ u32 s_id;
++ u32 d_id;
++ struct fc_seq_els_data rjt_data;
++
++ /*
++ * Handle special ELS cases like FLOGI, LOGO, and
++ * RSCN here. These don't require a session.
++ * Even if we had a session, it might not be ready.
++ */
++ if (fh->fh_type == FC_TYPE_ELS && fh->fh_r_ctl == FC_RCTL_ELS_REQ) {
++ /*
++ * Check opcode.
++ */
++ recv = NULL;
++ switch (fc_frame_payload_op(fp)) {
++ case ELS_FLOGI:
++ recv = fc_lport_recv_flogi_req;
++ break;
++ case ELS_LOGO:
++ fh = fc_frame_header_get(fp);
++ if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI)
++ recv = fc_lport_recv_logo_req;
++ break;
++ case ELS_RSCN:
++ recv = lp->tt.disc_recv_req;
++ break;
++ case ELS_ECHO:
++ recv = fc_lport_echo_req;
++ break;
++ case ELS_RLIR:
++ recv = fc_lport_rlir_req;
++ break;
++ case ELS_RNID:
++ recv = fc_lport_rnid_req;
++ break;
++ }
++
++ if (recv)
++ recv(sp, fp, lp);
++ else {
++ /*
++ * Find session.
++ * If this is a new incoming PLOGI, we won't find it.
++ */
++ s_id = ntoh24(fh->fh_s_id);
++ d_id = ntoh24(fh->fh_d_id);
++
++ rport = lp->tt.rport_lookup(lp, s_id);
++ if (rport) {
++ lp->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);
++ fc_frame_free(fp);
++ }
++ }
++ } else {
++ FC_DBG("dropping invalid frame (eof %x)\n", fr_eof(fp));
++ fc_frame_free(fp);
++ }
++
++ /*
++ * 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);
++}
++
++/*
++ * 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.
++ */
++int fc_lport_enter_reset(struct fc_lport *lp)
++{
++ if (fc_lport_debug)
++ FC_DBG("Processing RESET state\n");
++
++ if (lp->dns_rp) {
++ fc_remote_port_delete(lp->dns_rp);
++ lp->dns_rp = NULL;
++ }
++ fc_lport_ptp_clear(lp);
++
++ /*
++ * 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;
++}
++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).
++ */
++static void fc_lport_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_lport_enter_retry(lp);
++ } else {
++ fc_lport_enter_reject(lp);
++
++ }
++ }
++ 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);
++}
++
++static void fc_lport_timeout(unsigned long lp_arg)
++{
++ struct fc_lport *lp = (struct fc_lport *)lp_arg;
++
++ fc_lport_lock(lp);
++ fc_lport_enter_retry(lp);
++ fc_lport_unlock(lp);
++}
++
++static void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
++ void *lp_arg)
++{
++ struct fc_lport *lp = lp_arg;
++
++ 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);
++ }
++}
++
++/* Logout of the FC fabric */
++static void fc_lport_enter_logo(struct fc_lport *lp)
++{
++ struct fc_frame *fp;
++ struct fc_els_logo *logo;
++
++ if (fc_lport_debug)
++ FC_DBG("Processing LOGO state\n");
++
++ fc_lport_state_enter(lp, 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;
++ }
++
++ fp = fc_frame_alloc(lp, sizeof(*logo));
++ if (!fp) {
++ FC_DBG("failed to allocate frame\n");
++ 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);
++
++ 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;
++}
++
++/*
++ * Handle incoming ELS FLOGI response.
++ * Save parameters of remote switch. Finish exchange.
++ */
++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_frame_header *fh;
++ struct fc_els_flogi *flp;
++ u32 did;
++ u16 csp_flags;
++ unsigned int r_a_tov;
++ unsigned int e_d_tov;
++ u16 mfs;
++
++ if (IS_ERR(fp)) {
++ fc_lport_error(lp, fp);
++ return;
++ }
++
++ 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);
++ 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;
++ 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),
++ 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);
++ }
++ }
++ 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");
++ }
++ }
++ } else {
++ FC_DBG("bad FLOGI response\n");
++ }
++ fc_frame_free(fp);
++}
++
++/*
++ * Send ELS (extended link service) FLOGI request to peer.
++ */
++static void fc_lport_flogi_send(struct fc_lport *lp)
++{
++ struct fc_frame *fp;
++ struct fc_els_flogi *flp;
++
++ fp = fc_frame_alloc(lp, sizeof(*flp));
++ if (!fp)
++ return fc_lport_retry(lp);
++
++ flp = fc_frame_payload_get(fp, sizeof(*flp));
++ fc_lport_flogi_fill(lp, 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);
++
++}
++
++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)
++{
++ setup_timer(&lp->state_timer, fc_lport_timeout, (unsigned long)lp);
++ spin_lock_init(&lp->state_lock);
++
++ fc_lport_lock(lp);
++ fc_lport_state_enter(lp, LPORT_ST_NONE);
++ fc_lport_unlock(lp);
++
++ lp->ns_disc_delay = DNS_DELAY;
++
++ fc_lport_add_fc4_type(lp, FC_TYPE_FCP);
++ fc_lport_add_fc4_type(lp, FC_TYPE_CT);
++
++ return 0;
++}
++EXPORT_SYMBOL(fc_lport_config);
++
++int fc_lport_init(struct fc_lport *lp)
++{
++ 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;
++
++ return 0;
++}
++EXPORT_SYMBOL(fc_lport_init);
+diff --git a/drivers/scsi/libfc/fc_ns.c b/drivers/scsi/libfc/fc_ns.c
+new file mode 100644
+index 0000000..5c9272c
+--- /dev/null
++++ b/drivers/scsi/libfc/fc_ns.c
+@@ -0,0 +1,1283 @@
++/*
++ * 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
+new file mode 100644
+index 0000000..6d0c970
+--- /dev/null
++++ b/drivers/scsi/libfc/fc_rport.c
+@@ -0,0 +1,1301 @@
++/*
++ * 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
++ */
++
++/*
++ * Remote Port support.
++ *
++ * A remote port structure contains information about an N port to which we
++ * will create sessions.
++ */
++
++#include <linux/kernel.h>
++#include <linux/spinlock.h>
++#include <linux/interrupt.h>
++#include <linux/rcupdate.h>
++#include <linux/timer.h>
++#include <linux/workqueue.h>
++#include <asm/unaligned.h>
++
++#include <scsi/libfc/libfc.h>
++
++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_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 *,
++ struct fc_seq *, struct fc_frame *);
++static void fc_rport_recv_prlo_req(struct fc_rport *,
++ struct fc_seq *, struct fc_frame *);
++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 struct fc_rport *fc_remote_port_create(struct fc_lport *,
++ struct fc_rport_identifiers *);
++
++/**
++ * fc_rport_lookup - lookup a remote port by port_id
++ * @lp: Fibre Channel host port instance
++ * @fid: remote port port_id to match
++ */
++struct fc_rport *fc_rport_lookup(const struct fc_lport *lp, u32 fid)
++{
++ struct Scsi_Host *shost = lp->host;
++ struct fc_rport *rport, *found;
++ unsigned long flags;
++
++ found = NULL;
++ spin_lock_irqsave(shost->host_lock, flags);
++ list_for_each_entry(rport, &fc_host_rports(shost), peers)
++ if (rport->port_id == fid &&
++ rport->port_state == FC_PORTSTATE_ONLINE) {
++ found = rport;
++ get_device(&found->dev);
++ break;
++ }
++ spin_unlock_irqrestore(shost->host_lock, flags);
++ return found;
++}
++
++/**
++ * 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)
++ */
++static struct fc_rport *fc_remote_port_create(struct fc_lport *lp,
++ struct fc_rport_identifiers *ids)
++{
++ 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);
++}
++
++/**
++ * fc_plogi_get_maxframe - Get max payload from the common service parameters
++ * @flp: FLOGI payload structure
++ * @maxval: upper limit, may be less than what is in the service parameters
++ */
++static unsigned int
++fc_plogi_get_maxframe(struct fc_els_flogi *flp, unsigned int maxval)
++{
++ unsigned int mfs;
++
++ /*
++ * Get max payload from the common service parameters and the
++ * class 3 receive data field size.
++ */
++ mfs = ntohs(flp->fl_csp.sp_bb_data) & FC_SP_BB_DATA_MASK;
++ if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
++ maxval = mfs;
++ mfs = ntohs(flp->fl_cssp[3 - 1].cp_rdfs);
++ if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
++ maxval = mfs;
++ return maxval;
++}
++
++/**
++ * fc_lport_plogi_fill - Fill in PLOGI command for request
++ * @lp: 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,
++ struct fc_els_flogi *plogi, unsigned int op)
++{
++ struct fc_els_csp *sp;
++ struct fc_els_cssp *cp;
++
++ 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);
++
++ 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);
++ 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);
++
++ cp->cp_rdfs = htons((u16) lp->mfs);
++ cp->cp_con_seq = htons(255);
++ cp->cp_open_seq = 1;
++ }
++}
++
++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;
++}
++
++/**
++ * fc_rport_login - Start the remote port login state machine
++ * @rport: Fibre Channel remote port
++ */
++int fc_rport_login(struct fc_rport *rport)
++{
++ struct fc_rport_libfc_priv *rp = rport->dd_data;
++ struct fc_lport *lp = rp->local_port;
++
++ 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);
++
++ return 0;
++}
++
++/*
++ * Stop the session - log it off.
++ */
++int fc_rport_logout(struct fc_rport *rport)
++{
++ struct fc_rport_libfc_priv *rp = rport->dd_data;
++ struct fc_lport *lp = rp->local_port;
++
++ 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);
++ }
++
++ fc_remote_port_delete(rport);
++ }
++ break;
++ }
++
++ 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.
++ */
++void fc_rport_reset(struct fc_rport *rport)
++{
++ struct fc_rport_libfc_priv *rp = rport->dd_data;
++ struct fc_lport *lp;
++
++ if (fc_rp_debug)
++ FC_DBG("sess to %6x reset\n", rport->port_id);
++ fc_rport_lock(rport);
++
++ lp = rp->local_port;
++ 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);
++ }
++}
++
++/*
++ * Reset all sessions for a local port session list.
++ */
++void fc_rport_reset_list(struct fc_lport *lp)
++{
++ struct Scsi_Host *shost = lp->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);
++ }
++ spin_unlock_irqrestore(shost->host_lock, flags);
++}
++
++static void fc_rport_enter_start(struct fc_rport *rport)
++{
++ struct fc_rport_libfc_priv *rp = rport->dd_data;
++ struct fc_lport *lp = rp->local_port;
++
++ /*
++ * 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);
++
++ if (rport == lp->dns_rp || fc_lport_test_ready(lp))
++ fc_rport_enter_plogi(rport);
++}
++
++/*
++ * 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;
++}
++
++/*
++ * Timeout handler for retrying after allocation failures or exchange timeout.
++ */
++static void fc_rport_timeout(struct work_struct *work)
++{
++ struct fc_rport_libfc_priv *rp =
++ container_of(work, struct fc_rport_libfc_priv, retry_work.work);
++ struct fc_rport *rport = (((void *)rp) - sizeof(struct fc_rport));
++
++ switch (rp->rp_state) {
++ case RPORT_ST_PLOGI:
++ fc_rport_enter_plogi(rport);
++ break;
++ case RPORT_ST_PRLI:
++ fc_rport_enter_prli(rport);
++ break;
++ case RPORT_ST_RTV:
++ fc_rport_enter_rtv(rport);
++ break;
++ case RPORT_ST_LOGO:
++ 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);
++ }
++}
++
++/*
++ * Handle error from a sequence issued by the rport state machine.
++ */
++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);
++ if (fc_rp_debug)
++ FC_DBG("state %d error %ld retries %d\n",
++ rp->rp_state, PTR_ERR(fp), rp->retries);
++
++ if (PTR_ERR(fp) == -FC_EX_TIMEOUT &&
++ rp->retries++ >= rp->local_port->max_retry_count) {
++ get_device(&rport->dev);
++ schedule_delayed_work(&rp->retry_work, 0);
++ } else
++ fc_rport_reject(rport);
++
++ fc_rport_unlock(rport);
++}
++
++/**
++ * fc_rport_plpogi_recv_resp - Handle incoming ELS PLOGI response
++ * @sp: current sequence in the PLOGI exchange
++ * @fp: response frame
++ * @rp_arg: Fibre Channel remote port
++ */
++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_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);
++
++ 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 {
++ fc_rport_error(rport, fp);
++ }
++}
++
++/**
++ * fc_rport_enter_plogi - Send Port Login (PLOGI) request to peer
++ * @rport: Fibre Channel remote port to send PLOGI to
++ */
++static void fc_rport_enter_plogi(struct fc_rport *rport)
++{
++ 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;
++ 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);
++ 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_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);
++}
++
++/**
++ * fc_rport_prli_resp - Process Login (PRLI) response handler
++ * @sp: current sequence in the PRLI exchange
++ * @fp: response frame
++ * @rp_arg: Fibre Channel remote port
++ */
++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 {
++ struct fc_els_prli prli;
++ struct fc_els_spp spp;
++ } *pp;
++ u32 roles = FC_RPORT_ROLE_UNKNOWN;
++ u32 fcp_parm = 0;
++ u8 op;
++
++ if (IS_ERR(fp)) {
++ fc_rport_error(rport, fp);
++ return;
++ }
++
++ 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;
++ }
++
++ 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_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_frame_free(fp);
++}
++
++/**
++ * fc_rport_logo_resp - Logout (LOGO) response handler
++ * @sp: current sequence in the LOGO exchange
++ * @fp: response frame
++ * @rp_arg: Fibre Channel remote port
++ */
++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;
++ u8 op;
++
++ if (IS_ERR(fp)) {
++ fc_rport_error(rport, fp);
++ return;
++ }
++
++ 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_frame_free(fp);
++}
++
++/**
++ * fc_rport_enter_prli - Send Process Login (PRLI) request to peer
++ * @rport: Fibre Channel remote port to send PRLI to
++ */
++static void fc_rport_enter_prli(struct fc_rport *rport)
++{
++ 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;
++
++ 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);
++ }
++ 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);
++ 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);
++}
++
++/**
++ * fc_rport_els_rtv_resp - Request Timeout Value response handler
++ * @sp: current sequence in the RTV exchange
++ * @fp: response frame
++ * @rp_arg: Fibre Channel remote port
++ *
++ * Many targets don't seem to support this.
++ */
++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;
++ u8 op;
++
++ if (IS_ERR(fp)) {
++ fc_rport_error(rport, fp);
++ return;
++ }
++
++ fc_rport_lock(rport);
++ op = fc_frame_payload_op(fp);
++ if (op == ELS_LS_ACC) {
++ struct fc_els_rtv_acc *rtv;
++ u32 toq;
++ u32 tov;
++
++ rtv = fc_frame_payload_get(fp, sizeof(*rtv));
++ if (rtv) {
++ toq = ntohl(rtv->rtv_toq);
++ tov = ntohl(rtv->rtv_r_a_tov);
++ if (tov == 0)
++ tov = 1;
++ rp->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;
++ }
++ }
++ fc_rport_state_enter(rport, RPORT_ST_READY);
++ 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
++ */
++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;
++
++ 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);
++ 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);
++}
++
++/**
++ * fc_rport_enter_logo - Send Logout (LOGO) request to peer
++ * @rport: Fibre Channel remote port to send LOGO to
++ */
++static void fc_rport_enter_logo(struct fc_rport *rport)
++{
++ struct fc_frame *fp;
++ struct fc_els_logo *logo;
++ struct fc_lport *lp;
++ struct fc_rport_libfc_priv *rp = rport->dd_data;
++
++ 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);
++ 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);
++
++ 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);
++}
++
++/*
++ * 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.
++ */
++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_frame_header *fh;
++ struct fc_lport *lp = rp->local_port;
++ struct fc_seq_els_data els_data;
++ u8 op;
++
++ els_data.fp = NULL;
++ els_data.explan = ELS_EXPL_NONE;
++ els_data.reason = ELS_RJT_NONE;
++
++ fh = fc_frame_header_get(fp);
++
++ if (fh->fh_r_ctl == FC_RCTL_ELS_REQ && fh->fh_type == FC_TYPE_ELS) {
++ op = fc_frame_payload_op(fp);
++ switch (op) {
++ case ELS_PLOGI:
++ fc_rport_recv_plogi_req(rport, sp, fp);
++ break;
++ case ELS_PRLI:
++ fc_rport_recv_prli_req(rport, sp, fp);
++ break;
++ case ELS_PRLO:
++ fc_rport_recv_prlo_req(rport, sp, fp);
++ break;
++ case ELS_LOGO:
++ fc_rport_recv_logo_req(rport, sp, fp);
++ break;
++ case ELS_RRQ:
++ els_data.fp = fp;
++ lp->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);
++ break;
++ default:
++ els_data.reason = ELS_RJT_UNSUP;
++ lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
++ fc_frame_free(fp);
++ break;
++ }
++ } else {
++ fc_frame_free(fp);
++ }
++}
++
++/**
++ * fc_rport_recv_plogi_req - Handle incoming Port Login (PLOGI) request
++ * @rport: Fibre Channel remote port that initiated PLOGI
++ * @sp: current sequence in the PLOGI exchange
++ * @fp: PLOGI request frame
++ */
++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_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;
++ u64 wwpn;
++ u64 wwnn;
++ enum fc_els_rjt_reason reject = 0;
++ u32 f_ctl;
++
++ rjt_data.fp = NULL;
++ fh = fc_frame_header_get(fp);
++ sid = ntoh24(fh->fh_s_id);
++ pl = fc_frame_payload_get(fp, sizeof(*pl));
++ if (!pl) {
++ FC_DBG("incoming PLOGI from %x too short\n", sid);
++ WARN_ON(1);
++ /* XXX TBD: send reject? */
++ fc_frame_free(fp);
++ return;
++ }
++ 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,
++ * set the state appropriately and accept the PLOGI.
++ *
++ * If we had also sent a PLOGI, and if the received PLOGI is from a
++ * higher WWPN, we accept it, otherwise an LS_RJT is sent with reason
++ * "command already in progress".
++ *
++ * XXX TBD: If the session was ready before, the PLOGI should result in
++ * all outstanding exchanges being reset.
++ */
++ switch (rp->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)
++ 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);
++ /* 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);
++ 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);
++ fc_frame_free(fp);
++ } else {
++ fp = fc_frame_alloc(lp, 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);
++ fc_frame_free(fp);
++ } else {
++ sp = lp->tt.seq_start_next(sp);
++ WARN_ON(!sp);
++ fc_rport_set_name(rport, wwpn, wwnn);
++
++ /*
++ * Get session payload size from incoming PLOGI.
++ */
++ rport->maxframe_size =
++ fc_plogi_get_maxframe(pl, lp->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);
++
++ /*
++ * Send LS_ACC. If this fails,
++ * the originator should retry.
++ */
++ 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)
++ fc_rport_enter_prli(rport);
++ else
++ fc_rport_state_enter(rport,
++ RPORT_ST_PLOGI_RECV);
++ }
++ }
++ fc_rport_unlock(rport);
++}
++
++/**
++ * fc_rport_recv_prli_req - Handle incoming Process Login (PRLI) request
++ * @rport: Fibre Channel remote port that initiated PRLI
++ * @sp: current sequence in the PRLI exchange
++ * @fp: PRLI request frame
++ */
++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_frame *fp;
++ struct fc_frame_header *fh;
++ struct fc_lport *lp;
++ struct {
++ struct fc_els_prli prli;
++ struct fc_els_spp spp;
++ } *pp;
++ struct fc_els_spp *rspp; /* request service param page */
++ struct fc_els_spp *spp; /* response spp */
++ unsigned int len;
++ unsigned int plen;
++ enum fc_els_rjt_reason reason = ELS_RJT_UNAB;
++ enum fc_els_rjt_explan explan = ELS_EXPL_NONE;
++ enum fc_els_spp_resp resp;
++ struct fc_seq_els_data rjt_data;
++ 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:
++ case RPORT_ST_PRLI:
++ case RPORT_ST_READY:
++ reason = ELS_RJT_NONE;
++ break;
++ default:
++ break;
++ }
++ len = fr_len(rx_fp) - sizeof(*fh);
++ pp = fc_frame_payload_get(rx_fp, sizeof(*pp));
++ if (pp == NULL) {
++ reason = ELS_RJT_PROT;
++ explan = ELS_EXPL_INV_LEN;
++ } else {
++ plen = ntohs(pp->prli.prli_len);
++ if ((plen % 4) != 0 || plen > len) {
++ reason = ELS_RJT_PROT;
++ explan = ELS_EXPL_INV_LEN;
++ } else if (plen < len) {
++ len = plen;
++ }
++ plen = pp->prli.prli_spp_len;
++ if ((plen % 4) != 0 || plen < sizeof(*spp) ||
++ plen > len || len < sizeof(*pp)) {
++ reason = ELS_RJT_PROT;
++ explan = ELS_EXPL_INV_LEN;
++ }
++ rspp = &pp->spp;
++ }
++ if (reason != ELS_RJT_NONE ||
++ (fp = fc_frame_alloc(lp, len)) == NULL) {
++ rjt_data.reason = reason;
++ rjt_data.explan = explan;
++ lp->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
++ } else {
++ sp = lp->tt.seq_start_next(sp);
++ WARN_ON(!sp);
++ pp = fc_frame_payload_get(fp, len);
++ WARN_ON(!pp);
++ memset(pp, 0, len);
++ pp->prli.prli_cmd = ELS_LS_ACC;
++ pp->prli.prli_spp_len = plen;
++ pp->prli.prli_len = htons(len);
++ len -= sizeof(struct fc_els_prli);
++
++ /*
++ * Go through all the service parameter pages and build
++ * response. If plen indicates longer SPP than standard,
++ * use that. The entire response has been pre-cleared above.
++ */
++ spp = &pp->spp;
++ while (len >= plen) {
++ spp->spp_type = rspp->spp_type;
++ spp->spp_type_ext = rspp->spp_type_ext;
++ spp->spp_flags = rspp->spp_flags & FC_SPP_EST_IMG_PAIR;
++ resp = FC_SPP_RESP_ACK;
++ if (rspp->spp_flags & FC_SPP_RPA_VAL)
++ resp = FC_SPP_RESP_NO_PA;
++ switch (rspp->spp_type) {
++ case 0: /* common to all FC-4 types */
++ break;
++ case FC_TYPE_FCP:
++ fcp_parm = ntohl(rspp->spp_params);
++ if (fcp_parm * FCP_SPPF_RETRY)
++ rp->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);
++ spp->spp_params =
++ htonl(rp->local_port->service_params);
++ break;
++ default:
++ resp = FC_SPP_RESP_INVL;
++ break;
++ }
++ spp->spp_flags |= resp;
++ len -= plen;
++ rspp = (struct fc_els_spp *)((char *)rspp + plen);
++ spp = (struct fc_els_spp *)((char *)spp + plen);
++ }
++
++ /*
++ * Send LS_ACC. If this fails, the originator should retry.
++ */
++ 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);
++
++ /*
++ * Get lock and re-check state.
++ */
++ fc_rport_lock(rport);
++ switch (rp->rp_state) {
++ case RPORT_ST_PLOGI_RECV:
++ 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);
++ }
++ break;
++ case RPORT_ST_READY:
++ break;
++ default:
++ break;
++ }
++ fc_rport_unlock(rport);
++ }
++ fc_frame_free(rx_fp);
++}
++
++/**
++ * fc_rport_recv_prlo_req - Handle incoming Process Logout (PRLO) request
++ * @rport: Fibre Channel remote port that initiated PRLO
++ * @sp: current sequence in the PRLO exchange
++ * @fp: PRLO request frame
++ */
++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_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);
++ 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);
++ fc_frame_free(fp);
++}
++
++/**
++ * fc_rport_recv_logo_req - Handle incoming Logout (LOGO) request
++ * @rport: Fibre Channel remote port that initiated LOGO
++ * @sp: current sequence in the LOGO exchange
++ * @fp: LOGO request frame
++ */
++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;
++
++ 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_frame_free(fp);
++}
++
++int fc_rport_init(struct fc_lport *lp)
++{
++ 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 (!lp->tt.rport_recv_req)
++ lp->tt.rport_recv_req = fc_rport_recv_req;
++
++ if (!lp->tt.rport_create)
++ lp->tt.rport_create = fc_remote_port_create;
++
++ if (!lp->tt.rport_lookup)
++ lp->tt.rport_lookup = fc_rport_lookup;
++
++ if (!lp->tt.rport_reset)
++ lp->tt.rport_reset = fc_rport_reset;
++
++ if (!lp->tt.rport_reset_list)
++ lp->tt.rport_reset_list = fc_rport_reset_list;
++
++ return 0;
++}
++EXPORT_SYMBOL(fc_rport_init);
++
+--
+1.5.2.4
+
projects / people / teissler / ipfire-2.x.git / blobdiff