4 files changed, 154 insertions, 113 deletions

diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h
index 474aa214ab57..0b8a79d53a00 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib.h
+++ b/drivers/infiniband/ulp/ipoib/ipoib.h
@@ -336,6 +336,8 @@ static inline void ipoib_unregister_debugfs(void) { }
 extern int ipoib_sendq_size;
 extern int ipoib_recvq_size;
 
+extern struct ib_sa_client ipoib_sa_client;
+
 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
 extern int ipoib_debug_level;
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
index 5033666b1481..f426a69d9a43 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
@@ -169,117 +169,129 @@ static int ipoib_ib_post_receives(struct net_device *dev)
         return 0;
 }
 
-static void ipoib_ib_handle_wc(struct net_device *dev,
-                               struct ib_wc *wc)
+static void ipoib_ib_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
-        unsigned int wr_id = wc->wr_id;
+        unsigned int wr_id = wc->wr_id & ~IPOIB_OP_RECV;
+        struct sk_buff *skb;
+        dma_addr_t addr;
 
-        ipoib_dbg_data(priv, "called: id %d, op %d, status: %d\n",
+        ipoib_dbg_data(priv, "recv completion: id %d, op %d, status: %d\n",
                        wr_id, wc->opcode, wc->status);
 
-        if (wr_id & IPOIB_OP_RECV) {
-                wr_id &= ~IPOIB_OP_RECV;
-
-                if (wr_id < ipoib_recvq_size) {
-                        struct sk_buff *skb  = priv->rx_ring[wr_id].skb;
-                        dma_addr_t      addr = priv->rx_ring[wr_id].mapping;
-
-                        if (unlikely(wc->status != IB_WC_SUCCESS)) {
-                                if (wc->status != IB_WC_WR_FLUSH_ERR)
-                                        ipoib_warn(priv, "failed recv event "
-                                                   "(status=%d, wrid=%d vend_err %x)\n",
-                                                   wc->status, wr_id, wc->vendor_err);
-                                dma_unmap_single(priv->ca->dma_device, addr,
-                                                 IPOIB_BUF_SIZE, DMA_FROM_DEVICE);
-                                dev_kfree_skb_any(skb);
-                                priv->rx_ring[wr_id].skb = NULL;
-                                return;
-                        }
+        if (unlikely(wr_id >= ipoib_recvq_size)) {
+                ipoib_warn(priv, "recv completion event with wrid %d (> %d)\n",
+                           wr_id, ipoib_recvq_size);
+                return;
+        }
 
-                        /*
-                         * If we can't allocate a new RX buffer, dump
-                         * this packet and reuse the old buffer.
-                         */
-                        if (unlikely(ipoib_alloc_rx_skb(dev, wr_id))) {
-                                ++priv->stats.rx_dropped;
-                                goto repost;
-                        }
+        skb  = priv->rx_ring[wr_id].skb;
+        addr = priv->rx_ring[wr_id].mapping;
 
-                        ipoib_dbg_data(priv, "received %d bytes, SLID 0x%04x\n",
-                                       wc->byte_len, wc->slid);
+        if (unlikely(wc->status != IB_WC_SUCCESS)) {
+                if (wc->status != IB_WC_WR_FLUSH_ERR)
+                        ipoib_warn(priv, "failed recv event "
+                                   "(status=%d, wrid=%d vend_err %x)\n",
+                                   wc->status, wr_id, wc->vendor_err);
+                dma_unmap_single(priv->ca->dma_device, addr,
+                                 IPOIB_BUF_SIZE, DMA_FROM_DEVICE);
+                dev_kfree_skb_any(skb);
+                priv->rx_ring[wr_id].skb = NULL;
+                return;
+        }
 
-                        dma_unmap_single(priv->ca->dma_device, addr,
-                                         IPOIB_BUF_SIZE, DMA_FROM_DEVICE);
+        /*
+         * If we can't allocate a new RX buffer, dump
+         * this packet and reuse the old buffer.
+         */
+        if (unlikely(ipoib_alloc_rx_skb(dev, wr_id))) {
+                ++priv->stats.rx_dropped;
+                goto repost;
+        }
 
-                        skb_put(skb, wc->byte_len);
-                        skb_pull(skb, IB_GRH_BYTES);
+        ipoib_dbg_data(priv, "received %d bytes, SLID 0x%04x\n",
+                       wc->byte_len, wc->slid);
 
-                        if (wc->slid != priv->local_lid ||
-                            wc->src_qp != priv->qp->qp_num) {
-                                skb->protocol = ((struct ipoib_header *) skb->data)->proto;
-                                skb->mac.raw = skb->data;
-                                skb_pull(skb, IPOIB_ENCAP_LEN);
+        dma_unmap_single(priv->ca->dma_device, addr,
+                         IPOIB_BUF_SIZE, DMA_FROM_DEVICE);
 
-                                dev->last_rx = jiffies;
-                                ++priv->stats.rx_packets;
-                                priv->stats.rx_bytes += skb->len;
+        skb_put(skb, wc->byte_len);
+        skb_pull(skb, IB_GRH_BYTES);
 
-                                skb->dev = dev;
-                                /* XXX get correct PACKET_ type here */
-                                skb->pkt_type = PACKET_HOST;
-                                netif_rx_ni(skb);
-                        } else {
-                                ipoib_dbg_data(priv, "dropping loopback packet\n");
-                                dev_kfree_skb_any(skb);
-                        }
+        if (wc->slid != priv->local_lid ||
+            wc->src_qp != priv->qp->qp_num) {
+                skb->protocol = ((struct ipoib_header *) skb->data)->proto;
+                skb->mac.raw = skb->data;
+                skb_pull(skb, IPOIB_ENCAP_LEN);
 
-                repost:
-                        if (unlikely(ipoib_ib_post_receive(dev, wr_id)))
-                                ipoib_warn(priv, "ipoib_ib_post_receive failed "
-                                           "for buf %d\n", wr_id);
-                } else
-                        ipoib_warn(priv, "completion event with wrid %d\n",
-                                   wr_id);
+                dev->last_rx = jiffies;
+                ++priv->stats.rx_packets;
+                priv->stats.rx_bytes += skb->len;
 
+                skb->dev = dev;
+                /* XXX get correct PACKET_ type here */
+                skb->pkt_type = PACKET_HOST;
+                netif_rx_ni(skb);
         } else {
-                struct ipoib_tx_buf *tx_req;
-                unsigned long flags;
+                ipoib_dbg_data(priv, "dropping loopback packet\n");
+                dev_kfree_skb_any(skb);
+        }
 
-                if (wr_id >= ipoib_sendq_size) {
-                        ipoib_warn(priv, "completion event with wrid %d (> %d)\n",
-                                   wr_id, ipoib_sendq_size);
-                        return;
-                }
+repost:
+        if (unlikely(ipoib_ib_post_receive(dev, wr_id)))
+                ipoib_warn(priv, "ipoib_ib_post_receive failed "
+                           "for buf %d\n", wr_id);
+}
 
-                ipoib_dbg_data(priv, "send complete, wrid %d\n", wr_id);
+static void ipoib_ib_handle_tx_wc(struct net_device *dev, struct ib_wc *wc)
+{
+        struct ipoib_dev_priv *priv = netdev_priv(dev);
+        unsigned int wr_id = wc->wr_id;
+        struct ipoib_tx_buf *tx_req;
+        unsigned long flags;
 
-                tx_req = &priv->tx_ring[wr_id];
+        ipoib_dbg_data(priv, "send completion: id %d, op %d, status: %d\n",
+                       wr_id, wc->opcode, wc->status);
 
-                dma_unmap_single(priv->ca->dma_device,
-                                 pci_unmap_addr(tx_req, mapping),
-                                 tx_req->skb->len,
-                                 DMA_TO_DEVICE);
+        if (unlikely(wr_id >= ipoib_sendq_size)) {
+                ipoib_warn(priv, "send completion event with wrid %d (> %d)\n",
+                           wr_id, ipoib_sendq_size);
+                return;
+        }
 
-                ++priv->stats.tx_packets;
-                priv->stats.tx_bytes += tx_req->skb->len;
+        tx_req = &priv->tx_ring[wr_id];
 
-                dev_kfree_skb_any(tx_req->skb);
+        dma_unmap_single(priv->ca->dma_device,
+                         pci_unmap_addr(tx_req, mapping),
+                         tx_req->skb->len,
+                         DMA_TO_DEVICE);
 
-                spin_lock_irqsave(&priv->tx_lock, flags);
-                ++priv->tx_tail;
-                if (netif_queue_stopped(dev) &&
-                    test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags) &&
-                    priv->tx_head - priv->tx_tail <= ipoib_sendq_size >> 1)
-                        netif_wake_queue(dev);
-                spin_unlock_irqrestore(&priv->tx_lock, flags);
+        ++priv->stats.tx_packets;
+        priv->stats.tx_bytes += tx_req->skb->len;
 
-                if (wc->status != IB_WC_SUCCESS &&
-                    wc->status != IB_WC_WR_FLUSH_ERR)
-                        ipoib_warn(priv, "failed send event "
-                                   "(status=%d, wrid=%d vend_err %x)\n",
-                                   wc->status, wr_id, wc->vendor_err);
-        }
+        dev_kfree_skb_any(tx_req->skb);
+
+        spin_lock_irqsave(&priv->tx_lock, flags);
+        ++priv->tx_tail;
+        if (netif_queue_stopped(dev) &&
+            test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags) &&
+            priv->tx_head - priv->tx_tail <= ipoib_sendq_size >> 1)
+                netif_wake_queue(dev);
+        spin_unlock_irqrestore(&priv->tx_lock, flags);
+
+        if (wc->status != IB_WC_SUCCESS &&
+            wc->status != IB_WC_WR_FLUSH_ERR)
+                ipoib_warn(priv, "failed send event "
+                           "(status=%d, wrid=%d vend_err %x)\n",
+                           wc->status, wr_id, wc->vendor_err);
+}
+
+static void ipoib_ib_handle_wc(struct net_device *dev, struct ib_wc *wc)
+{
+        if (wc->wr_id & IPOIB_OP_RECV)
+                ipoib_ib_handle_rx_wc(dev, wc);
+        else
+                ipoib_ib_handle_tx_wc(dev, wc);
 }
 
 void ipoib_ib_completion(struct ib_cq *cq, void *dev_ptr)
@@ -320,7 +332,7 @@ void ipoib_send(struct net_device *dev, struct sk_buff *skb,
         struct ipoib_tx_buf *tx_req;
         dma_addr_t addr;
 
-        if (skb->len > dev->mtu + INFINIBAND_ALEN) {
+        if (unlikely(skb->len > dev->mtu + INFINIBAND_ALEN)) {
                 ipoib_warn(priv, "packet len %d (> %d) too long to send, dropping\n",
                            skb->len, dev->mtu + INFINIBAND_ALEN);
                 ++priv->stats.tx_dropped;
@@ -619,8 +631,10 @@ void ipoib_ib_dev_flush(void *_dev)
          * The device could have been brought down between the start and when
          * we get here, don't bring it back up if it's not configured up
          */
-        if (test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags))
+        if (test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags)) {
                 ipoib_ib_dev_up(dev);
+                ipoib_mcast_restart_task(dev);
+        }
 
         mutex_lock(&priv->vlan_mutex);
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index cf71d2a5515c..1eaf00e9862c 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -40,7 +40,6 @@
 
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/vmalloc.h>
 #include <linux/kernel.h>
 
 #include <linux/if_arp.h>       /* For ARPHRD_xxx */
@@ -82,6 +81,8 @@ static const u8 ipv4_bcast_addr[] = {
 
 struct workqueue_struct *ipoib_workqueue;
 
+struct ib_sa_client ipoib_sa_client;
+
 static void ipoib_add_one(struct ib_device *device);
 static void ipoib_remove_one(struct ib_device *device);
 
@@ -336,7 +337,8 @@ void ipoib_flush_paths(struct net_device *dev)
         struct ipoib_path *path, *tp;
         LIST_HEAD(remove_list);
 
-        spin_lock_irq(&priv->lock);
+        spin_lock_irq(&priv->tx_lock);
+        spin_lock(&priv->lock);
 
         list_splice(&priv->path_list, &remove_list);
         INIT_LIST_HEAD(&priv->path_list);
@@ -347,12 +349,15 @@ void ipoib_flush_paths(struct net_device *dev)
         list_for_each_entry_safe(path, tp, &remove_list, list) {
                 if (path->query)
                         ib_sa_cancel_query(path->query_id, path->query);
-                spin_unlock_irq(&priv->lock);
+                spin_unlock(&priv->lock);
+                spin_unlock_irq(&priv->tx_lock);
                 wait_for_completion(&path->done);
                 path_free(dev, path);
-                spin_lock_irq(&priv->lock);
+                spin_lock_irq(&priv->tx_lock);
+                spin_lock(&priv->lock);
         }
-        spin_unlock_irq(&priv->lock);
+        spin_unlock(&priv->lock);
+        spin_unlock_irq(&priv->tx_lock);
 }
 
 static void path_rec_completion(int status,
@@ -459,7 +464,7 @@ static int path_rec_start(struct net_device *dev,
         init_completion(&path->done);
 
         path->query_id =
-                ib_sa_path_rec_get(priv->ca, priv->port,
+                ib_sa_path_rec_get(&ipoib_sa_client, priv->ca, priv->port,
                                    &path->pathrec,
                                    IB_SA_PATH_REC_DGID          |
                                    IB_SA_PATH_REC_SGID          |
@@ -615,7 +620,7 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct ipoib_neigh *neigh;
         unsigned long flags;
 
-        if (!spin_trylock_irqsave(&priv->tx_lock, flags))
+        if (unlikely(!spin_trylock_irqsave(&priv->tx_lock, flags)))
                 return NETDEV_TX_LOCKED;
 
         /*
@@ -628,7 +633,7 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 return NETDEV_TX_BUSY;
         }
 
-        if (skb->dst && skb->dst->neighbour) {
+        if (likely(skb->dst && skb->dst->neighbour)) {
                 if (unlikely(!*to_ipoib_neigh(skb->dst->neighbour))) {
                         ipoib_path_lookup(skb, dev);
                         goto out;
@@ -1107,13 +1112,16 @@ static void ipoib_add_one(struct ib_device *device)
         struct ipoib_dev_priv *priv;
         int s, e, p;
 
+        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
+                return;
+
         dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL);
         if (!dev_list)
                 return;
 
         INIT_LIST_HEAD(dev_list);
 
-        if (device->node_type == IB_NODE_SWITCH) {
+        if (device->node_type == RDMA_NODE_IB_SWITCH) {
                 s = 0;
                 e = 0;
         } else {
@@ -1137,6 +1145,9 @@ static void ipoib_remove_one(struct ib_device *device)
         struct ipoib_dev_priv *priv, *tmp;
         struct list_head *dev_list;
 
+        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
+                return;
+
         dev_list = ib_get_client_data(device, &ipoib_client);
 
         list_for_each_entry_safe(priv, tmp, dev_list, list) {
@@ -1181,13 +1192,16 @@ static int __init ipoib_init_module(void)
                 goto err_fs;
         }
 
+        ib_sa_register_client(&ipoib_sa_client);
+
         ret = ib_register_client(&ipoib_client);
         if (ret)
-                goto err_wq;
+                goto err_sa;
 
         return 0;
 
-err_wq:
+err_sa:
+        ib_sa_unregister_client(&ipoib_sa_client);
         destroy_workqueue(ipoib_workqueue);
 
 err_fs:
@@ -1199,6 +1213,7 @@ err_fs:
 static void __exit ipoib_cleanup_module(void)
 {
         ib_unregister_client(&ipoib_client);
+        ib_sa_unregister_client(&ipoib_sa_client);
         ipoib_unregister_debugfs();
         destroy_workqueue(ipoib_workqueue);
 }
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
index ec356ce7cdcd..3faa1820f0e9 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
@@ -361,7 +361,7 @@ static int ipoib_mcast_sendonly_join(struct ipoib_mcast *mcast)
 
         init_completion(&mcast->done);
 
-        ret = ib_sa_mcmember_rec_set(priv->ca, priv->port, &rec,
+        ret = ib_sa_mcmember_rec_set(&ipoib_sa_client, priv->ca, priv->port, &rec,
                                      IB_SA_MCMEMBER_REC_MGID            |
                                      IB_SA_MCMEMBER_REC_PORT_GID        |
                                      IB_SA_MCMEMBER_REC_PKEY            |
@@ -472,22 +472,32 @@ static void ipoib_mcast_join(struct net_device *dev, struct ipoib_mcast *mcast,
 
         if (create) {
                 comp_mask |=
-                        IB_SA_MCMEMBER_REC_QKEY         |
-                        IB_SA_MCMEMBER_REC_SL           |
-                        IB_SA_MCMEMBER_REC_FLOW_LABEL   |
-                        IB_SA_MCMEMBER_REC_TRAFFIC_CLASS;
+                        IB_SA_MCMEMBER_REC_QKEY                 |
+                        IB_SA_MCMEMBER_REC_MTU_SELECTOR         |
+                        IB_SA_MCMEMBER_REC_MTU                  |
+                        IB_SA_MCMEMBER_REC_TRAFFIC_CLASS        |
+                        IB_SA_MCMEMBER_REC_RATE_SELECTOR        |
+                        IB_SA_MCMEMBER_REC_RATE                 |
+                        IB_SA_MCMEMBER_REC_SL                   |
+                        IB_SA_MCMEMBER_REC_FLOW_LABEL           |
+                        IB_SA_MCMEMBER_REC_HOP_LIMIT;
 
                 rec.qkey          = priv->broadcast->mcmember.qkey;
+                rec.mtu_selector  = IB_SA_EQ;
+                rec.mtu           = priv->broadcast->mcmember.mtu;
+                rec.traffic_class = priv->broadcast->mcmember.traffic_class;
+                rec.rate_selector = IB_SA_EQ;
+                rec.rate          = priv->broadcast->mcmember.rate;
                 rec.sl            = priv->broadcast->mcmember.sl;
                 rec.flow_label    = priv->broadcast->mcmember.flow_label;
-                rec.traffic_class = priv->broadcast->mcmember.traffic_class;
+                rec.hop_limit     = priv->broadcast->mcmember.hop_limit;
         }
 
         init_completion(&mcast->done);
 
-        ret = ib_sa_mcmember_rec_set(priv->ca, priv->port, &rec, comp_mask,
-                                     mcast->backoff * 1000, GFP_ATOMIC,
-                                     ipoib_mcast_join_complete,
+        ret = ib_sa_mcmember_rec_set(&ipoib_sa_client, priv->ca, priv->port,
+                                     &rec, comp_mask, mcast->backoff * 1000,
+                                     GFP_ATOMIC, ipoib_mcast_join_complete,
                                      mcast, &mcast->query);
 
         if (ret < 0) {
@@ -528,7 +538,7 @@ void ipoib_mcast_join_task(void *dev_ptr)
                         priv->local_rate = attr.active_speed *
                                 ib_width_enum_to_int(attr.active_width);
                 } else
-                        ipoib_warn(priv, "ib_query_port failed\n");
+                ipoib_warn(priv, "ib_query_port failed\n");
         }
 
         if (!priv->broadcast) {
@@ -681,7 +691,7 @@ static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast)
          * Just make one shot at leaving and don't wait for a reply;
          * if we fail, too bad.
          */
-        ret = ib_sa_mcmember_rec_delete(priv->ca, priv->port, &rec,
+        ret = ib_sa_mcmember_rec_delete(&ipoib_sa_client, priv->ca, priv->port, &rec,
                                         IB_SA_MCMEMBER_REC_MGID         |
                                         IB_SA_MCMEMBER_REC_PORT_GID     |
                                         IB_SA_MCMEMBER_REC_PKEY         |
@@ -795,7 +805,7 @@ void ipoib_mcast_dev_flush(struct net_device *dev)
         }
 
         if (priv->broadcast) {
-                rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree);
+                rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree);
                 list_add_tail(&priv->broadcast->list, &remove_list);
                 priv->broadcast = NULL;
         }