Merge tag 'mlx5-updates-2020-05-09' of git://git.kernel.org/pub/scm/linux/kernel/git/saeed/linux (0d5c56a2) · Commits · 戴 / test

drivers/net/bonding/bond_alb.c

+28 −11

Original line number	Diff line number	Diff line
		@@ -1331,11 +1331,11 @@ static netdev_tx_t bond_do_alb_xmit(struct sk_buff skb, struct bonding bond,
		return bond_tx_drop(bond->dev, skb);
		}

		netdev_tx_t bond_tlb_xmit(struct sk_buff skb, struct net_device bond_dev)
		struct slave bond_xmit_tlb_slave_get(struct bonding bond,
		struct sk_buff *skb)
		{
		struct bonding *bond = netdev_priv(bond_dev);
		struct ethhdr *eth_data;
		struct slave *tx_slave = NULL;
		struct ethhdr *eth_data;
		u32 hash_index;

		skb_reset_mac_header(skb);
		@@ -1357,7 +1357,7 @@ netdev_tx_t bond_tlb_xmit(struct sk_buff skb, struct net_device bond_dev)
		struct bond_up_slave *slaves;
		unsigned int count;

		slaves = rcu_dereference(bond->slave_arr);
		slaves = rcu_dereference(bond->usable_slaves);
		count = slaves ? READ_ONCE(slaves->count) : 0;
		if (likely(count))
		tx_slave = slaves->arr[hash_index %
		@@ -1366,20 +1366,29 @@ netdev_tx_t bond_tlb_xmit(struct sk_buff skb, struct net_device bond_dev)
		break;
		}
		}
		return bond_do_alb_xmit(skb, bond, tx_slave);
		return tx_slave;
		}

		netdev_tx_t bond_alb_xmit(struct sk_buff skb, struct net_device bond_dev)
		netdev_tx_t bond_tlb_xmit(struct sk_buff skb, struct net_device bond_dev)
		{
		struct bonding *bond = netdev_priv(bond_dev);
		struct ethhdr *eth_data;
		struct slave *tx_slave;

		tx_slave = bond_xmit_tlb_slave_get(bond, skb);
		return bond_do_alb_xmit(skb, bond, tx_slave);
		}

		struct slave bond_xmit_alb_slave_get(struct bonding bond,
		struct sk_buff *skb)
		{
		struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
		struct slave *tx_slave = NULL;
		static const __be32 ip_bcast = htonl(0xffffffff);
		int hash_size = 0;
		struct slave *tx_slave = NULL;
		const u8 *hash_start = NULL;
		bool do_tx_balance = true;
		struct ethhdr *eth_data;
		u32 hash_index = 0;
		const u8 *hash_start = NULL;
		int hash_size = 0;

		skb_reset_mac_header(skb);
		eth_data = eth_hdr(skb);
		@@ -1491,14 +1500,22 @@ netdev_tx_t bond_alb_xmit(struct sk_buff skb, struct net_device bond_dev)
		struct bond_up_slave *slaves;
		unsigned int count;

		slaves = rcu_dereference(bond->slave_arr);
		slaves = rcu_dereference(bond->usable_slaves);
		count = slaves ? READ_ONCE(slaves->count) : 0;
		if (likely(count))
		tx_slave = slaves->arr[bond_xmit_hash(bond, skb) %
		count];
		}
		}
		return tx_slave;
		}

		netdev_tx_t bond_alb_xmit(struct sk_buff skb, struct net_device bond_dev)
		{
		struct bonding *bond = netdev_priv(bond_dev);
		struct slave *tx_slave = NULL;

		tx_slave = bond_xmit_alb_slave_get(bond, skb);
		return bond_do_alb_xmit(skb, bond, tx_slave);
		}

drivers/net/bonding/bond_main.c

+186 −66

Original line number	Diff line number	Diff line
		@@ -3923,16 +3923,15 @@ unwind:
		}

		/**
		* bond_xmit_slave_id - transmit skb through slave with slave_id
		* bond_get_slave_by_id - get xmit slave with slave_id
		* @bond: bonding device that is transmitting
		* @skb: buffer to transmit
		* @slave_id: slave id up to slave_cnt-1 through which to transmit
		*
		* This function tries to transmit through slave with slave_id but in case
		* This function tries to get slave with slave_id but in case
		* it fails, it tries to find the first available slave for transmission.
		* The skb is consumed in all cases, thus the function is void.
		*/
		static netdev_tx_t bond_xmit_slave_id(struct bonding bond, struct sk_buff skb, int slave_id)
		static struct slave bond_get_slave_by_id(struct bonding bond,
		int slave_id)
		{
		struct list_head *iter;
		struct slave *slave;
		@@ -3942,7 +3941,7 @@ static netdev_tx_t bond_xmit_slave_id(struct bonding bond, struct sk_buff skb,
		bond_for_each_slave_rcu(bond, slave, iter) {
		if (--i < 0) {
		if (bond_slave_can_tx(slave))
		return bond_dev_queue_xmit(bond, skb, slave->dev);
		return slave;
		}
		}

		@@ -3952,10 +3951,10 @@ static netdev_tx_t bond_xmit_slave_id(struct bonding bond, struct sk_buff skb,
		if (--i < 0)
		break;
		if (bond_slave_can_tx(slave))
		return bond_dev_queue_xmit(bond, skb, slave->dev);
		return slave;
		}
		/* no slave that can tx has been found */
		return bond_tx_drop(bond->dev, skb);
		return NULL;
		}

		/**
		@@ -3991,10 +3990,9 @@ static u32 bond_rr_gen_slave_id(struct bonding *bond)
		return slave_id;
		}

		static netdev_tx_t bond_xmit_roundrobin(struct sk_buff *skb,
		struct net_device *bond_dev)
		static struct slave bond_xmit_roundrobin_slave_get(struct bonding bond,
		struct sk_buff *skb)
		{
		struct bonding *bond = netdev_priv(bond_dev);
		struct slave *slave;
		int slave_cnt;
		u32 slave_id;
		@@ -4016,20 +4014,39 @@ static netdev_tx_t bond_xmit_roundrobin(struct sk_buff *skb,
		if (iph->protocol == IPPROTO_IGMP) {
		slave = rcu_dereference(bond->curr_active_slave);
		if (slave)
		return bond_dev_queue_xmit(bond, skb, slave->dev);
		return bond_xmit_slave_id(bond, skb, 0);
		return slave;
		return bond_get_slave_by_id(bond, 0);
		}
		}

		non_igmp:
		slave_cnt = READ_ONCE(bond->slave_cnt);
		if (likely(slave_cnt)) {
		slave_id = bond_rr_gen_slave_id(bond);
		return bond_xmit_slave_id(bond, skb, slave_id % slave_cnt);
		slave_id = bond_rr_gen_slave_id(bond) % slave_cnt;
		return bond_get_slave_by_id(bond, slave_id);
		}
		return NULL;
		}

		static netdev_tx_t bond_xmit_roundrobin(struct sk_buff *skb,
		struct net_device *bond_dev)
		{
		struct bonding *bond = netdev_priv(bond_dev);
		struct slave *slave;

		slave = bond_xmit_roundrobin_slave_get(bond, skb);
		if (likely(slave))
		return bond_dev_queue_xmit(bond, skb, slave->dev);

		return bond_tx_drop(bond_dev, skb);
		}

		static struct slave bond_xmit_activebackup_slave_get(struct bonding bond,
		struct sk_buff *skb)
		{
		return rcu_dereference(bond->curr_active_slave);
		}

		/* In active-backup mode, we know that bond->curr_active_slave is always valid if
		* the bond has a usable interface.
		*/
		@@ -4039,7 +4056,7 @@ static netdev_tx_t bond_xmit_activebackup(struct sk_buff *skb,
		struct bonding *bond = netdev_priv(bond_dev);
		struct slave *slave;

		slave = rcu_dereference(bond->curr_active_slave);
		slave = bond_xmit_activebackup_slave_get(bond, skb);
		if (slave)
		return bond_dev_queue_xmit(bond, skb, slave->dev);

		@@ -4077,6 +4094,61 @@ err:
		bond_slave_arr_work_rearm(bond, 1);
		}

		static void bond_skip_slave(struct bond_up_slave *slaves,
		struct slave *skipslave)
		{
		int idx;

		/* Rare situation where caller has asked to skip a specific
		* slave but allocation failed (most likely!). BTW this is
		* only possible when the call is initiated from
		* __bond_release_one(). In this situation; overwrite the
		* skipslave entry in the array with the last entry from the
		* array to avoid a situation where the xmit path may choose
		* this to-be-skipped slave to send a packet out.
		*/
		for (idx = 0; slaves && idx < slaves->count; idx++) {
		if (skipslave == slaves->arr[idx]) {
		slaves->arr[idx] =
		slaves->arr[slaves->count - 1];
		slaves->count--;
		break;
		}
		}
		}

		static void bond_set_slave_arr(struct bonding *bond,
		struct bond_up_slave *usable_slaves,
		struct bond_up_slave *all_slaves)
		{
		struct bond_up_slave usable, all;

		usable = rtnl_dereference(bond->usable_slaves);
		rcu_assign_pointer(bond->usable_slaves, usable_slaves);
		kfree_rcu(usable, rcu);

		all = rtnl_dereference(bond->all_slaves);
		rcu_assign_pointer(bond->all_slaves, all_slaves);
		kfree_rcu(all, rcu);
		}

		static void bond_reset_slave_arr(struct bonding *bond)
		{
		struct bond_up_slave usable, all;

		usable = rtnl_dereference(bond->usable_slaves);
		if (usable) {
		RCU_INIT_POINTER(bond->usable_slaves, NULL);
		kfree_rcu(usable, rcu);
		}

		all = rtnl_dereference(bond->all_slaves);
		if (all) {
		RCU_INIT_POINTER(bond->all_slaves, NULL);
		kfree_rcu(all, rcu);
		}
		}

		/* Build the usable slaves array in control path for modes that use xmit-hash
		* to determine the slave interface -
		* (a) BOND_MODE_8023AD
		@@ -4087,9 +4159,9 @@ err:
		*/
		int bond_update_slave_arr(struct bonding bond, struct slave skipslave)
		{
		struct bond_up_slave usable_slaves = NULL, all_slaves = NULL;
		struct slave *slave;
		struct list_head *iter;
		struct bond_up_slave new_arr, old_arr;
		int agg_id = 0;
		int ret = 0;

		@@ -4097,11 +4169,12 @@ int bond_update_slave_arr(struct bonding bond, struct slave skipslave)
		WARN_ON(lockdep_is_held(&bond->mode_lock));
		#endif

		new_arr = kzalloc(offsetof(struct bond_up_slave, arr[bond->slave_cnt]),
		GFP_KERNEL);
		if (!new_arr) {
		usable_slaves = kzalloc(struct_size(usable_slaves, arr,
		bond->slave_cnt), GFP_KERNEL);
		all_slaves = kzalloc(struct_size(all_slaves, arr,
		bond->slave_cnt), GFP_KERNEL);
		if (!usable_slaves \|\| !all_slaves) {
		ret = -ENOMEM;
		pr_err("Failed to build slave-array.\n");
		goto out;
		}
		if (BOND_MODE(bond) == BOND_MODE_8023AD) {
		@@ -4109,20 +4182,19 @@ int bond_update_slave_arr(struct bonding bond, struct slave skipslave)

		if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
		pr_debug("bond_3ad_get_active_agg_info failed\n");
		kfree_rcu(new_arr, rcu);
		/* No active aggragator means it's not safe to use
		* the previous array.
		*/
		old_arr = rtnl_dereference(bond->slave_arr);
		if (old_arr) {
		RCU_INIT_POINTER(bond->slave_arr, NULL);
		kfree_rcu(old_arr, rcu);
		}
		bond_reset_slave_arr(bond);
		goto out;
		}
		agg_id = ad_info.aggregator_id;
		}
		bond_for_each_slave(bond, slave, iter) {
		if (skipslave == slave)
		continue;

		all_slaves->arr[all_slaves->count++] = slave;
		if (BOND_MODE(bond) == BOND_MODE_8023AD) {
		struct aggregator *agg;

		@@ -4132,44 +4204,45 @@ int bond_update_slave_arr(struct bonding bond, struct slave skipslave)
		}
		if (!bond_slave_can_tx(slave))
		continue;
		if (skipslave == slave)
		continue;

		slave_dbg(bond->dev, slave->dev, "Adding slave to tx hash array[%d]\n",
		new_arr->count);
		usable_slaves->count);

		new_arr->arr[new_arr->count++] = slave;
		usable_slaves->arr[usable_slaves->count++] = slave;
		}

		old_arr = rtnl_dereference(bond->slave_arr);
		rcu_assign_pointer(bond->slave_arr, new_arr);
		if (old_arr)
		kfree_rcu(old_arr, rcu);
		bond_set_slave_arr(bond, usable_slaves, all_slaves);
		return ret;
		out:
		if (ret != 0 && skipslave) {
		int idx;

		/* Rare situation where caller has asked to skip a specific
		* slave but allocation failed (most likely!). BTW this is
		* only possible when the call is initiated from
		* __bond_release_one(). In this situation; overwrite the
		* skipslave entry in the array with the last entry from the
		* array to avoid a situation where the xmit path may choose
		* this to-be-skipped slave to send a packet out.
		*/
		old_arr = rtnl_dereference(bond->slave_arr);
		for (idx = 0; old_arr != NULL && idx < old_arr->count; idx++) {
		if (skipslave == old_arr->arr[idx]) {
		old_arr->arr[idx] =
		old_arr->arr[old_arr->count-1];
		old_arr->count--;
		break;
		}
		}
		bond_skip_slave(rtnl_dereference(bond->all_slaves),
		skipslave);
		bond_skip_slave(rtnl_dereference(bond->usable_slaves),
		skipslave);
		}
		kfree_rcu(all_slaves, rcu);
		kfree_rcu(usable_slaves, rcu);

		return ret;
		}

		static struct slave bond_xmit_3ad_xor_slave_get(struct bonding bond,
		struct sk_buff *skb,
		struct bond_up_slave *slaves)
		{
		struct slave *slave;
		unsigned int count;
		u32 hash;

		hash = bond_xmit_hash(bond, skb);
		count = slaves ? READ_ONCE(slaves->count) : 0;
		if (unlikely(!count))
		return NULL;

		slave = slaves->arr[hash % count];
		return slave;
		}

		/* Use this Xmit function for 3AD as well as XOR modes. The current
		* usable slave array is formed in the control path. The xmit function
		* just calculates hash and sends the packet out.
		@@ -4178,16 +4251,14 @@ static netdev_tx_t bond_3ad_xor_xmit(struct sk_buff *skb,
		struct net_device *dev)
		{
		struct bonding *bond = netdev_priv(dev);
		struct slave *slave;
		struct bond_up_slave *slaves;
		unsigned int count;
		struct slave *slave;

		slaves = rcu_dereference(bond->slave_arr);
		count = slaves ? READ_ONCE(slaves->count) : 0;
		if (likely(count)) {
		slave = slaves->arr[bond_xmit_hash(bond, skb) % count];
		slaves = rcu_dereference(bond->usable_slaves);
		slave = bond_xmit_3ad_xor_slave_get(bond, skb, slaves);
		if (likely(slave))
		return bond_dev_queue_xmit(bond, skb, slave->dev);
		}

		return bond_tx_drop(dev, skb);
		}

		@@ -4269,6 +4340,48 @@ static u16 bond_select_queue(struct net_device dev, struct sk_buff skb,
		return txq;
		}

		static struct net_device bond_xmit_get_slave(struct net_device master_dev,
		struct sk_buff *skb,
		bool all_slaves)
		{
		struct bonding *bond = netdev_priv(master_dev);
		struct bond_up_slave *slaves;
		struct slave *slave = NULL;

		switch (BOND_MODE(bond)) {
		case BOND_MODE_ROUNDROBIN:
		slave = bond_xmit_roundrobin_slave_get(bond, skb);
		break;
		case BOND_MODE_ACTIVEBACKUP:
		slave = bond_xmit_activebackup_slave_get(bond, skb);
		break;
		case BOND_MODE_8023AD:
		case BOND_MODE_XOR:
		if (all_slaves)
		slaves = rcu_dereference(bond->all_slaves);
		else
		slaves = rcu_dereference(bond->usable_slaves);
		slave = bond_xmit_3ad_xor_slave_get(bond, skb, slaves);
		break;
		case BOND_MODE_BROADCAST:
		break;
		case BOND_MODE_ALB:
		slave = bond_xmit_alb_slave_get(bond, skb);
		break;
		case BOND_MODE_TLB:
		slave = bond_xmit_tlb_slave_get(bond, skb);
		break;
		default:
		/* Should never happen, mode already checked */
		WARN_ONCE(true, "Unknown bonding mode");
		break;
		}

		if (slave)
		return slave->dev;
		return NULL;
		}

		static netdev_tx_t __bond_start_xmit(struct sk_buff skb, struct net_device dev)
		{
		struct bonding *bond = netdev_priv(dev);
		@@ -4389,6 +4502,7 @@ static const struct net_device_ops bond_netdev_ops = {
		.ndo_del_slave = bond_release,
		.ndo_fix_features = bond_fix_features,
		.ndo_features_check = passthru_features_check,
		.ndo_get_xmit_slave = bond_xmit_get_slave,
		};

		static const struct device_type bond_type = {
		@@ -4456,9 +4570,9 @@ void bond_setup(struct net_device *bond_dev)
		static void bond_uninit(struct net_device *bond_dev)
		{
		struct bonding *bond = netdev_priv(bond_dev);
		struct bond_up_slave usable, all;
		struct list_head *iter;
		struct slave *slave;
		struct bond_up_slave *arr;

		bond_netpoll_cleanup(bond_dev);

		@@ -4467,10 +4581,16 @@ static void bond_uninit(struct net_device *bond_dev)
		__bond_release_one(bond_dev, slave->dev, true, true);
		netdev_info(bond_dev, "Released all slaves\n");

		arr = rtnl_dereference(bond->slave_arr);
		if (arr) {
		RCU_INIT_POINTER(bond->slave_arr, NULL);
		kfree_rcu(arr, rcu);
		usable = rtnl_dereference(bond->usable_slaves);
		if (usable) {
		RCU_INIT_POINTER(bond->usable_slaves, NULL);
		kfree_rcu(usable, rcu);
		}

		all = rtnl_dereference(bond->all_slaves);
		if (all) {
		RCU_INIT_POINTER(bond->all_slaves, NULL);
		kfree_rcu(all, rcu);
		}

		list_del(&bond->bond_list);

drivers/net/ethernet/mellanox/mlx5/core/accel/accel.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -5,7 +5,6 @@

		#include <linux/skbuff.h>
		#include <linux/netdevice.h>
		#include "en.h"

		static inline bool is_metadata_hdr_valid(struct sk_buff *skb)
		{

drivers/net/ethernet/mellanox/mlx5/core/en.h

+2 −29

Original line number	Diff line number	Diff line
		@@ -339,16 +339,6 @@ struct mlx5e_cq_decomp {
		u16 wqe_counter;
		} ____cacheline_aligned_in_smp;

		struct mlx5e_tx_wqe_info {
		struct sk_buff *skb;
		u32 num_bytes;
		u8 num_wqebbs;
		u8 num_dma;
		#ifdef CONFIG_MLX5_EN_TLS
		struct page *resync_dump_frag_page;
		#endif
		};

		enum mlx5e_dma_map_type {
		MLX5E_DMA_MAP_SINGLE,
		MLX5E_DMA_MAP_PAGE
		@@ -370,18 +360,6 @@ enum {
		MLX5E_SQ_STATE_PENDING_XSK_TX,
		};

		struct mlx5e_icosq_wqe_info {
		u8 opcode;
		u8 num_wqebbs;

		/* Auxiliary data for different opcodes. */
		union {
		struct {
		struct mlx5e_rq *rq;
		} umr;
		};
		};

		struct mlx5e_txqsq {
		/* data path */

		@@ -484,11 +462,6 @@ struct mlx5e_xdp_info_fifo {
		u32 mask;
		};

		struct mlx5e_xdp_wqe_info {
		u8 num_wqebbs;
		u8 num_pkts;
		};

		struct mlx5e_xdp_mpwqe {
		/* Current MPWQE session */
		struct mlx5e_tx_wqe *wqe;
		@@ -919,7 +892,7 @@ void mlx5e_build_ptys2ethtool_map(void);
		u16 mlx5e_select_queue(struct net_device dev, struct sk_buff skb,
		struct net_device *sb_dev);
		netdev_tx_t mlx5e_xmit(struct sk_buff skb, struct net_device dev);
		netdev_tx_t mlx5e_sq_xmit(struct mlx5e_txqsq sq, struct sk_buff skb,
		void mlx5e_sq_xmit(struct mlx5e_txqsq sq, struct sk_buff skb,
		struct mlx5e_tx_wqe *wqe, u16 pi, bool xmit_more);

		void mlx5e_trigger_irq(struct mlx5e_icosq *sq);

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h

+28 −1

Original line number	Diff line number	Diff line
		@@ -27,6 +27,11 @@

		#define INL_HDR_START_SZ (sizeof(((struct mlx5_wqe_eth_seg *)NULL)->inline_hdr.start))

		enum mlx5e_icosq_wqe_type {
		MLX5E_ICOSQ_WQE_NOP,
		MLX5E_ICOSQ_WQE_UMR_RX,
		};

		static inline bool
		mlx5e_wqc_has_room_for(struct mlx5_wq_cyc *wq, u16 cc, u16 pc, u16 n)
		{
		@@ -81,6 +86,16 @@ mlx5e_post_nop_fence(struct mlx5_wq_cyc wq, u32 sqn, u16 pc)
		return wqe;
		}

		struct mlx5e_tx_wqe_info {
		struct sk_buff *skb;
		u32 num_bytes;
		u8 num_wqebbs;
		u8 num_dma;
		#ifdef CONFIG_MLX5_EN_TLS
		struct page *resync_dump_frag_page;
		#endif
		};

		static inline u16 mlx5e_txqsq_get_next_pi(struct mlx5e_txqsq *sq, u16 size)
		{
		struct mlx5_wq_cyc *wq = &sq->wq;
		@@ -109,6 +124,18 @@ static inline u16 mlx5e_txqsq_get_next_pi(struct mlx5e_txqsq *sq, u16 size)
		return pi;
		}

		struct mlx5e_icosq_wqe_info {
		u8 wqe_type;
		u8 num_wqebbs;

		/* Auxiliary data for different wqe types. */
		union {
		struct {
		struct mlx5e_rq *rq;
		} umr;
		};
		};

		static inline u16 mlx5e_icosq_get_next_pi(struct mlx5e_icosq *sq, u16 size)
		{
		struct mlx5_wq_cyc *wq = &sq->wq;
		@@ -125,7 +152,7 @@ static inline u16 mlx5e_icosq_get_next_pi(struct mlx5e_icosq *sq, u16 size)
		/* Fill SQ frag edge with NOPs to avoid WQE wrapping two pages. */
		for (; wi < edge_wi; wi++) {
		*wi = (struct mlx5e_icosq_wqe_info) {
		.opcode = MLX5_OPCODE_NOP,
		.wqe_type = MLX5E_ICOSQ_WQE_NOP,
		.num_wqebbs = 1,
		};
		mlx5e_post_nop(wq, sq->sqn, &sq->pc);

Admin message