Patched in Tegra support.

2 files changed, 212 insertions, 298 deletions

diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index d5088ce7829..0bfa545675b 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -30,8 +30,6 @@
  * SOFTWARE.
  */
 
-#define pr_fmt(fmt) PFX fmt
-
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -167,7 +165,7 @@ static void srp_free_iu(struct srp_host *host, struct srp_iu *iu)
 
 static void srp_qp_event(struct ib_event *event, void *context)
 {
-        pr_debug("QP event %d\n", event->event);
+        printk(KERN_ERR PFX "QP event %d\n", event->event);
 }
 
 static int srp_init_qp(struct srp_target_port *target,
@@ -222,29 +220,27 @@ static int srp_new_cm_id(struct srp_target_port *target)
 static int srp_create_target_ib(struct srp_target_port *target)
 {
         struct ib_qp_init_attr *init_attr;
-        struct ib_cq *recv_cq, *send_cq;
-        struct ib_qp *qp;
         int ret;
 
         init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL);
         if (!init_attr)
                 return -ENOMEM;
 
-        recv_cq = ib_create_cq(target->srp_host->srp_dev->dev,
-                               srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0);
-        if (IS_ERR(recv_cq)) {
-                ret = PTR_ERR(recv_cq);
+        target->recv_cq = ib_create_cq(target->srp_host->srp_dev->dev,
+                                       srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0);
+        if (IS_ERR(target->recv_cq)) {
+                ret = PTR_ERR(target->recv_cq);
                 goto err;
         }
 
-        send_cq = ib_create_cq(target->srp_host->srp_dev->dev,
-                               srp_send_completion, NULL, target, SRP_SQ_SIZE, 0);
-        if (IS_ERR(send_cq)) {
-                ret = PTR_ERR(send_cq);
+        target->send_cq = ib_create_cq(target->srp_host->srp_dev->dev,
+                                       srp_send_completion, NULL, target, SRP_SQ_SIZE, 0);
+        if (IS_ERR(target->send_cq)) {
+                ret = PTR_ERR(target->send_cq);
                 goto err_recv_cq;
         }
 
-        ib_req_notify_cq(recv_cq, IB_CQ_NEXT_COMP);
+        ib_req_notify_cq(target->recv_cq, IB_CQ_NEXT_COMP);
 
         init_attr->event_handler       = srp_qp_event;
         init_attr->cap.max_send_wr     = SRP_SQ_SIZE;
@@ -253,41 +249,30 @@ static int srp_create_target_ib(struct srp_target_port *target)
         init_attr->cap.max_send_sge    = 1;
         init_attr->sq_sig_type         = IB_SIGNAL_ALL_WR;
         init_attr->qp_type             = IB_QPT_RC;
-        init_attr->send_cq             = send_cq;
-        init_attr->recv_cq             = recv_cq;
+        init_attr->send_cq             = target->send_cq;
+        init_attr->recv_cq             = target->recv_cq;
 
-        qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
-        if (IS_ERR(qp)) {
-                ret = PTR_ERR(qp);
+        target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
+        if (IS_ERR(target->qp)) {
+                ret = PTR_ERR(target->qp);
                 goto err_send_cq;
         }
 
-        ret = srp_init_qp(target, qp);
+        ret = srp_init_qp(target, target->qp);
         if (ret)
                 goto err_qp;
 
-        if (target->qp)
-                ib_destroy_qp(target->qp);
-        if (target->recv_cq)
-                ib_destroy_cq(target->recv_cq);
-        if (target->send_cq)
-                ib_destroy_cq(target->send_cq);
-
-        target->qp = qp;
-        target->recv_cq = recv_cq;
-        target->send_cq = send_cq;
-
         kfree(init_attr);
         return 0;
 
 err_qp:
-        ib_destroy_qp(qp);
+        ib_destroy_qp(target->qp);
 
 err_send_cq:
-        ib_destroy_cq(send_cq);
+        ib_destroy_cq(target->send_cq);
 
 err_recv_cq:
-        ib_destroy_cq(recv_cq);
+        ib_destroy_cq(target->recv_cq);
 
 err:
         kfree(init_attr);
@@ -302,9 +287,6 @@ static void srp_free_target_ib(struct srp_target_port *target)
         ib_destroy_cq(target->send_cq);
         ib_destroy_cq(target->recv_cq);
 
-        target->qp = NULL;
-        target->send_cq = target->recv_cq = NULL;
-
         for (i = 0; i < SRP_RQ_SIZE; ++i)
                 srp_free_iu(target->srp_host, target->rx_ring[i]);
         for (i = 0; i < SRP_SQ_SIZE; ++i)
@@ -444,50 +426,34 @@ static int srp_send_req(struct srp_target_port *target)
         return status;
 }
 
-static bool srp_queue_remove_work(struct srp_target_port *target)
+static void srp_disconnect_target(struct srp_target_port *target)
 {
-        bool changed = false;
+        /* XXX should send SRP_I_LOGOUT request */
 
-        spin_lock_irq(&target->lock);
-        if (target->state != SRP_TARGET_REMOVED) {
-                target->state = SRP_TARGET_REMOVED;
-                changed = true;
+        init_completion(&target->done);
+        if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
+                shost_printk(KERN_DEBUG, target->scsi_host,
+                             PFX "Sending CM DREQ failed\n");
+                return;
         }
-        spin_unlock_irq(&target->lock);
-
-        if (changed)
-                queue_work(system_long_wq, &target->remove_work);
-
-        return changed;
+        wait_for_completion(&target->done);
 }
 
-static bool srp_change_conn_state(struct srp_target_port *target,
-                                  bool connected)
+static bool srp_change_state(struct srp_target_port *target,
+                            enum srp_target_state old,
+                            enum srp_target_state new)
 {
         bool changed = false;
 
         spin_lock_irq(&target->lock);
-        if (target->connected != connected) {
-                target->connected = connected;
+        if (target->state == old) {
+                target->state = new;
                 changed = true;
         }
         spin_unlock_irq(&target->lock);
-
         return changed;
 }
 
-static void srp_disconnect_target(struct srp_target_port *target)
-{
-        if (srp_change_conn_state(target, false)) {
-                /* XXX should send SRP_I_LOGOUT request */
-
-                if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
-                        shost_printk(KERN_DEBUG, target->scsi_host,
-                                     PFX "Sending CM DREQ failed\n");
-                }
-        }
-}
-
 static void srp_free_req_data(struct srp_target_port *target)
 {
         struct ib_device *ibdev = target->srp_host->srp_dev->dev;
@@ -506,65 +472,31 @@ static void srp_free_req_data(struct srp_target_port *target)
         }
 }
 
-/**
- * srp_del_scsi_host_attr() - Remove attributes defined in the host template.
- * @shost: SCSI host whose attributes to remove from sysfs.
- *
- * Note: Any attributes defined in the host template and that did not exist
- * before invocation of this function will be ignored.
- */
-static void srp_del_scsi_host_attr(struct Scsi_Host *shost)
+static void srp_remove_work(struct work_struct *work)
 {
-        struct device_attribute **attr;
+        struct srp_target_port *target =
+                container_of(work, struct srp_target_port, work);
 
-        for (attr = shost->hostt->shost_attrs; attr && *attr; ++attr)
-                device_remove_file(&shost->shost_dev, *attr);
-}
+        if (!srp_change_state(target, SRP_TARGET_DEAD, SRP_TARGET_REMOVED))
+                return;
 
-static void srp_remove_target(struct srp_target_port *target)
-{
-        WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);
+        spin_lock(&target->srp_host->target_lock);
+        list_del(&target->list);
+        spin_unlock(&target->srp_host->target_lock);
 
-        srp_del_scsi_host_attr(target->scsi_host);
         srp_remove_host(target->scsi_host);
         scsi_remove_host(target->scsi_host);
-        srp_disconnect_target(target);
         ib_destroy_cm_id(target->cm_id);
         srp_free_target_ib(target);
         srp_free_req_data(target);
         scsi_host_put(target->scsi_host);
 }
 
-static void srp_remove_work(struct work_struct *work)
-{
-        struct srp_target_port *target =
-                container_of(work, struct srp_target_port, remove_work);
-
-        WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);
-
-        spin_lock(&target->srp_host->target_lock);
-        list_del(&target->list);
-        spin_unlock(&target->srp_host->target_lock);
-
-        srp_remove_target(target);
-}
-
-static void srp_rport_delete(struct srp_rport *rport)
-{
-        struct srp_target_port *target = rport->lld_data;
-
-        srp_queue_remove_work(target);
-}
-
 static int srp_connect_target(struct srp_target_port *target)
 {
         int retries = 3;
         int ret;
 
-        WARN_ON_ONCE(target->connected);
-
-        target->qp_in_error = false;
-
         ret = srp_lookup_path(target);
         if (ret)
                 return ret;
@@ -584,7 +516,6 @@ static int srp_connect_target(struct srp_target_port *target)
                  */
                 switch (target->status) {
                 case 0:
-                        srp_change_conn_state(target, true);
                         return 0;
 
                 case SRP_PORT_REDIRECT:
@@ -637,74 +568,35 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd,
                         scmnd->sc_data_direction);
 }
 
-/**
- * srp_claim_req - Take ownership of the scmnd associated with a request.
- * @target: SRP target port.
- * @req: SRP request.
- * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take
- *         ownership of @req->scmnd if it equals @scmnd.
- *
- * Return value:
- * Either NULL or a pointer to the SCSI command the caller became owner of.
- */
-static struct scsi_cmnd *srp_claim_req(struct srp_target_port *target,
-                                       struct srp_request *req,
-                                       struct scsi_cmnd *scmnd)
+static void srp_remove_req(struct srp_target_port *target,
+                           struct srp_request *req, s32 req_lim_delta)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&target->lock, flags);
-        if (!scmnd) {
-                scmnd = req->scmnd;
-                req->scmnd = NULL;
-        } else if (req->scmnd == scmnd) {
-                req->scmnd = NULL;
-        } else {
-                scmnd = NULL;
-        }
-        spin_unlock_irqrestore(&target->lock, flags);
-
-        return scmnd;
-}
-
-/**
- * srp_free_req() - Unmap data and add request to the free request list.
- */
-static void srp_free_req(struct srp_target_port *target,
-                         struct srp_request *req, struct scsi_cmnd *scmnd,
-                         s32 req_lim_delta)
-{
-        unsigned long flags;
-
-        srp_unmap_data(scmnd, target, req);
-
+        srp_unmap_data(req->scmnd, target, req);
         spin_lock_irqsave(&target->lock, flags);
         target->req_lim += req_lim_delta;
+        req->scmnd = NULL;
         list_add_tail(&req->list, &target->free_reqs);
         spin_unlock_irqrestore(&target->lock, flags);
 }
 
 static void srp_reset_req(struct srp_target_port *target, struct srp_request *req)
 {
-        struct scsi_cmnd *scmnd = srp_claim_req(target, req, NULL);
-
-        if (scmnd) {
-                srp_free_req(target, req, scmnd, 0);
-                scmnd->result = DID_RESET << 16;
-                scmnd->scsi_done(scmnd);
-        }
+        req->scmnd->result = DID_RESET << 16;
+        req->scmnd->scsi_done(req->scmnd);
+        srp_remove_req(target, req, 0);
 }
 
 static int srp_reconnect_target(struct srp_target_port *target)
 {
-        struct Scsi_Host *shost = target->scsi_host;
+        struct ib_qp_attr qp_attr;
+        struct ib_wc wc;
         int i, ret;
 
-        if (target->state != SRP_TARGET_LIVE)
+        if (!srp_change_state(target, SRP_TARGET_LIVE, SRP_TARGET_CONNECTING))
                 return -EAGAIN;
 
-        scsi_target_block(&shost->shost_gendev);
-
         srp_disconnect_target(target);
         /*
          * Now get a new local CM ID so that we avoid confusing the
@@ -712,11 +604,21 @@ static int srp_reconnect_target(struct srp_target_port *target)
          */
         ret = srp_new_cm_id(target);
         if (ret)
-                goto unblock;
+                goto err;
 
-        ret = srp_create_target_ib(target);
+        qp_attr.qp_state = IB_QPS_RESET;
+        ret = ib_modify_qp(target->qp, &qp_attr, IB_QP_STATE);
+        if (ret)
+                goto err;
+
+        ret = srp_init_qp(target, target->qp);
         if (ret)
-                goto unblock;
+                goto err;
+
+        while (ib_poll_cq(target->recv_cq, 1, &wc) > 0)
+                ; /* nothing */
+        while (ib_poll_cq(target->send_cq, 1, &wc) > 0)
+                ; /* nothing */
 
         for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
                 struct srp_request *req = &target->req_ring[i];
@@ -728,16 +630,13 @@ static int srp_reconnect_target(struct srp_target_port *target)
         for (i = 0; i < SRP_SQ_SIZE; ++i)
                 list_add(&target->tx_ring[i]->list, &target->free_tx);
 
+        target->qp_in_error = 0;
         ret = srp_connect_target(target);
-
-unblock:
-        scsi_target_unblock(&shost->shost_gendev, ret == 0 ? SDEV_RUNNING :
-                            SDEV_TRANSPORT_OFFLINE);
-
         if (ret)
                 goto err;
 
-        shost_printk(KERN_INFO, target->scsi_host, PFX "reconnect succeeded\n");
+        if (!srp_change_state(target, SRP_TARGET_CONNECTING, SRP_TARGET_LIVE))
+                ret = -EAGAIN;
 
         return ret;
 
@@ -750,8 +649,17 @@ err:
          * However, we have to defer the real removal because we
          * are in the context of the SCSI error handler now, which
          * will deadlock if we call scsi_remove_host().
+         *
+         * Schedule our work inside the lock to avoid a race with
+         * the flush_scheduled_work() in srp_remove_one().
          */
-        srp_queue_remove_work(target);
+        spin_lock_irq(&target->lock);
+        if (target->state == SRP_TARGET_CONNECTING) {
+                target->state = SRP_TARGET_DEAD;
+                INIT_WORK(&target->work, srp_remove_work);
+                queue_work(ib_wq, &target->work);
+        }
+        spin_unlock_irq(&target->lock);
 
         return ret;
 }
@@ -1147,18 +1055,11 @@ static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
                 complete(&target->tsk_mgmt_done);
         } else {
                 req = &target->req_ring[rsp->tag];
-                scmnd = srp_claim_req(target, req, NULL);
-                if (!scmnd) {
+                scmnd = req->scmnd;
+                if (!scmnd)
                         shost_printk(KERN_ERR, target->scsi_host,
                                      "Null scmnd for RSP w/tag %016llx\n",
                                      (unsigned long long) rsp->tag);
-
-                        spin_lock_irqsave(&target->lock, flags);
-                        target->req_lim += be32_to_cpu(rsp->req_lim_delta);
-                        spin_unlock_irqrestore(&target->lock, flags);
-
-                        return;
-                }
                 scmnd->result = rsp->status;
 
                 if (rsp->flags & SRP_RSP_FLAG_SNSVALID) {
@@ -1173,9 +1074,7 @@ static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
                 else if (rsp->flags & (SRP_RSP_FLAG_DIOVER | SRP_RSP_FLAG_DIUNDER))
                         scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt));
 
-                srp_free_req(target, req, scmnd,
-                             be32_to_cpu(rsp->req_lim_delta));
-
+                srp_remove_req(target, req, be32_to_cpu(rsp->req_lim_delta));
                 scmnd->host_scribble = NULL;
                 scmnd->scsi_done(scmnd);
         }
@@ -1298,19 +1197,6 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
                              PFX "Recv failed with error code %d\n", res);
 }
 
-static void srp_handle_qp_err(enum ib_wc_status wc_status,
-                              enum ib_wc_opcode wc_opcode,
-                              struct srp_target_port *target)
-{
-        if (target->connected && !target->qp_in_error) {
-                shost_printk(KERN_ERR, target->scsi_host,
-                             PFX "failed %s status %d\n",
-                             wc_opcode & IB_WC_RECV ? "receive" : "send",
-                             wc_status);
-        }
-        target->qp_in_error = true;
-}
-
 static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
 {
         struct srp_target_port *target = target_ptr;
@@ -1318,11 +1204,15 @@ static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
 
         ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
         while (ib_poll_cq(cq, 1, &wc) > 0) {
-                if (likely(wc.status == IB_WC_SUCCESS)) {
-                        srp_handle_recv(target, &wc);
-                } else {
-                        srp_handle_qp_err(wc.status, wc.opcode, target);
+                if (wc.status) {
+                        shost_printk(KERN_ERR, target->scsi_host,
+                                     PFX "failed receive status %d\n",
+                                     wc.status);
+                        target->qp_in_error = 1;
+                        break;
                 }
+
+                srp_handle_recv(target, &wc);
         }
 }
 
@@ -1333,12 +1223,16 @@ static void srp_send_completion(struct ib_cq *cq, void *target_ptr)
         struct srp_iu *iu;
 
         while (ib_poll_cq(cq, 1, &wc) > 0) {
-                if (likely(wc.status == IB_WC_SUCCESS)) {
-                        iu = (struct srp_iu *) (uintptr_t) wc.wr_id;
-                        list_add(&iu->list, &target->free_tx);
-                } else {
-                        srp_handle_qp_err(wc.status, wc.opcode, target);
+                if (wc.status) {
+                        shost_printk(KERN_ERR, target->scsi_host,
+                                     PFX "failed send status %d\n",
+                                     wc.status);
+                        target->qp_in_error = 1;
+                        break;
                 }
+
+                iu = (struct srp_iu *) (uintptr_t) wc.wr_id;
+                list_add(&iu->list, &target->free_tx);
         }
 }
 
@@ -1352,6 +1246,16 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         unsigned long flags;
         int len;
 
+        if (target->state == SRP_TARGET_CONNECTING)
+                goto err;
+
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED) {
+                scmnd->result = DID_BAD_TARGET << 16;
+                scmnd->scsi_done(scmnd);
+                return 0;
+        }
+
         spin_lock_irqsave(&target->lock, flags);
         iu = __srp_get_tx_iu(target, SRP_IU_CMD);
         if (!iu)
@@ -1408,6 +1312,7 @@ err_iu:
 err_unlock:
         spin_unlock_irqrestore(&target->lock, flags);
 
+err:
         return SCSI_MLQUEUE_HOST_BUSY;
 }
 
@@ -1449,33 +1354,6 @@ err:
         return -ENOMEM;
 }
 
-static uint32_t srp_compute_rq_tmo(struct ib_qp_attr *qp_attr, int attr_mask)
-{
-        uint64_t T_tr_ns, max_compl_time_ms;
-        uint32_t rq_tmo_jiffies;
-
-        /*
-         * According to section 11.2.4.2 in the IBTA spec (Modify Queue Pair,
-         * table 91), both the QP timeout and the retry count have to be set
-         * for RC QP's during the RTR to RTS transition.
-         */
-        WARN_ON_ONCE((attr_mask & (IB_QP_TIMEOUT | IB_QP_RETRY_CNT)) !=
-                     (IB_QP_TIMEOUT | IB_QP_RETRY_CNT));
-
-        /*
-         * Set target->rq_tmo_jiffies to one second more than the largest time
-         * it can take before an error completion is generated. See also
-         * C9-140..142 in the IBTA spec for more information about how to
-         * convert the QP Local ACK Timeout value to nanoseconds.
-         */
-        T_tr_ns = 4096 * (1ULL << qp_attr->timeout);
-        max_compl_time_ms = qp_attr->retry_cnt * 4 * T_tr_ns;
-        do_div(max_compl_time_ms, NSEC_PER_MSEC);
-        rq_tmo_jiffies = msecs_to_jiffies(max_compl_time_ms + 1000);
-
-        return rq_tmo_jiffies;
-}
-
 static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
                                struct srp_login_rsp *lrsp,
                                struct srp_target_port *target)
@@ -1535,8 +1413,6 @@ static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
         if (ret)
                 goto error_free;
 
-        target->rq_tmo_jiffies = srp_compute_rq_tmo(qp_attr, attr_mask);
-
         ret = ib_modify_qp(target->qp, qp_attr, attr_mask);
         if (ret)
                 goto error_free;
@@ -1658,7 +1534,6 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
         case IB_CM_DREQ_RECEIVED:
                 shost_printk(KERN_WARNING, target->scsi_host,
                              PFX "DREQ received - connection closed\n");
-                srp_change_conn_state(target, false);
                 if (ib_send_cm_drep(cm_id, NULL, 0))
                         shost_printk(KERN_ERR, target->scsi_host,
                                      PFX "Sending CM DREP failed\n");
@@ -1668,6 +1543,7 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
                 shost_printk(KERN_ERR, target->scsi_host,
                              PFX "connection closed\n");
 
+                comp = 1;
                 target->status = 0;
                 break;
 
@@ -1695,6 +1571,10 @@ static int srp_send_tsk_mgmt(struct srp_target_port *target,
         struct srp_iu *iu;
         struct srp_tsk_mgmt *tsk_mgmt;
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -1;
+
         init_completion(&target->tsk_mgmt_done);
 
         spin_lock_irq(&target->lock);
@@ -1733,18 +1613,25 @@ static int srp_abort(struct scsi_cmnd *scmnd)
 {
         struct srp_target_port *target = host_to_target(scmnd->device->host);
         struct srp_request *req = (struct srp_request *) scmnd->host_scribble;
+        int ret = SUCCESS;
 
         shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
 
-        if (!req || target->qp_in_error || !srp_claim_req(target, req, scmnd))
+        if (!req || target->qp_in_error)
+                return FAILED;
+        if (srp_send_tsk_mgmt(target, req->index, scmnd->device->lun,
+                              SRP_TSK_ABORT_TASK))
                 return FAILED;
-        srp_send_tsk_mgmt(target, req->index, scmnd->device->lun,
-                          SRP_TSK_ABORT_TASK);
-        srp_free_req(target, req, scmnd, 0);
-        scmnd->result = DID_ABORT << 16;
-        scmnd->scsi_done(scmnd);
 
-        return SUCCESS;
+        if (req->scmnd) {
+                if (!target->tsk_mgmt_status) {
+                        srp_remove_req(target, req, 0);
+                        scmnd->result = DID_ABORT << 16;
+                } else
+                        ret = FAILED;
+        }
+
+        return ret;
 }
 
 static int srp_reset_device(struct scsi_cmnd *scmnd)
@@ -1784,26 +1671,15 @@ static int srp_reset_host(struct scsi_cmnd *scmnd)
         return ret;
 }
 
-static int srp_slave_configure(struct scsi_device *sdev)
-{
-        struct Scsi_Host *shost = sdev->host;
-        struct srp_target_port *target = host_to_target(shost);
-        struct request_queue *q = sdev->request_queue;
-        unsigned long timeout;
-
-        if (sdev->type == TYPE_DISK) {
-                timeout = max_t(unsigned, 30 * HZ, target->rq_tmo_jiffies);
-                blk_queue_rq_timeout(q, timeout);
-        }
-
-        return 0;
-}
-
 static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
                            char *buf)
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%016llx\n",
                        (unsigned long long) be64_to_cpu(target->id_ext));
 }
@@ -1813,6 +1689,10 @@ static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%016llx\n",
                        (unsigned long long) be64_to_cpu(target->ioc_guid));
 }
@@ -1822,6 +1702,10 @@ static ssize_t show_service_id(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%016llx\n",
                        (unsigned long long) be64_to_cpu(target->service_id));
 }
@@ -1831,6 +1715,10 @@ static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
 }
 
@@ -1839,6 +1727,10 @@ static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%pI6\n", target->path.dgid.raw);
 }
 
@@ -1847,6 +1739,10 @@ static ssize_t show_orig_dgid(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%pI6\n", target->orig_dgid);
 }
 
@@ -1855,6 +1751,10 @@ static ssize_t show_req_lim(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%d\n", target->req_lim);
 }
 
@@ -1863,6 +1763,10 @@ static ssize_t show_zero_req_lim(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%d\n", target->zero_req_lim);
 }
 
@@ -1931,7 +1835,6 @@ static struct scsi_host_template srp_template = {
         .module                         = THIS_MODULE,
         .name                           = "InfiniBand SRP initiator",
         .proc_name                      = DRV_NAME,
-        .slave_configure                = srp_slave_configure,
         .info                           = srp_target_info,
         .queuecommand                   = srp_queuecommand,
         .eh_abort_handler               = srp_abort,
@@ -1965,14 +1868,11 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
                 return PTR_ERR(rport);
         }
 
-        rport->lld_data = target;
-
         spin_lock(&host->target_lock);
         list_add_tail(&target->list, &host->target_list);
         spin_unlock(&host->target_lock);
 
         target->state = SRP_TARGET_LIVE;
-        target->connected = false;
 
         scsi_scan_target(&target->scsi_host->shost_gendev,
                          0, target->scsi_id, SCAN_WILD_CARD, 0);
@@ -2089,7 +1989,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                                 goto out;
                         }
                         if (strlen(p) != 32) {
-                                pr_warn("bad dest GID parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad dest GID parameter '%s'\n", p);
                                 kfree(p);
                                 goto out;
                         }
@@ -2104,7 +2004,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_PKEY:
                         if (match_hex(args, &token)) {
-                                pr_warn("bad P_Key parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad P_Key parameter '%s'\n", p);
                                 goto out;
                         }
                         target->path.pkey = cpu_to_be16(token);
@@ -2123,7 +2023,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_MAX_SECT:
                         if (match_int(args, &token)) {
-                                pr_warn("bad max sect parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad max sect parameter '%s'\n", p);
                                 goto out;
                         }
                         target->scsi_host->max_sectors = token;
@@ -2131,8 +2031,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_MAX_CMD_PER_LUN:
                         if (match_int(args, &token)) {
-                                pr_warn("bad max cmd_per_lun parameter '%s'\n",
-                                        p);
+                                printk(KERN_WARNING PFX "bad max cmd_per_lun parameter '%s'\n", p);
                                 goto out;
                         }
                         target->scsi_host->cmd_per_lun = min(token, SRP_CMD_SQ_SIZE);
@@ -2140,14 +2039,14 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_IO_CLASS:
                         if (match_hex(args, &token)) {
-                                pr_warn("bad IO class parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad  IO class parameter '%s' \n", p);
                                 goto out;
                         }
                         if (token != SRP_REV10_IB_IO_CLASS &&
                             token != SRP_REV16A_IB_IO_CLASS) {
-                                pr_warn("unknown IO class parameter value %x specified (use %x or %x).\n",
-                                        token, SRP_REV10_IB_IO_CLASS,
-                                        SRP_REV16A_IB_IO_CLASS);
+                                printk(KERN_WARNING PFX "unknown IO class parameter value"
+                                       " %x specified (use %x or %x).\n",
+                                       token, SRP_REV10_IB_IO_CLASS, SRP_REV16A_IB_IO_CLASS);
                                 goto out;
                         }
                         target->io_class = token;
@@ -2165,8 +2064,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_CMD_SG_ENTRIES:
                         if (match_int(args, &token) || token < 1 || token > 255) {
-                                pr_warn("bad max cmd_sg_entries parameter '%s'\n",
-                                        p);
+                                printk(KERN_WARNING PFX "bad max cmd_sg_entries parameter '%s'\n", p);
                                 goto out;
                         }
                         target->cmd_sg_cnt = token;
@@ -2174,7 +2072,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_ALLOW_EXT_SG:
                         if (match_int(args, &token)) {
-                                pr_warn("bad allow_ext_sg parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad allow_ext_sg parameter '%s'\n", p);
                                 goto out;
                         }
                         target->allow_ext_sg = !!token;
@@ -2183,16 +2081,15 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                 case SRP_OPT_SG_TABLESIZE:
                         if (match_int(args, &token) || token < 1 ||
                                         token > SCSI_MAX_SG_CHAIN_SEGMENTS) {
-                                pr_warn("bad max sg_tablesize parameter '%s'\n",
-                                        p);
+                                printk(KERN_WARNING PFX "bad max sg_tablesize parameter '%s'\n", p);
                                 goto out;
                         }
                         target->sg_tablesize = token;
                         break;
 
                 default:
-                        pr_warn("unknown parameter or missing value '%s' in target creation request\n",
-                                p);
+                        printk(KERN_WARNING PFX "unknown parameter or missing value "
+                               "'%s' in target creation request\n", p);
                         goto out;
                 }
         }
@@ -2203,8 +2100,9 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                 for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i)
                         if ((srp_opt_tokens[i].token & SRP_OPT_ALL) &&
                             !(srp_opt_tokens[i].token & opt_mask))
-                                pr_warn("target creation request is missing parameter '%s'\n",
-                                        srp_opt_tokens[i].pattern);
+                                printk(KERN_WARNING PFX "target creation request is "
+                                       "missing parameter '%s'\n",
+                                       srp_opt_tokens[i].pattern);
 
 out:
         kfree(options);
@@ -2251,7 +2149,7 @@ static ssize_t srp_create_target(struct device *dev,
 
         if (!host->srp_dev->fmr_pool && !target->allow_ext_sg &&
                                 target->cmd_sg_cnt < target->sg_tablesize) {
-                pr_warn("No FMR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n");
+                printk(KERN_WARNING PFX "No FMR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n");
                 target->sg_tablesize = target->cmd_sg_cnt;
         }
 
@@ -2262,7 +2160,6 @@ static ssize_t srp_create_target(struct device *dev,
                              sizeof (struct srp_indirect_buf) +
                              target->cmd_sg_cnt * sizeof (struct srp_direct_buf);
 
-        INIT_WORK(&target->remove_work, srp_remove_work);
         spin_lock_init(&target->lock);
         INIT_LIST_HEAD(&target->free_tx);
         INIT_LIST_HEAD(&target->free_reqs);
@@ -2307,6 +2204,7 @@ static ssize_t srp_create_target(struct device *dev,
         if (ret)
                 goto err_free_ib;
 
+        target->qp_in_error = 0;
         ret = srp_connect_target(target);
         if (ret) {
                 shost_printk(KERN_ERR, target->scsi_host,
@@ -2411,7 +2309,8 @@ static void srp_add_one(struct ib_device *device)
                 return;
 
         if (ib_query_device(device, dev_attr)) {
-                pr_warn("Query device failed for %s\n", device->name);
+                printk(KERN_WARNING PFX "Query device failed for %s\n",
+                       device->name);
                 goto free_attr;
         }
 
@@ -2496,7 +2395,8 @@ static void srp_remove_one(struct ib_device *device)
 {
         struct srp_device *srp_dev;
         struct srp_host *host, *tmp_host;
-        struct srp_target_port *target;
+        LIST_HEAD(target_list);
+        struct srp_target_port *target, *tmp_target;
 
         srp_dev = ib_get_client_data(device, &srp_client);
 
@@ -2509,17 +2409,34 @@ static void srp_remove_one(struct ib_device *device)
                 wait_for_completion(&host->released);
 
                 /*
-                 * Remove all target ports.
+                 * Mark all target ports as removed, so we stop queueing
+                 * commands and don't try to reconnect.
                  */
                 spin_lock(&host->target_lock);
-                list_for_each_entry(target, &host->target_list, list)
-                        srp_queue_remove_work(target);
+                list_for_each_entry(target, &host->target_list, list) {
+                        spin_lock_irq(&target->lock);
+                        target->state = SRP_TARGET_REMOVED;
+                        spin_unlock_irq(&target->lock);
+                }
                 spin_unlock(&host->target_lock);
 
                 /*
-                 * Wait for target port removal tasks.
+                 * Wait for any reconnection tasks that may have
+                 * started before we marked our target ports as
+                 * removed, and any target port removal tasks.
                  */
-                flush_workqueue(system_long_wq);
+                flush_workqueue(ib_wq);
+
+                list_for_each_entry_safe(target, tmp_target,
+                                         &host->target_list, list) {
+                        srp_remove_host(target->scsi_host);
+                        scsi_remove_host(target->scsi_host);
+                        srp_disconnect_target(target);
+                        ib_destroy_cm_id(target->cm_id);
+                        srp_free_target_ib(target);
+                        srp_free_req_data(target);
+                        scsi_host_put(target->scsi_host);
+                }
 
                 kfree(host);
         }
@@ -2533,7 +2450,6 @@ static void srp_remove_one(struct ib_device *device)
 }
 
 static struct srp_function_template ib_srp_transport_functions = {
-        .rport_delete            = srp_rport_delete,
 };
 
 static int __init srp_init_module(void)
@@ -2543,7 +2459,7 @@ static int __init srp_init_module(void)
         BUILD_BUG_ON(FIELD_SIZEOF(struct ib_wc, wr_id) < sizeof(void *));
 
         if (srp_sg_tablesize) {
-                pr_warn("srp_sg_tablesize is deprecated, please use cmd_sg_entries\n");
+                printk(KERN_WARNING PFX "srp_sg_tablesize is deprecated, please use cmd_sg_entries\n");
                 if (!cmd_sg_entries)
                         cmd_sg_entries = srp_sg_tablesize;
         }
@@ -2552,15 +2468,14 @@ static int __init srp_init_module(void)
                 cmd_sg_entries = SRP_DEF_SG_TABLESIZE;
 
         if (cmd_sg_entries > 255) {
-                pr_warn("Clamping cmd_sg_entries to 255\n");
+                printk(KERN_WARNING PFX "Clamping cmd_sg_entries to 255\n");
                 cmd_sg_entries = 255;
         }
 
         if (!indirect_sg_entries)
                 indirect_sg_entries = cmd_sg_entries;
         else if (indirect_sg_entries < cmd_sg_entries) {
-                pr_warn("Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n",
-                        cmd_sg_entries);
+                printk(KERN_WARNING PFX "Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n", cmd_sg_entries);
                 indirect_sg_entries = cmd_sg_entries;
         }
 
@@ -2571,7 +2486,7 @@ static int __init srp_init_module(void)
 
         ret = class_register(&srp_class);
         if (ret) {
-                pr_err("couldn't register class infiniband_srp\n");
+                printk(KERN_ERR PFX "couldn't register class infiniband_srp\n");
                 srp_release_transport(ib_srp_transport_template);
                 return ret;
         }
@@ -2580,7 +2495,7 @@ static int __init srp_init_module(void)
 
         ret = ib_register_client(&srp_client);
         if (ret) {
-                pr_err("couldn't register IB client\n");
+                printk(KERN_ERR PFX "couldn't register IB client\n");
                 srp_release_transport(ib_srp_transport_template);
                 ib_sa_unregister_client(&srp_sa_client);
                 class_unregister(&srp_class);
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h
index de2d0b3c0bf..020caf0c378 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.h
+++ b/drivers/infiniband/ulp/srp/ib_srp.h
@@ -80,7 +80,9 @@ enum {
 
 enum srp_target_state {
         SRP_TARGET_LIVE,
-        SRP_TARGET_REMOVED,
+        SRP_TARGET_CONNECTING,
+        SRP_TARGET_DEAD,
+        SRP_TARGET_REMOVED
 };
 
 enum srp_iu_type {
@@ -161,9 +163,6 @@ struct srp_target_port {
         struct ib_sa_query     *path_query;
         int                     path_query_id;
 
-        u32                     rq_tmo_jiffies;
-        bool                    connected;
-
         struct ib_cm_id        *cm_id;
 
         int                     max_ti_iu_len;
@@ -174,12 +173,12 @@ struct srp_target_port {
         struct srp_iu          *rx_ring[SRP_RQ_SIZE];
         struct srp_request      req_ring[SRP_CMD_SQ_SIZE];
 
-        struct work_struct      remove_work;
+        struct work_struct      work;
 
         struct list_head        list;
         struct completion       done;
         int                     status;
-        bool                    qp_in_error;
+        int                     qp_in_error;
 
         struct completion       tsk_mgmt_done;
         u8                      tsk_mgmt_status;