Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband: (45 commits)
  RDMA/cxgb3: Fix error paths in post_send and post_recv
  RDMA/nes: Fix stale ARP issue
  RDMA/nes: FIN during MPA startup causes timeout
  RDMA/nes: Free kmap() resources
  RDMA/nes: Check for zero STag
  RDMA/nes: Fix Xansation test crash on cm_node ref_count
  RDMA/nes: Abnormal listener exit causes loopback node crash
  RDMA/nes: Fix crash in nes_accept()
  RDMA/nes: Resource not freed for REJECTed connections
  RDMA/nes: MPA request/response error checking
  RDMA/nes: Fix query of ORD values
  RDMA/nes: Fix MAX_CM_BUFFER define
  RDMA/nes: Pass correct size to ioremap_nocache()
  RDMA/nes: Update copyright and branding string
  RDMA/nes: Add max_cqe check to nes_create_cq()
  RDMA/nes: Clean up struct nes_qp
  RDMA/nes: Implement IB_SIGNAL_ALL_WR as an iWARP extension
  RDMA/nes: Add additional SFP+ PHY uC status check and PHY reset
  RDMA/nes: Correct fast memory registration implementation
  IB/ehca: Fix error paths in post_send and post_recv
  ...

4 files changed, 39 insertions, 40 deletions

diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index c825142a2fb..0136abd50dd 100644
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -375,6 +375,7 @@ extern rwlock_t ehca_qp_idr_lock;
 extern rwlock_t ehca_cq_idr_lock;
 extern struct idr ehca_qp_idr;
 extern struct idr ehca_cq_idr;
+extern spinlock_t shca_list_lock;
 
 extern int ehca_static_rate;
 extern int ehca_port_act_time;
diff --git a/drivers/infiniband/hw/ehca/ehca_eq.c b/drivers/infiniband/hw/ehca/ehca_eq.c
index 523e733c630..3b87589b8ea 100644
--- a/drivers/infiniband/hw/ehca/ehca_eq.c
+++ b/drivers/infiniband/hw/ehca/ehca_eq.c
@@ -169,12 +169,15 @@ int ehca_destroy_eq(struct ehca_shca *shca, struct ehca_eq *eq)
         unsigned long flags;
         u64 h_ret;
 
-        spin_lock_irqsave(&eq->spinlock, flags);
         ibmebus_free_irq(eq->ist, (void *)shca);
 
-        h_ret = hipz_h_destroy_eq(shca->ipz_hca_handle, eq);
+        spin_lock_irqsave(&shca_list_lock, flags);
+        eq->is_initialized = 0;
+        spin_unlock_irqrestore(&shca_list_lock, flags);
 
-        spin_unlock_irqrestore(&eq->spinlock, flags);
+        tasklet_kill(&eq->interrupt_task);
+
+        h_ret = hipz_h_destroy_eq(shca->ipz_hca_handle, eq);
 
         if (h_ret != H_SUCCESS) {
                 ehca_err(&shca->ib_device, "Can't free EQ resources.");
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index fb2d83c5bf0..129a6bebd6e 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -123,7 +123,7 @@ DEFINE_IDR(ehca_qp_idr);
 DEFINE_IDR(ehca_cq_idr);
 
 static LIST_HEAD(shca_list); /* list of all registered ehcas */
-static DEFINE_SPINLOCK(shca_list_lock);
+DEFINE_SPINLOCK(shca_list_lock);
 
 static struct timer_list poll_eqs_timer;
 
diff --git a/drivers/infiniband/hw/ehca/ehca_reqs.c b/drivers/infiniband/hw/ehca/ehca_reqs.c
index 8fd88cd828f..e3ec7fdd67b 100644
--- a/drivers/infiniband/hw/ehca/ehca_reqs.c
+++ b/drivers/infiniband/hw/ehca/ehca_reqs.c
@@ -400,7 +400,6 @@ static inline void map_ib_wc_status(u32 cqe_status,
 
 static inline int post_one_send(struct ehca_qp *my_qp,
                          struct ib_send_wr *cur_send_wr,
-                         struct ib_send_wr **bad_send_wr,
                          int hidden)
 {
         struct ehca_wqe *wqe_p;
@@ -412,8 +411,6 @@ static inline int post_one_send(struct ehca_qp *my_qp,
         wqe_p = ipz_qeit_get_inc(&my_qp->ipz_squeue);
         if (unlikely(!wqe_p)) {
                 /* too many posted work requests: queue overflow */
-                if (bad_send_wr)
-                        *bad_send_wr = cur_send_wr;
                 ehca_err(my_qp->ib_qp.device, "Too many posted WQEs "
                          "qp_num=%x", my_qp->ib_qp.qp_num);
                 return -ENOMEM;
@@ -433,8 +430,6 @@ static inline int post_one_send(struct ehca_qp *my_qp,
          */
         if (unlikely(ret)) {
                 my_qp->ipz_squeue.current_q_offset = start_offset;
-                if (bad_send_wr)
-                        *bad_send_wr = cur_send_wr;
                 ehca_err(my_qp->ib_qp.device, "Could not write WQE "
                          "qp_num=%x", my_qp->ib_qp.qp_num);
                 return -EINVAL;
@@ -448,7 +443,6 @@ int ehca_post_send(struct ib_qp *qp,
                    struct ib_send_wr **bad_send_wr)
 {
         struct ehca_qp *my_qp = container_of(qp, struct ehca_qp, ib_qp);
-        struct ib_send_wr *cur_send_wr;
         int wqe_cnt = 0;
         int ret = 0;
         unsigned long flags;
@@ -457,7 +451,8 @@ int ehca_post_send(struct ib_qp *qp,
         if (unlikely(my_qp->state < IB_QPS_RTS)) {
                 ehca_err(qp->device, "Invalid QP state  qp_state=%d qpn=%x",
                          my_qp->state, qp->qp_num);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
         /* LOCK the QUEUE */
@@ -476,24 +471,21 @@ int ehca_post_send(struct ib_qp *qp,
                 struct ib_send_wr circ_wr;
                 memset(&circ_wr, 0, sizeof(circ_wr));
                 circ_wr.opcode = IB_WR_RDMA_READ;
-                post_one_send(my_qp, &circ_wr, NULL, 1); /* ignore retcode */
+                post_one_send(my_qp, &circ_wr, 1); /* ignore retcode */
                 wqe_cnt++;
                 ehca_dbg(qp->device, "posted circ wr  qp_num=%x", qp->qp_num);
                 my_qp->message_count = my_qp->packet_count = 0;
         }
 
         /* loop processes list of send reqs */
-        for (cur_send_wr = send_wr; cur_send_wr != NULL;
-             cur_send_wr = cur_send_wr->next) {
-                ret = post_one_send(my_qp, cur_send_wr, bad_send_wr, 0);
+        while (send_wr) {
+                ret = post_one_send(my_qp, send_wr, 0);
                 if (unlikely(ret)) {
-                        /* if one or more WQEs were successful, don't fail */
-                        if (wqe_cnt)
-                                ret = 0;
                         goto post_send_exit0;
                 }
                 wqe_cnt++;
-        } /* eof for cur_send_wr */
+                send_wr = send_wr->next;
+        }
 
 post_send_exit0:
         iosync(); /* serialize GAL register access */
@@ -503,6 +495,10 @@ post_send_exit0:
                          my_qp, qp->qp_num, wqe_cnt, ret);
         my_qp->message_count += wqe_cnt;
         spin_unlock_irqrestore(&my_qp->spinlock_s, flags);
+
+out:
+        if (ret)
+                *bad_send_wr = send_wr;
         return ret;
 }
 
@@ -511,7 +507,6 @@ static int internal_post_recv(struct ehca_qp *my_qp,
                               struct ib_recv_wr *recv_wr,
                               struct ib_recv_wr **bad_recv_wr)
 {
-        struct ib_recv_wr *cur_recv_wr;
         struct ehca_wqe *wqe_p;
         int wqe_cnt = 0;
         int ret = 0;
@@ -522,27 +517,23 @@ static int internal_post_recv(struct ehca_qp *my_qp,
         if (unlikely(!HAS_RQ(my_qp))) {
                 ehca_err(dev, "QP has no RQ  ehca_qp=%p qp_num=%x ext_type=%d",
                          my_qp, my_qp->real_qp_num, my_qp->ext_type);
-                return -ENODEV;
+                ret = -ENODEV;
+                goto out;
         }
 
         /* LOCK the QUEUE */
         spin_lock_irqsave(&my_qp->spinlock_r, flags);
 
-        /* loop processes list of send reqs */
-        for (cur_recv_wr = recv_wr; cur_recv_wr != NULL;
-             cur_recv_wr = cur_recv_wr->next) {
+        /* loop processes list of recv reqs */
+        while (recv_wr) {
                 u64 start_offset = my_qp->ipz_rqueue.current_q_offset;
                 /* get pointer next to free WQE */
                 wqe_p = ipz_qeit_get_inc(&my_qp->ipz_rqueue);
                 if (unlikely(!wqe_p)) {
                         /* too many posted work requests: queue overflow */
-                        if (bad_recv_wr)
-                                *bad_recv_wr = cur_recv_wr;
-                        if (wqe_cnt == 0) {
-                                ret = -ENOMEM;
-                                ehca_err(dev, "Too many posted WQEs "
-                                         "qp_num=%x", my_qp->real_qp_num);
-                        }
+                        ret = -ENOMEM;
+                        ehca_err(dev, "Too many posted WQEs "
+                                "qp_num=%x", my_qp->real_qp_num);
                         goto post_recv_exit0;
                 }
                 /*
@@ -552,7 +543,7 @@ static int internal_post_recv(struct ehca_qp *my_qp,
                 rq_map_idx = start_offset / my_qp->ipz_rqueue.qe_size;
 
                 /* write a RECV WQE into the QUEUE */
-                ret = ehca_write_rwqe(&my_qp->ipz_rqueue, wqe_p, cur_recv_wr,
+                ret = ehca_write_rwqe(&my_qp->ipz_rqueue, wqe_p, recv_wr,
                                 rq_map_idx);
                 /*
                  * if something failed,
@@ -560,22 +551,20 @@ static int internal_post_recv(struct ehca_qp *my_qp,
                  */
                 if (unlikely(ret)) {
                         my_qp->ipz_rqueue.current_q_offset = start_offset;
-                        *bad_recv_wr = cur_recv_wr;
-                        if (wqe_cnt == 0) {
-                                ret = -EINVAL;
-                                ehca_err(dev, "Could not write WQE "
-                                         "qp_num=%x", my_qp->real_qp_num);
-                        }
+                        ret = -EINVAL;
+                        ehca_err(dev, "Could not write WQE "
+                                "qp_num=%x", my_qp->real_qp_num);
                         goto post_recv_exit0;
                 }
 
                 qmap_entry = &my_qp->rq_map.map[rq_map_idx];
-                qmap_entry->app_wr_id = get_app_wr_id(cur_recv_wr->wr_id);
+                qmap_entry->app_wr_id = get_app_wr_id(recv_wr->wr_id);
                 qmap_entry->reported = 0;
                 qmap_entry->cqe_req = 1;
 
                 wqe_cnt++;
-        } /* eof for cur_recv_wr */
+                recv_wr = recv_wr->next;
+        } /* eof for recv_wr */
 
 post_recv_exit0:
         iosync(); /* serialize GAL register access */
@@ -584,6 +573,11 @@ post_recv_exit0:
             ehca_dbg(dev, "ehca_qp=%p qp_num=%x wqe_cnt=%d ret=%i",
                      my_qp, my_qp->real_qp_num, wqe_cnt, ret);
         spin_unlock_irqrestore(&my_qp->spinlock_r, flags);
+
+out:
+        if (ret)
+                *bad_recv_wr = recv_wr;
+
         return ret;
 }
 
@@ -597,6 +591,7 @@ int ehca_post_recv(struct ib_qp *qp,
         if (unlikely(my_qp->state == IB_QPS_RESET)) {
                 ehca_err(qp->device, "Invalid QP state  qp_state=%d qpn=%x",
                          my_qp->state, qp->qp_num);
+                *bad_recv_wr = recv_wr;
                 return -EINVAL;
         }