1 files changed, 118 insertions, 55 deletions

diff --git a/drivers/infiniband/hw/cxgb3/iwch_cm.c b/drivers/infiniband/hw/cxgb3/iwch_cm.c
index 72ca360c3dbc..c325c44807e8 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_cm.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_cm.c
@@ -63,10 +63,14 @@ static char *states[] = {
         NULL,
 };
 
-static int ep_timeout_secs = 10;
+int peer2peer = 0;
+module_param(peer2peer, int, 0644);
+MODULE_PARM_DESC(peer2peer, "Support peer2peer ULPs (default=0)");
+
+static int ep_timeout_secs = 60;
 module_param(ep_timeout_secs, int, 0644);
 MODULE_PARM_DESC(ep_timeout_secs, "CM Endpoint operation timeout "
-                                   "in seconds (default=10)");
+                                   "in seconds (default=60)");
 
 static int mpa_rev = 1;
 module_param(mpa_rev, int, 0644);
@@ -125,6 +129,12 @@ static void start_ep_timer(struct iwch_ep *ep)
 static void stop_ep_timer(struct iwch_ep *ep)
 {
         PDBG("%s ep %p\n", __func__, ep);
+        if (!timer_pending(&ep->timer)) {
+                printk(KERN_ERR "%s timer stopped when its not running!  ep %p state %u\n",
+                        __func__, ep, ep->com.state);
+                WARN_ON(1);
+                return;
+        }
         del_timer_sync(&ep->timer);
         put_ep(&ep->com);
 }
@@ -508,7 +518,7 @@ static void send_mpa_req(struct iwch_ep *ep, struct sk_buff *skb)
         skb_reset_transport_header(skb);
         len = skb->len;
         req = (struct tx_data_wr *) skb_push(skb, sizeof(*req));
-        req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA));
+        req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA)|F_WR_COMPL);
         req->wr_lo = htonl(V_WR_TID(ep->hwtid));
         req->len = htonl(len);
         req->param = htonl(V_TX_PORT(ep->l2t->smt_idx) |
@@ -559,7 +569,7 @@ static int send_mpa_reject(struct iwch_ep *ep, const void *pdata, u8 plen)
         set_arp_failure_handler(skb, arp_failure_discard);
         skb_reset_transport_header(skb);
         req = (struct tx_data_wr *) skb_push(skb, sizeof(*req));
-        req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA));
+        req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA)|F_WR_COMPL);
         req->wr_lo = htonl(V_WR_TID(ep->hwtid));
         req->len = htonl(mpalen);
         req->param = htonl(V_TX_PORT(ep->l2t->smt_idx) |
@@ -611,7 +621,7 @@ static int send_mpa_reply(struct iwch_ep *ep, const void *pdata, u8 plen)
         skb_reset_transport_header(skb);
         len = skb->len;
         req = (struct tx_data_wr *) skb_push(skb, sizeof(*req));
-        req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA));
+        req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA)|F_WR_COMPL);
         req->wr_lo = htonl(V_WR_TID(ep->hwtid));
         req->len = htonl(len);
         req->param = htonl(V_TX_PORT(ep->l2t->smt_idx) |
@@ -879,6 +889,7 @@ static void process_mpa_reply(struct iwch_ep *ep, struct sk_buff *skb)
          * the MPA header is valid.
          */
         state_set(&ep->com, FPDU_MODE);
+        ep->mpa_attr.initiator = 1;
         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
         ep->mpa_attr.recv_marker_enabled = markers_enabled;
         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
@@ -901,8 +912,14 @@ static void process_mpa_reply(struct iwch_ep *ep, struct sk_buff *skb)
         /* bind QP and TID with INIT_WR */
         err = iwch_modify_qp(ep->com.qp->rhp,
                              ep->com.qp, mask, &attrs, 1);
-        if (!err)
-                goto out;
+        if (err)
+                goto err;
+
+        if (peer2peer && iwch_rqes_posted(ep->com.qp) == 0) {
+                iwch_post_zb_read(ep->com.qp);
+        }
+
+        goto out;
 err:
         abort_connection(ep, skb, GFP_KERNEL);
 out:
@@ -995,6 +1012,7 @@ static void process_mpa_request(struct iwch_ep *ep, struct sk_buff *skb)
          * If we get here we have accumulated the entire mpa
          * start reply message including private data.
          */
+        ep->mpa_attr.initiator = 0;
         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
         ep->mpa_attr.recv_marker_enabled = markers_enabled;
         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
@@ -1065,17 +1083,33 @@ static int tx_ack(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
 
         PDBG("%s ep %p credits %u\n", __func__, ep, credits);
 
-        if (credits == 0)
+        if (credits == 0) {
+                PDBG(KERN_ERR "%s 0 credit ack  ep %p state %u\n",
+                        __func__, ep, state_read(&ep->com));
                 return CPL_RET_BUF_DONE;
+        }
+
         BUG_ON(credits != 1);
-        BUG_ON(ep->mpa_skb == NULL);
-        kfree_skb(ep->mpa_skb);
-        ep->mpa_skb = NULL;
         dst_confirm(ep->dst);
-        if (state_read(&ep->com) == MPA_REP_SENT) {
-                ep->com.rpl_done = 1;
-                PDBG("waking up ep %p\n", ep);
-                wake_up(&ep->com.waitq);
+        if (!ep->mpa_skb) {
+                PDBG("%s rdma_init wr_ack ep %p state %u\n",
+                        __func__, ep, state_read(&ep->com));
+                if (ep->mpa_attr.initiator) {
+                        PDBG("%s initiator ep %p state %u\n",
+                                __func__, ep, state_read(&ep->com));
+                        if (peer2peer)
+                                iwch_post_zb_read(ep->com.qp);
+                } else {
+                        PDBG("%s responder ep %p state %u\n",
+                                __func__, ep, state_read(&ep->com));
+                        ep->com.rpl_done = 1;
+                        wake_up(&ep->com.waitq);
+                }
+        } else {
+                PDBG("%s lsm ack ep %p state %u freeing skb\n",
+                        __func__, ep, state_read(&ep->com));
+                kfree_skb(ep->mpa_skb);
+                ep->mpa_skb = NULL;
         }
         return CPL_RET_BUF_DONE;
 }
@@ -1083,8 +1117,11 @@ static int tx_ack(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
 static int abort_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
 {
         struct iwch_ep *ep = ctx;
+        unsigned long flags;
+        int release = 0;
 
         PDBG("%s ep %p\n", __func__, ep);
+        BUG_ON(!ep);
 
         /*
          * We get 2 abort replies from the HW.  The first one must
@@ -1095,9 +1132,22 @@ static int abort_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                 return CPL_RET_BUF_DONE;
         }
 
-        close_complete_upcall(ep);
-        state_set(&ep->com, DEAD);
-        release_ep_resources(ep);
+        spin_lock_irqsave(&ep->com.lock, flags);
+        switch (ep->com.state) {
+        case ABORTING:
+                close_complete_upcall(ep);
+                __state_set(&ep->com, DEAD);
+                release = 1;
+                break;
+        default:
+                printk(KERN_ERR "%s ep %p state %d\n",
+                     __func__, ep, ep->com.state);
+                break;
+        }
+        spin_unlock_irqrestore(&ep->com.lock, flags);
+
+        if (release)
+                release_ep_resources(ep);
         return CPL_RET_BUF_DONE;
 }
 
@@ -1470,7 +1520,8 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
         struct sk_buff *rpl_skb;
         struct iwch_qp_attributes attrs;
         int ret;
-        int state;
+        int release = 0;
+        unsigned long flags;
 
         if (is_neg_adv_abort(req->status)) {
                 PDBG("%s neg_adv_abort ep %p tid %d\n", __func__, ep,
@@ -1488,9 +1539,9 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                 return CPL_RET_BUF_DONE;
         }
 
-        state = state_read(&ep->com);
-        PDBG("%s ep %p state %u\n", __func__, ep, state);
-        switch (state) {
+        spin_lock_irqsave(&ep->com.lock, flags);
+        PDBG("%s ep %p state %u\n", __func__, ep, ep->com.state);
+        switch (ep->com.state) {
         case CONNECTING:
                 break;
         case MPA_REQ_WAIT:
@@ -1536,21 +1587,25 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                 break;
         case DEAD:
                 PDBG("%s PEER_ABORT IN DEAD STATE!!!!\n", __func__);
+                spin_unlock_irqrestore(&ep->com.lock, flags);
                 return CPL_RET_BUF_DONE;
         default:
                 BUG_ON(1);
                 break;
         }
         dst_confirm(ep->dst);
+        if (ep->com.state != ABORTING) {
+                __state_set(&ep->com, DEAD);
+                release = 1;
+        }
+        spin_unlock_irqrestore(&ep->com.lock, flags);
 
         rpl_skb = get_skb(skb, sizeof(*rpl), GFP_KERNEL);
         if (!rpl_skb) {
                 printk(KERN_ERR MOD "%s - cannot allocate skb!\n",
                        __func__);
-                dst_release(ep->dst);
-                l2t_release(L2DATA(ep->com.tdev), ep->l2t);
-                put_ep(&ep->com);
-                return CPL_RET_BUF_DONE;
+                release = 1;
+                goto out;
         }
         rpl_skb->priority = CPL_PRIORITY_DATA;
         rpl = (struct cpl_abort_rpl *) skb_put(rpl_skb, sizeof(*rpl));
@@ -1559,10 +1614,9 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
         OPCODE_TID(rpl) = htonl(MK_OPCODE_TID(CPL_ABORT_RPL, ep->hwtid));
         rpl->cmd = CPL_ABORT_NO_RST;
         cxgb3_ofld_send(ep->com.tdev, rpl_skb);
-        if (state != ABORTING) {
-                state_set(&ep->com, DEAD);
+out:
+        if (release)
                 release_ep_resources(ep);
-        }
         return CPL_RET_BUF_DONE;
 }
 
@@ -1596,8 +1650,8 @@ static int close_con_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                 release = 1;
                 break;
         case ABORTING:
-                break;
         case DEAD:
+                break;
         default:
                 BUG_ON(1);
                 break;
@@ -1661,15 +1715,18 @@ static void ep_timeout(unsigned long arg)
         struct iwch_ep *ep = (struct iwch_ep *)arg;
         struct iwch_qp_attributes attrs;
         unsigned long flags;
+        int abort = 1;
 
         spin_lock_irqsave(&ep->com.lock, flags);
         PDBG("%s ep %p tid %u state %d\n", __func__, ep, ep->hwtid,
              ep->com.state);
         switch (ep->com.state) {
         case MPA_REQ_SENT:
+                __state_set(&ep->com, ABORTING);
                 connect_reply_upcall(ep, -ETIMEDOUT);
                 break;
         case MPA_REQ_WAIT:
+                __state_set(&ep->com, ABORTING);
                 break;
         case CLOSING:
         case MORIBUND:
@@ -1679,13 +1736,17 @@ static void ep_timeout(unsigned long arg)
                                      ep->com.qp, IWCH_QP_ATTR_NEXT_STATE,
                                      &attrs, 1);
                 }
+                __state_set(&ep->com, ABORTING);
                 break;
         default:
-                BUG();
+                printk(KERN_ERR "%s unexpected state ep %p state %u\n",
+                        __func__, ep, ep->com.state);
+                WARN_ON(1);
+                abort = 0;
         }
-        __state_set(&ep->com, CLOSING);
         spin_unlock_irqrestore(&ep->com.lock, flags);
-        abort_connection(ep, NULL, GFP_ATOMIC);
+        if (abort)
+                abort_connection(ep, NULL, GFP_ATOMIC);
         put_ep(&ep->com);
 }
 
@@ -1762,16 +1823,19 @@ int iwch_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         if (err)
                 goto err;
 
+        /* if needed, wait for wr_ack */
+        if (iwch_rqes_posted(qp)) {
+                wait_event(ep->com.waitq, ep->com.rpl_done);
+                err = ep->com.rpl_err;
+                if (err)
+                        goto err;
+        }
+
         err = send_mpa_reply(ep, conn_param->private_data,
                              conn_param->private_data_len);
         if (err)
                 goto err;
 
-        /* wait for wr_ack */
-        wait_event(ep->com.waitq, ep->com.rpl_done);
-        err = ep->com.rpl_err;
-        if (err)
-                goto err;
 
         state_set(&ep->com, FPDU_MODE);
         established_upcall(ep);
@@ -1968,40 +2032,39 @@ int iwch_ep_disconnect(struct iwch_ep *ep, int abrupt, gfp_t gfp)
         PDBG("%s ep %p state %s, abrupt %d\n", __func__, ep,
              states[ep->com.state], abrupt);
 
-        if (ep->com.state == DEAD) {
-                PDBG("%s already dead ep %p\n", __func__, ep);
-                goto out;
-        }
-
-        if (abrupt) {
-                if (ep->com.state != ABORTING) {
-                        ep->com.state = ABORTING;
-                        close = 1;
-                }
-                goto out;
-        }
-
         switch (ep->com.state) {
         case MPA_REQ_WAIT:
         case MPA_REQ_SENT:
         case MPA_REQ_RCVD:
         case MPA_REP_SENT:
         case FPDU_MODE:
-                start_ep_timer(ep);
-                ep->com.state = CLOSING;
                 close = 1;
+                if (abrupt)
+                        ep->com.state = ABORTING;
+                else {
+                        ep->com.state = CLOSING;
+                        start_ep_timer(ep);
+                }
                 break;
         case CLOSING:
-                ep->com.state = MORIBUND;
                 close = 1;
+                if (abrupt) {
+                        stop_ep_timer(ep);
+                        ep->com.state = ABORTING;
+                } else
+                        ep->com.state = MORIBUND;
                 break;
         case MORIBUND:
+        case ABORTING:
+        case DEAD:
+                PDBG("%s ignoring disconnect ep %p state %u\n",
+                     __func__, ep, ep->com.state);
                 break;
         default:
                 BUG();
                 break;
         }
-out:
+
         spin_unlock_irqrestore(&ep->com.lock, flags);
         if (close) {
                 if (abrupt)