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

1 files changed, 52 insertions, 62 deletions

diff --git a/drivers/infiniband/core/mad_rmpp.c b/drivers/infiniband/core/mad_rmpp.c
index e23836d0e21b..3249e1d8c07b 100644
--- a/drivers/infiniband/core/mad_rmpp.c
+++ b/drivers/infiniband/core/mad_rmpp.c
@@ -103,12 +103,12 @@ void ib_cancel_rmpp_recvs(struct ib_mad_agent_private *agent)
 static int data_offset(u8 mgmt_class)
 {
         if (mgmt_class == IB_MGMT_CLASS_SUBN_ADM)
-                return offsetof(struct ib_sa_mad, data);
+                return IB_MGMT_SA_HDR;
         else if ((mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) &&
                  (mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END))
-                return offsetof(struct ib_vendor_mad, data);
+                return IB_MGMT_VENDOR_HDR;
         else
-                return offsetof(struct ib_rmpp_mad, data);
+                return IB_MGMT_RMPP_HDR;
 }
 
 static void format_ack(struct ib_rmpp_mad *ack,
@@ -135,55 +135,52 @@ static void ack_recv(struct mad_rmpp_recv *rmpp_recv,
                      struct ib_mad_recv_wc *recv_wc)
 {
         struct ib_mad_send_buf *msg;
-        struct ib_send_wr *bad_send_wr;
-        int hdr_len, ret;
+        int ret;
 
-        hdr_len = sizeof(struct ib_mad_hdr) + sizeof(struct ib_rmpp_hdr);
         msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp,
-                                 recv_wc->wc->pkey_index, rmpp_recv->ah, 1,
-                                 hdr_len, sizeof(struct ib_rmpp_mad) - hdr_len,
-                                 GFP_KERNEL);
+                                 recv_wc->wc->pkey_index, 1, IB_MGMT_RMPP_HDR,
+                                 IB_MGMT_RMPP_DATA, GFP_KERNEL);
         if (!msg)
                 return;
 
-        format_ack((struct ib_rmpp_mad *) msg->mad,
-                   (struct ib_rmpp_mad *) recv_wc->recv_buf.mad, rmpp_recv);
-        ret = ib_post_send_mad(&rmpp_recv->agent->agent, &msg->send_wr,
-                               &bad_send_wr);
+        format_ack(msg->mad, (struct ib_rmpp_mad *) recv_wc->recv_buf.mad,
+                   rmpp_recv);
+        msg->ah = rmpp_recv->ah;
+        ret = ib_post_send_mad(msg, NULL);
         if (ret)
                 ib_free_send_mad(msg);
 }
 
-static int alloc_response_msg(struct ib_mad_agent *agent,
-                              struct ib_mad_recv_wc *recv_wc,
-                              struct ib_mad_send_buf **msg)
+static struct ib_mad_send_buf *alloc_response_msg(struct ib_mad_agent *agent,
+                                                  struct ib_mad_recv_wc *recv_wc)
 {
-        struct ib_mad_send_buf *m;
+        struct ib_mad_send_buf *msg;
         struct ib_ah *ah;
-        int hdr_len;
 
         ah = ib_create_ah_from_wc(agent->qp->pd, recv_wc->wc,
                                   recv_wc->recv_buf.grh, agent->port_num);
         if (IS_ERR(ah))
-                return PTR_ERR(ah);
-
-        hdr_len = sizeof(struct ib_mad_hdr) + sizeof(struct ib_rmpp_hdr);
-        m = ib_create_send_mad(agent, recv_wc->wc->src_qp,
-                               recv_wc->wc->pkey_index, ah, 1, hdr_len,
-                               sizeof(struct ib_rmpp_mad) - hdr_len,
-                               GFP_KERNEL);
-        if (IS_ERR(m)) {
+                return (void *) ah;
+
+        msg = ib_create_send_mad(agent, recv_wc->wc->src_qp,
+                                 recv_wc->wc->pkey_index, 1,
+                                 IB_MGMT_RMPP_HDR, IB_MGMT_RMPP_DATA,
+                                 GFP_KERNEL);
+        if (IS_ERR(msg))
                 ib_destroy_ah(ah);
-                return PTR_ERR(m);
-        }
-        *msg = m;
-        return 0;
+        else
+                msg->ah = ah;
+
+        return msg;
 }
 
-static void free_msg(struct ib_mad_send_buf *msg)
+void ib_rmpp_send_handler(struct ib_mad_send_wc *mad_send_wc)
 {
-        ib_destroy_ah(msg->send_wr.wr.ud.ah);
-        ib_free_send_mad(msg);
+        struct ib_rmpp_mad *rmpp_mad = mad_send_wc->send_buf->mad;
+
+        if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_ACK)
+                ib_destroy_ah(mad_send_wc->send_buf->ah);
+        ib_free_send_mad(mad_send_wc->send_buf);
 }
 
 static void nack_recv(struct ib_mad_agent_private *agent,
@@ -191,14 +188,13 @@ static void nack_recv(struct ib_mad_agent_private *agent,
 {
         struct ib_mad_send_buf *msg;
         struct ib_rmpp_mad *rmpp_mad;
-        struct ib_send_wr *bad_send_wr;
         int ret;
 
-        ret = alloc_response_msg(&agent->agent, recv_wc, &msg);
-        if (ret)
+        msg = alloc_response_msg(&agent->agent, recv_wc);
+        if (IS_ERR(msg))
                 return;
 
-        rmpp_mad = (struct ib_rmpp_mad *) msg->mad;
+        rmpp_mad = msg->mad;
         memcpy(rmpp_mad, recv_wc->recv_buf.mad,
                data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class));
 
@@ -210,9 +206,11 @@ static void nack_recv(struct ib_mad_agent_private *agent,
         rmpp_mad->rmpp_hdr.seg_num = 0;
         rmpp_mad->rmpp_hdr.paylen_newwin = 0;
 
-        ret = ib_post_send_mad(&agent->agent, &msg->send_wr, &bad_send_wr);
-        if (ret)
-                free_msg(msg);
+        ret = ib_post_send_mad(msg, NULL);
+        if (ret) {
+                ib_destroy_ah(msg->ah);
+                ib_free_send_mad(msg);
+        }
 }
 
 static void recv_timeout_handler(void *data)
@@ -585,7 +583,7 @@ static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr)
         int timeout;
         u32 paylen;
 
-        rmpp_mad = (struct ib_rmpp_mad *)mad_send_wr->send_wr.wr.ud.mad_hdr;
+        rmpp_mad = mad_send_wr->send_buf.mad;
         ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE);
         rmpp_mad->rmpp_hdr.seg_num = cpu_to_be32(mad_send_wr->seg_num);
 
@@ -612,7 +610,7 @@ static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr)
         }
 
         /* 2 seconds for an ACK until we can find the packet lifetime */
-        timeout = mad_send_wr->send_wr.wr.ud.timeout_ms;
+        timeout = mad_send_wr->send_buf.timeout_ms;
         if (!timeout || timeout > 2000)
                 mad_send_wr->timeout = msecs_to_jiffies(2000);
         mad_send_wr->seg_num++;
@@ -640,7 +638,7 @@ static void abort_send(struct ib_mad_agent_private *agent, __be64 tid,
 
         wc.status = IB_WC_REM_ABORT_ERR;
         wc.vendor_err = rmpp_status;
-        wc.wr_id = mad_send_wr->wr_id;
+        wc.send_buf = &mad_send_wr->send_buf;
         ib_mad_complete_send_wr(mad_send_wr, &wc);
         return;
 out:
@@ -694,12 +692,12 @@ static void process_rmpp_ack(struct ib_mad_agent_private *agent,
 
         if (seg_num > mad_send_wr->last_ack) {
                 mad_send_wr->last_ack = seg_num;
-                mad_send_wr->retries = mad_send_wr->send_wr.wr.ud.retries;
+                mad_send_wr->retries = mad_send_wr->send_buf.retries;
         }
         mad_send_wr->newwin = newwin;
         if (mad_send_wr->last_ack == mad_send_wr->total_seg) {
                 /* If no response is expected, the ACK completes the send */
-                if (!mad_send_wr->send_wr.wr.ud.timeout_ms) {
+                if (!mad_send_wr->send_buf.timeout_ms) {
                         struct ib_mad_send_wc wc;
 
                         ib_mark_mad_done(mad_send_wr);
@@ -707,13 +705,13 @@ static void process_rmpp_ack(struct ib_mad_agent_private *agent,
 
                         wc.status = IB_WC_SUCCESS;
                         wc.vendor_err = 0;
-                        wc.wr_id = mad_send_wr->wr_id;
+                        wc.send_buf = &mad_send_wr->send_buf;
                         ib_mad_complete_send_wr(mad_send_wr, &wc);
                         return;
                 }
                 if (mad_send_wr->refcount == 1)
-                        ib_reset_mad_timeout(mad_send_wr, mad_send_wr->
-                                             send_wr.wr.ud.timeout_ms);
+                        ib_reset_mad_timeout(mad_send_wr,
+                                             mad_send_wr->send_buf.timeout_ms);
         } else if (mad_send_wr->refcount == 1 &&
                    mad_send_wr->seg_num < mad_send_wr->newwin &&
                    mad_send_wr->seg_num <= mad_send_wr->total_seg) {
@@ -842,7 +840,7 @@ int ib_send_rmpp_mad(struct ib_mad_send_wr_private *mad_send_wr)
         struct ib_rmpp_mad *rmpp_mad;
         int i, total_len, ret;
 
-        rmpp_mad = (struct ib_rmpp_mad *)mad_send_wr->send_wr.wr.ud.mad_hdr;
+        rmpp_mad = mad_send_wr->send_buf.mad;
         if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
               IB_MGMT_RMPP_FLAG_ACTIVE))
                 return IB_RMPP_RESULT_UNHANDLED;
@@ -863,7 +861,7 @@ int ib_send_rmpp_mad(struct ib_mad_send_wr_private *mad_send_wr)
 
         mad_send_wr->total_seg = (total_len - mad_send_wr->data_offset) /
                         (sizeof(struct ib_rmpp_mad) - mad_send_wr->data_offset);
-        mad_send_wr->pad = total_len - offsetof(struct ib_rmpp_mad, data) -
+        mad_send_wr->pad = total_len - IB_MGMT_RMPP_HDR -
                            be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);
 
         /* We need to wait for the final ACK even if there isn't a response */
@@ -878,23 +876,15 @@ int ib_process_rmpp_send_wc(struct ib_mad_send_wr_private *mad_send_wr,
                             struct ib_mad_send_wc *mad_send_wc)
 {
         struct ib_rmpp_mad *rmpp_mad;
-        struct ib_mad_send_buf *msg;
         int ret;
 
-        rmpp_mad = (struct ib_rmpp_mad *)mad_send_wr->send_wr.wr.ud.mad_hdr;
+        rmpp_mad = mad_send_wr->send_buf.mad;
         if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
               IB_MGMT_RMPP_FLAG_ACTIVE))
                 return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */
 
-        if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) {
-                msg = (struct ib_mad_send_buf *) (unsigned long)
-                      mad_send_wc->wr_id;
-                if (rmpp_mad->rmpp_hdr.rmpp_type == IB_MGMT_RMPP_TYPE_ACK)
-                        ib_free_send_mad(msg);
-                else
-                        free_msg(msg);
+        if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA)
                 return IB_RMPP_RESULT_INTERNAL;  /* ACK, STOP, or ABORT */
-        }
 
         if (mad_send_wc->status != IB_WC_SUCCESS ||
             mad_send_wr->status != IB_WC_SUCCESS)
@@ -905,7 +895,7 @@ int ib_process_rmpp_send_wc(struct ib_mad_send_wr_private *mad_send_wr,
 
         if (mad_send_wr->last_ack == mad_send_wr->total_seg) {
                 mad_send_wr->timeout =
-                        msecs_to_jiffies(mad_send_wr->send_wr.wr.ud.timeout_ms);
+                        msecs_to_jiffies(mad_send_wr->send_buf.timeout_ms);
                 return IB_RMPP_RESULT_PROCESSED; /* Send done */
         }
 
@@ -926,7 +916,7 @@ int ib_retry_rmpp(struct ib_mad_send_wr_private *mad_send_wr)
         struct ib_rmpp_mad *rmpp_mad;
         int ret;
 
-        rmpp_mad = (struct ib_rmpp_mad *)mad_send_wr->send_wr.wr.ud.mad_hdr;
+        rmpp_mad = mad_send_wr->send_buf.mad;
         if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
               IB_MGMT_RMPP_FLAG_ACTIVE))
                 return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */