Commit bbfeba26 authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files

Merge branch 'mlx5-misc-patches-2024-08-08' 

Tariq Toukan says:

====================
mlx5 misc patches 2024-08-08

This patchset contains multiple enhancements from the team to the mlx5
core and Eth drivers.

Patch #1 by Chris bumps a defined value to permit more devices doing TC
offloads.

Patch #2 by Jianbo adds an IPsec fast-path optimization to replace the
slow async handling.

Patches #3 and #4 by Jianbo add TC offload support for complicated rules
to overcome firmware limitation.

Patch #5 by Gal unifies the access macro to advertised/supported link
modes.

Patches #6 to #9 by Gal adds extack messages in ethtool ops to replace
prints to the kernel log.

Patch #10 by Cosmin switches to using 'update' verb instead of 'replace'
to better reflect the operation.

Patch #11 by Cosmin exposes an update connection tracking operation to
replace the assumed delete+add implementaiton.
====================

Link: https://patch.msgid.link/20240808055927.2059700-1-tariqt@nvidia.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents 1862923b 6b5662b7

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

+4 −2
Original line number Diff line number Diff line
@@ -1172,14 +1172,16 @@ void mlx5e_ethtool_get_ringparam(struct mlx5e_priv *priv, 
				 struct ethtool_ringparam *param,

				 struct kernel_ethtool_ringparam *kernel_param);

int mlx5e_ethtool_set_ringparam(struct mlx5e_priv *priv,

				struct ethtool_ringparam *param);

				struct ethtool_ringparam *param,

				struct netlink_ext_ack *extack);

void mlx5e_ethtool_get_channels(struct mlx5e_priv *priv,

				struct ethtool_channels *ch);

int mlx5e_ethtool_set_channels(struct mlx5e_priv *priv,

			       struct ethtool_channels *ch);

int mlx5e_ethtool_get_coalesce(struct mlx5e_priv *priv,

			       struct ethtool_coalesce *coal,

			       struct kernel_ethtool_coalesce *kernel_coal);

			       struct kernel_ethtool_coalesce *kernel_coal,

			       struct netlink_ext_ack *extack);

int mlx5e_ethtool_set_coalesce(struct mlx5e_priv *priv,

			       struct ethtool_coalesce *coal,

			       struct kernel_ethtool_coalesce *kernel_coal,

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

+2 −0
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ struct mlx5_ct_fs_ops { 
						struct mlx5_flow_attr *attr,

						struct flow_rule *flow_rule);

	void (*ct_rule_del)(struct mlx5_ct_fs *fs, struct mlx5_ct_fs_rule *fs_rule);

	int (*ct_rule_update)(struct mlx5_ct_fs *fs, struct mlx5_ct_fs_rule *fs_rule,

			      struct mlx5_flow_spec *spec, struct mlx5_flow_attr *attr);



	size_t priv_size;

};

drivers/net/ethernet/mellanox/mlx5/core/en/tc/ct_fs_dmfs.c

+21 −0
Original line number Diff line number Diff line
@@ -65,9 +65,30 @@ mlx5_ct_fs_dmfs_ct_rule_del(struct mlx5_ct_fs *fs, struct mlx5_ct_fs_rule *fs_ru 
	kfree(dmfs_rule);

}



static int mlx5_ct_fs_dmfs_ct_rule_update(struct mlx5_ct_fs *fs, struct mlx5_ct_fs_rule *fs_rule,

					  struct mlx5_flow_spec *spec, struct mlx5_flow_attr *attr)

{

	struct mlx5_ct_fs_dmfs_rule *dmfs_rule = container_of(fs_rule,

							      struct mlx5_ct_fs_dmfs_rule,

							      fs_rule);

	struct mlx5e_priv *priv = netdev_priv(fs->netdev);

	struct mlx5_flow_handle *rule;



	rule = mlx5_tc_rule_insert(priv, spec, attr);

	if (IS_ERR(rule))

		return PTR_ERR(rule);

	mlx5_tc_rule_delete(priv, dmfs_rule->rule, dmfs_rule->attr);



	dmfs_rule->rule = rule;

	dmfs_rule->attr = attr;



	return 0;

}



static struct mlx5_ct_fs_ops dmfs_ops = {

	.ct_rule_add = mlx5_ct_fs_dmfs_ct_rule_add,

	.ct_rule_del = mlx5_ct_fs_dmfs_ct_rule_del,

	.ct_rule_update = mlx5_ct_fs_dmfs_ct_rule_update,



	.init = mlx5_ct_fs_dmfs_init,

	.destroy = mlx5_ct_fs_dmfs_destroy,

drivers/net/ethernet/mellanox/mlx5/core/en/tc/ct_fs_smfs.c

+26 −0
Original line number Diff line number Diff line
@@ -368,9 +368,35 @@ mlx5_ct_fs_smfs_ct_rule_del(struct mlx5_ct_fs *fs, struct mlx5_ct_fs_rule *fs_ru 
	kfree(smfs_rule);

}



static int mlx5_ct_fs_smfs_ct_rule_update(struct mlx5_ct_fs *fs, struct mlx5_ct_fs_rule *fs_rule,

					  struct mlx5_flow_spec *spec, struct mlx5_flow_attr *attr)

{

	struct mlx5_ct_fs_smfs_rule *smfs_rule = container_of(fs_rule,

							      struct mlx5_ct_fs_smfs_rule,

							      fs_rule);

	struct mlx5_ct_fs_smfs *fs_smfs = mlx5_ct_fs_priv(fs);

	struct mlx5dr_action *actions[3];  /* We only need to create 3 actions, see below. */

	struct mlx5dr_rule *rule;



	actions[0] = smfs_rule->count_action;

	actions[1] = attr->modify_hdr->action.dr_action;

	actions[2] = fs_smfs->fwd_action;



	rule = mlx5_smfs_rule_create(smfs_rule->smfs_matcher->dr_matcher, spec,

				     ARRAY_SIZE(actions), actions, spec->flow_context.flow_source);

	if (!rule)

		return -EINVAL;



	mlx5_smfs_rule_destroy(smfs_rule->rule);

	smfs_rule->rule = rule;



	return 0;

}



static struct mlx5_ct_fs_ops fs_smfs_ops = {

	.ct_rule_add = mlx5_ct_fs_smfs_ct_rule_add,

	.ct_rule_del = mlx5_ct_fs_smfs_ct_rule_del,

	.ct_rule_update = mlx5_ct_fs_smfs_ct_rule_update,



	.init = mlx5_ct_fs_smfs_init,

	.destroy = mlx5_ct_fs_smfs_destroy,

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

+21 −25
Original line number Diff line number Diff line
@@ -876,7 +876,7 @@ mlx5_tc_ct_entry_add_rule(struct mlx5_tc_ct_priv *ct_priv, 
}



static int

mlx5_tc_ct_entry_replace_rule(struct mlx5_tc_ct_priv *ct_priv,

mlx5_tc_ct_entry_update_rule(struct mlx5_tc_ct_priv *ct_priv,

			     struct flow_rule *flow_rule,

			     struct mlx5_ct_entry *entry,

			     bool nat, u8 zone_restore_id)
@@ -884,7 +884,6 @@ mlx5_tc_ct_entry_replace_rule(struct mlx5_tc_ct_priv *ct_priv, 
	struct mlx5_ct_zone_rule *zone_rule = &entry->zone_rules[nat];

	struct mlx5_flow_attr *attr = zone_rule->attr, *old_attr;

	struct mlx5e_mod_hdr_handle *mh;

	struct mlx5_ct_fs_rule *rule;

	struct mlx5_flow_spec *spec;

	int err;
@@ -902,29 +901,26 @@ mlx5_tc_ct_entry_replace_rule(struct mlx5_tc_ct_priv *ct_priv, 
	err = mlx5_tc_ct_entry_create_mod_hdr(ct_priv, attr, flow_rule, &mh, zone_restore_id,

					      nat, mlx5_tc_ct_entry_in_ct_nat_table(entry));

	if (err) {

		ct_dbg("Failed to create ct entry mod hdr");

		ct_dbg("Failed to create ct entry mod hdr, err: %d", err);

		goto err_mod_hdr;

	}



	mlx5_tc_ct_set_tuple_match(ct_priv, spec, flow_rule);

	mlx5e_tc_match_to_reg_match(spec, ZONE_TO_REG, entry->tuple.zone, MLX5_CT_ZONE_MASK);



	rule = ct_priv->fs_ops->ct_rule_add(ct_priv->fs, spec, attr, flow_rule);

	if (IS_ERR(rule)) {

		err = PTR_ERR(rule);

		ct_dbg("Failed to add replacement ct entry rule, nat: %d", nat);

	err = ct_priv->fs_ops->ct_rule_update(ct_priv->fs, zone_rule->rule, spec, attr);

	if (err) {

		ct_dbg("Failed to update ct entry rule, nat: %d, err: %d", nat, err);

		goto err_rule;

	}



	ct_priv->fs_ops->ct_rule_del(ct_priv->fs, zone_rule->rule);

	zone_rule->rule = rule;

	mlx5_tc_ct_entry_destroy_mod_hdr(ct_priv, old_attr, zone_rule->mh);

	zone_rule->mh = mh;

	mlx5_put_label_mapping(ct_priv, old_attr->ct_attr.ct_labels_id);



	kfree(old_attr);

	kvfree(spec);

	ct_dbg("Replaced ct entry rule in zone %d", entry->tuple.zone);

	ct_dbg("Updated ct entry rule in zone %d", entry->tuple.zone);



	return 0;
@@ -1141,7 +1137,7 @@ mlx5_tc_ct_entry_add_rules(struct mlx5_tc_ct_priv *ct_priv, 
}



static int

mlx5_tc_ct_entry_replace_rules(struct mlx5_tc_ct_priv *ct_priv,

mlx5_tc_ct_entry_update_rules(struct mlx5_tc_ct_priv *ct_priv,

			      struct flow_rule *flow_rule,

			      struct mlx5_ct_entry *entry,

			      u8 zone_restore_id)
@@ -1149,14 +1145,14 @@ mlx5_tc_ct_entry_replace_rules(struct mlx5_tc_ct_priv *ct_priv, 
	int err = 0;



	if (mlx5_tc_ct_entry_in_ct_table(entry)) {

		err = mlx5_tc_ct_entry_replace_rule(ct_priv, flow_rule, entry, false,

		err = mlx5_tc_ct_entry_update_rule(ct_priv, flow_rule, entry, false,

						   zone_restore_id);

		if (err)

			return err;

	}



	if (mlx5_tc_ct_entry_in_ct_nat_table(entry)) {

		err = mlx5_tc_ct_entry_replace_rule(ct_priv, flow_rule, entry, true,

		err = mlx5_tc_ct_entry_update_rule(ct_priv, flow_rule, entry, true,

						   zone_restore_id);

		if (err && mlx5_tc_ct_entry_in_ct_table(entry))

			mlx5_tc_ct_entry_del_rule(ct_priv, entry, false);
@@ -1165,13 +1161,13 @@ mlx5_tc_ct_entry_replace_rules(struct mlx5_tc_ct_priv *ct_priv, 
}



static int

mlx5_tc_ct_block_flow_offload_replace(struct mlx5_ct_ft *ft, struct flow_rule *flow_rule,

mlx5_tc_ct_block_flow_offload_update(struct mlx5_ct_ft *ft, struct flow_rule *flow_rule,

				     struct mlx5_ct_entry *entry, unsigned long cookie)

{

	struct mlx5_tc_ct_priv *ct_priv = ft->ct_priv;

	int err;



	err = mlx5_tc_ct_entry_replace_rules(ct_priv, flow_rule, entry, ft->zone_restore_id);

	err = mlx5_tc_ct_entry_update_rules(ct_priv, flow_rule, entry, ft->zone_restore_id);

	if (!err)

		return 0;
@@ -1216,7 +1212,7 @@ mlx5_tc_ct_block_flow_offload_add(struct mlx5_ct_ft *ft, 
		entry->restore_cookie = meta_action->ct_metadata.cookie;

		spin_unlock_bh(&ct_priv->ht_lock);



		err = mlx5_tc_ct_block_flow_offload_replace(ft, flow_rule, entry, cookie);

		err = mlx5_tc_ct_block_flow_offload_update(ft, flow_rule, entry, cookie);

		mlx5_tc_ct_entry_put(entry);

		return err;

	}