Merge branch 'mlx4-next'

Tariq Toukan says:

====================
mlx4 misc cleanups and improvements

This patchset contains some cleanups and improvements from the team
to the mlx4 Eth and core drivers.

Series generated against net-next commit:
5a7a5555a362 'net sched: stylistic cleanups'
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/mellanox/mlx4/cmd.c b/drivers/net/ethernet/mellanox/mlx4/cmd.c
index f04a423..a58d96c 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx4/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cmd.c
@@ -785,17 +785,23 @@ int __mlx4_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
                return mlx4_cmd_reset_flow(dev, op, op_modifier, -EIO);
 
        if (!mlx4_is_mfunc(dev) || (native && mlx4_is_master(dev))) {
+               int ret;
+
                if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
                        return mlx4_internal_err_ret_value(dev, op,
                                                          op_modifier);
+               down_read(&mlx4_priv(dev)->cmd.switch_sem);
                if (mlx4_priv(dev)->cmd.use_events)
-                       return mlx4_cmd_wait(dev, in_param, out_param,
-                                            out_is_imm, in_modifier,
-                                            op_modifier, op, timeout);
+                       ret = mlx4_cmd_wait(dev, in_param, out_param,
+                                           out_is_imm, in_modifier,
+                                           op_modifier, op, timeout);
                else
-                       return mlx4_cmd_poll(dev, in_param, out_param,
-                                            out_is_imm, in_modifier,
-                                            op_modifier, op, timeout);
+                       ret = mlx4_cmd_poll(dev, in_param, out_param,
+                                           out_is_imm, in_modifier,
+                                           op_modifier, op, timeout);
+
+               up_read(&mlx4_priv(dev)->cmd.switch_sem);
+               return ret;
        }
        return mlx4_slave_cmd(dev, in_param, out_param, out_is_imm,
                              in_modifier, op_modifier, op, timeout);
@@ -2454,6 +2460,7 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
        int flags = 0;
 
        if (!priv->cmd.initialized) {
+               init_rwsem(&priv->cmd.switch_sem);
                mutex_init(&priv->cmd.slave_cmd_mutex);
                sema_init(&priv->cmd.poll_sem, 1);
                priv->cmd.use_events = 0;
@@ -2583,6 +2590,7 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
        if (!priv->cmd.context)
                return -ENOMEM;
 
+       down_write(&priv->cmd.switch_sem);
        for (i = 0; i < priv->cmd.max_cmds; ++i) {
                priv->cmd.context[i].token = i;
                priv->cmd.context[i].next  = i + 1;
@@ -2606,6 +2614,7 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
 
        down(&priv->cmd.poll_sem);
        priv->cmd.use_events = 1;
+       up_write(&priv->cmd.switch_sem);
 
        return err;
 }
@@ -2618,6 +2627,7 @@ void mlx4_cmd_use_polling(struct mlx4_dev *dev)
        struct mlx4_priv *priv = mlx4_priv(dev);
        int i;
 
+       down_write(&priv->cmd.switch_sem);
        priv->cmd.use_events = 0;
 
        for (i = 0; i < priv->cmd.max_cmds; ++i)
@@ -2626,6 +2636,7 @@ void mlx4_cmd_use_polling(struct mlx4_dev *dev)
        kfree(priv->cmd.context);
 
        up(&priv->cmd.poll_sem);
+       up_write(&priv->cmd.switch_sem);
 }
 
 struct mlx4_cmd_mailbox *mlx4_alloc_cmd_mailbox(struct mlx4_dev *dev)

diff --git a/drivers/net/ethernet/mellanox/mlx4/en_rx.c b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
index c46355b..f2e8bed 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx4/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
@@ -72,7 +72,7 @@ static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
        }
        dma = dma_map_page(priv->ddev, page, 0, PAGE_SIZE << order,
                           frag_info->dma_dir);
-       if (dma_mapping_error(priv->ddev, dma)) {
+       if (unlikely(dma_mapping_error(priv->ddev, dma))) {
                put_page(page);
                return -ENOMEM;
        }
@@ -108,7 +108,8 @@ static int mlx4_en_alloc_frags(struct mlx4_en_priv *priv,
                    ring_alloc[i].page_size)
                        continue;
 
-               if (mlx4_alloc_pages(priv, &page_alloc[i], frag_info, gfp))
+               if (unlikely(mlx4_alloc_pages(priv, &page_alloc[i],
+                                             frag_info, gfp)))
                        goto out;
        }
 
@@ -585,7 +586,7 @@ static int mlx4_en_complete_rx_desc(struct mlx4_en_priv *priv,
                frag_info = &priv->frag_info[nr];
                if (length <= frag_info->frag_prefix_size)
                        break;
-               if (!frags[nr].page)
+               if (unlikely(!frags[nr].page))
                        goto fail;
 
                dma = be64_to_cpu(rx_desc->data[nr].addr);
@@ -625,7 +626,7 @@ static struct sk_buff *mlx4_en_rx_skb(struct mlx4_en_priv *priv,
        dma_addr_t dma;
 
        skb = netdev_alloc_skb(priv->dev, SMALL_PACKET_SIZE + NET_IP_ALIGN);
-       if (!skb) {
+       if (unlikely(!skb)) {
                en_dbg(RX_ERR, priv, "Failed allocating skb\n");
                return NULL;
        }
@@ -736,7 +737,8 @@ static int get_fixed_ipv6_csum(__wsum hw_checksum, struct sk_buff *skb,
 {
        __wsum csum_pseudo_hdr = 0;
 
-       if (ipv6h->nexthdr == IPPROTO_FRAGMENT || ipv6h->nexthdr == IPPROTO_HOPOPTS)
+       if (unlikely(ipv6h->nexthdr == IPPROTO_FRAGMENT ||
+                    ipv6h->nexthdr == IPPROTO_HOPOPTS))
                return -1;
        hw_checksum = csum_add(hw_checksum, (__force __wsum)htons(ipv6h->nexthdr));
 
@@ -769,7 +771,7 @@ static int check_csum(struct mlx4_cqe *cqe, struct sk_buff *skb, void *va,
                get_fixed_ipv4_csum(hw_checksum, skb, hdr);
 #if IS_ENABLED(CONFIG_IPV6)
        else if (cqe->status & cpu_to_be16(MLX4_CQE_STATUS_IPV6))
-               if (get_fixed_ipv6_csum(hw_checksum, skb, hdr))
+               if (unlikely(get_fixed_ipv6_csum(hw_checksum, skb, hdr)))
                        return -1;
 #endif
        return 0;
@@ -796,10 +798,10 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
        u64 timestamp;
        bool l2_tunnel;
 
-       if (!priv->port_up)
+       if (unlikely(!priv->port_up))
                return 0;
 
-       if (budget <= 0)
+       if (unlikely(budget <= 0))
                return polled;
 
        /* Protect accesses to: ring->xdp_prog, priv->mac_hash list */
@@ -902,9 +904,9 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                        case XDP_PASS:
                                break;
                        case XDP_TX:
-                               if (!mlx4_en_xmit_frame(frags, dev,
+                               if (likely(!mlx4_en_xmit_frame(frags, dev,
                                                        length, tx_index,
-                                                       &doorbell_pending))
+                                                       &doorbell_pending)))
                                        goto consumed;
                                goto xdp_drop; /* Drop on xmit failure */
                        default:
@@ -912,7 +914,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                        case XDP_ABORTED:
                        case XDP_DROP:
 xdp_drop:
-                               if (mlx4_en_rx_recycle(ring, frags))
+                               if (likely(mlx4_en_rx_recycle(ring, frags)))
                                        goto consumed;
                                goto next;
                        }
@@ -1016,12 +1018,12 @@ xdp_drop:
 
                /* GRO not possible, complete processing here */
                skb = mlx4_en_rx_skb(priv, rx_desc, frags, length);
-               if (!skb) {
+               if (unlikely(!skb)) {
                        ring->dropped++;
                        goto next;
                }
 
-                if (unlikely(priv->validate_loopback)) {
+               if (unlikely(priv->validate_loopback)) {
                        validate_loopback(priv, skb);
                        goto next;
                }

diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4.h b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
index c9d7fc5..c128ba3 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
@@ -46,6 +46,7 @@
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <net/devlink.h>
+#include <linux/rwsem.h>
 
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/driver.h>
@@ -627,6 +628,7 @@ struct mlx4_cmd {
        struct mutex            slave_cmd_mutex;
        struct semaphore        poll_sem;
        struct semaphore        event_sem;
+       struct rw_semaphore     switch_sem;
        int                     max_cmds;
        spinlock_t              context_lock;
        int                     free_head;

diff --git a/drivers/net/ethernet/mellanox/mlx4/srq.c b/drivers/net/ethernet/mellanox/mlx4/srq.c
index 6714662..f44d089 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx4/srq.c
+++ b/drivers/net/ethernet/mellanox/mlx4/srq.c
@@ -45,15 +45,12 @@ void mlx4_srq_event(struct mlx4_dev *dev, u32 srqn, int event_type)
        struct mlx4_srq_table *srq_table = &mlx4_priv(dev)->srq_table;
        struct mlx4_srq *srq;
 
-       spin_lock(&srq_table->lock);
-
+       rcu_read_lock();
        srq = radix_tree_lookup(&srq_table->tree, srqn & (dev->caps.num_srqs - 1));
+       rcu_read_unlock();
        if (srq)
                atomic_inc(&srq->refcount);
-
-       spin_unlock(&srq_table->lock);
-
-       if (!srq) {
+       else {
                mlx4_warn(dev, "Async event for bogus SRQ %08x\n", srqn);
                return;
        }
@@ -301,12 +298,11 @@ struct mlx4_srq *mlx4_srq_lookup(struct mlx4_dev *dev, u32 srqn)
 {
        struct mlx4_srq_table *srq_table = &mlx4_priv(dev)->srq_table;
        struct mlx4_srq *srq;
-       unsigned long flags;
 
-       spin_lock_irqsave(&srq_table->lock, flags);
+       rcu_read_lock();
        srq = radix_tree_lookup(&srq_table->tree,
                                srqn & (dev->caps.num_srqs - 1));
-       spin_unlock_irqrestore(&srq_table->lock, flags);
+       rcu_read_unlock();
 
        return srq;
 }