Commit ada3e24b authored by Ahmed Zaki's avatar Ahmed Zaki Committed by Tony Nguyen
Browse files

idpf: add flow steering support 



Use the new virtchnl2 OP codes to communicate with the Control Plane to
add flow steering filters. We add the basic functionality for add/delete
with TCP/UDP IPv4 only. Support for other OP codes and protocols will be
added later.

Standard 'ethtool -N|--config-ntuple' should be used, for example:

    # ethtool -N ens801f0d1 flow-type tcp4 src-ip 10.0.0.1 action 6

to route all IPv4/TCP traffic from IP 10.0.0.1 to queue 6.

Reviewed-by: default avatarSridhar Samudrala <sridhar.samudrala@intel.com>
Signed-off-by: default avatarAhmed Zaki <ahmed.zaki@intel.com>
Reviewed-by: default avatarSimon Horman <horms@kernel.org>
Signed-off-by: default avatarTony Nguyen <anthony.l.nguyen@intel.com>
parent bff42357

drivers/net/ethernet/intel/idpf/idpf.h

+13 −0
Original line number Diff line number Diff line
@@ -269,6 +269,12 @@ struct idpf_port_stats { 
	struct virtchnl2_vport_stats vport_stats;

};



struct idpf_fsteer_fltr {

	struct list_head list;

	u32 loc;

	u32 q_index;

};



/**

 * struct idpf_vport - Handle for netdevices and queue resources

 * @num_txq: Number of allocated TX queues
@@ -411,6 +417,8 @@ struct idpf_rss_data { 
 *		      ethtool

 * @user_flags: User toggled config flags

 * @mac_filter_list: List of MAC filters

 * @num_fsteer_fltrs: number of flow steering filters

 * @flow_steer_list: list of flow steering filters

 *

 * Used to restore configuration after a reset as the vport will get wiped.

 */
@@ -422,6 +430,8 @@ struct idpf_vport_user_config_data { 
	u32 num_req_rxq_desc;

	DECLARE_BITMAP(user_flags, __IDPF_USER_FLAGS_NBITS);

	struct list_head mac_filter_list;

	u32 num_fsteer_fltrs;

	struct list_head flow_steer_list;

};



/**
@@ -960,4 +970,7 @@ void idpf_idc_issue_reset_event(struct iidc_rdma_core_dev_info *cdev_info); 
void idpf_idc_vdev_mtu_event(struct iidc_rdma_vport_dev_info *vdev_info,

			     enum iidc_rdma_event_type event_type);



int idpf_add_del_fsteer_filters(struct idpf_adapter *adapter,

				struct virtchnl2_flow_rule_add_del *rule,

				enum virtchnl2_op opcode);

#endif /* !_IDPF_H_ */

drivers/net/ethernet/intel/idpf/idpf_ethtool.c

+293 −5
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ 


#include "idpf.h"

#include "idpf_ptp.h"

#include "idpf_virtchnl.h"



/**

 * idpf_get_rxnfc - command to get RX flow classification rules
@@ -13,26 +14,312 @@ 
 * Returns Success if the command is supported.

 */

static int idpf_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,

			  u32 __always_unused *rule_locs)

			  u32 *rule_locs)

{

	struct idpf_netdev_priv *np = netdev_priv(netdev);

	struct idpf_vport_user_config_data *user_config;

	struct idpf_fsteer_fltr *f;

	struct idpf_vport *vport;

	unsigned int cnt = 0;

	int err = 0;



	idpf_vport_ctrl_lock(netdev);

	vport = idpf_netdev_to_vport(netdev);

	user_config = &np->adapter->vport_config[np->vport_idx]->user_config;



	switch (cmd->cmd) {

	case ETHTOOL_GRXRINGS:

		cmd->data = vport->num_rxq;

		break;

	case ETHTOOL_GRXCLSRLCNT:

		cmd->rule_cnt = user_config->num_fsteer_fltrs;

		cmd->data = idpf_fsteer_max_rules(vport);

		break;

	case ETHTOOL_GRXCLSRULE:

		err = -EINVAL;

		list_for_each_entry(f, &user_config->flow_steer_list, list)

			if (f->loc == cmd->fs.location) {

				cmd->fs.ring_cookie = f->q_index;

				err = 0;

				break;

			}

		break;

	case ETHTOOL_GRXCLSRLALL:

		cmd->data = idpf_fsteer_max_rules(vport);

		list_for_each_entry(f, &user_config->flow_steer_list, list) {

			if (cnt == cmd->rule_cnt) {

				err = -EMSGSIZE;

				break;

			}

			rule_locs[cnt] = f->loc;

			cnt++;

		}

		if (!err)

			cmd->rule_cnt = user_config->num_fsteer_fltrs;

		break;

	default:

		break;

	}



	idpf_vport_ctrl_unlock(netdev);



		return 0;

	return err;

}



static void idpf_fsteer_fill_ipv4(struct virtchnl2_proto_hdrs *hdrs,

				  struct ethtool_rx_flow_spec *fsp)

{

	struct iphdr *iph;



	hdrs->proto_hdr[0].hdr_type = cpu_to_le32(VIRTCHNL2_PROTO_HDR_IPV4);



	iph = (struct iphdr *)hdrs->proto_hdr[0].buffer_spec;

	iph->saddr = fsp->h_u.tcp_ip4_spec.ip4src;

	iph->daddr = fsp->h_u.tcp_ip4_spec.ip4dst;



	iph = (struct iphdr *)hdrs->proto_hdr[0].buffer_mask;

	iph->saddr = fsp->m_u.tcp_ip4_spec.ip4src;

	iph->daddr = fsp->m_u.tcp_ip4_spec.ip4dst;

}



static void idpf_fsteer_fill_udp(struct virtchnl2_proto_hdrs *hdrs,

				 struct ethtool_rx_flow_spec *fsp,

				 bool v4)

{

	struct udphdr *udph, *udpm;



	hdrs->proto_hdr[1].hdr_type = cpu_to_le32(VIRTCHNL2_PROTO_HDR_UDP);



	udph = (struct udphdr *)hdrs->proto_hdr[1].buffer_spec;

	udpm = (struct udphdr *)hdrs->proto_hdr[1].buffer_mask;



	if (v4) {

		udph->source = fsp->h_u.udp_ip4_spec.psrc;

		udph->dest = fsp->h_u.udp_ip4_spec.pdst;

		udpm->source = fsp->m_u.udp_ip4_spec.psrc;

		udpm->dest = fsp->m_u.udp_ip4_spec.pdst;

	} else {

		udph->source = fsp->h_u.udp_ip6_spec.psrc;

		udph->dest = fsp->h_u.udp_ip6_spec.pdst;

		udpm->source = fsp->m_u.udp_ip6_spec.psrc;

		udpm->dest = fsp->m_u.udp_ip6_spec.pdst;

	}

}



static void idpf_fsteer_fill_tcp(struct virtchnl2_proto_hdrs *hdrs,

				 struct ethtool_rx_flow_spec *fsp,

				 bool v4)

{

	struct tcphdr *tcph, *tcpm;



	hdrs->proto_hdr[1].hdr_type = cpu_to_le32(VIRTCHNL2_PROTO_HDR_TCP);



	tcph = (struct tcphdr *)hdrs->proto_hdr[1].buffer_spec;

	tcpm = (struct tcphdr *)hdrs->proto_hdr[1].buffer_mask;



	if (v4) {

		tcph->source = fsp->h_u.tcp_ip4_spec.psrc;

		tcph->dest = fsp->h_u.tcp_ip4_spec.pdst;

		tcpm->source = fsp->m_u.tcp_ip4_spec.psrc;

		tcpm->dest = fsp->m_u.tcp_ip4_spec.pdst;

	} else {

		tcph->source = fsp->h_u.tcp_ip6_spec.psrc;

		tcph->dest = fsp->h_u.tcp_ip6_spec.pdst;

		tcpm->source = fsp->m_u.tcp_ip6_spec.psrc;

		tcpm->dest = fsp->m_u.tcp_ip6_spec.pdst;

	}

}



/**

 * idpf_add_flow_steer - add a Flow Steering filter

 * @netdev: network interface device structure

 * @cmd: command to add Flow Steering filter

 *

 * Return: 0 on success and negative values for failure

 */

static int idpf_add_flow_steer(struct net_device *netdev,

			       struct ethtool_rxnfc *cmd)

{

	struct idpf_fsteer_fltr *fltr, *parent = NULL, *f;

	struct idpf_netdev_priv *np = netdev_priv(netdev);

	struct idpf_vport_user_config_data *user_config;

	struct ethtool_rx_flow_spec *fsp = &cmd->fs;

	struct virtchnl2_flow_rule_add_del *rule;

	struct idpf_vport_config *vport_config;

	struct virtchnl2_rule_action_set *acts;

	struct virtchnl2_flow_rule_info *info;

	struct virtchnl2_proto_hdrs *hdrs;

	struct idpf_vport *vport;

	u32 flow_type, q_index;

	u16 num_rxq;

	int err;



	vport = idpf_netdev_to_vport(netdev);

	vport_config = vport->adapter->vport_config[np->vport_idx];

	user_config = &vport_config->user_config;

	num_rxq = user_config->num_req_rx_qs;



	flow_type = fsp->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS);

	if (flow_type != fsp->flow_type)

		return -EINVAL;



	if (!idpf_sideband_action_ena(vport, fsp) ||

	    !idpf_sideband_flow_type_ena(vport, flow_type))

		return -EOPNOTSUPP;



	if (user_config->num_fsteer_fltrs > idpf_fsteer_max_rules(vport))

		return -ENOSPC;



	q_index = fsp->ring_cookie;

	if (q_index >= num_rxq)

		return -EINVAL;



	rule = kzalloc(struct_size(rule, rule_info, 1), GFP_KERNEL);

	if (!rule)

		return -ENOMEM;



	rule->vport_id = cpu_to_le32(vport->vport_id);

	rule->count = cpu_to_le32(1);

	info = &rule->rule_info[0];

	info->rule_id = cpu_to_le32(fsp->location);



	hdrs = &info->rule_cfg.proto_hdrs;

	hdrs->tunnel_level = 0;

	hdrs->count = cpu_to_le32(2);



	acts = &info->rule_cfg.action_set;

	acts->count = cpu_to_le32(1);

	acts->actions[0].action_type = cpu_to_le32(VIRTCHNL2_ACTION_QUEUE);

	acts->actions[0].act_conf.q_id = cpu_to_le32(q_index);



	switch (flow_type) {

	case UDP_V4_FLOW:

		idpf_fsteer_fill_ipv4(hdrs, fsp);

		idpf_fsteer_fill_udp(hdrs, fsp, true);

		break;

	case TCP_V4_FLOW:

		idpf_fsteer_fill_ipv4(hdrs, fsp);

		idpf_fsteer_fill_tcp(hdrs, fsp, true);

		break;

	default:

		err = -EINVAL;

		goto out;

	}



	err = idpf_add_del_fsteer_filters(vport->adapter, rule,

					  VIRTCHNL2_OP_ADD_FLOW_RULE);

	if (err)

		goto out;



	if (info->status != cpu_to_le32(VIRTCHNL2_FLOW_RULE_SUCCESS)) {

		err = -EIO;

		goto out;

	}



	fltr = kzalloc(sizeof(*fltr), GFP_KERNEL);

	if (!fltr) {

		err = -ENOMEM;

		goto out;

	}



	fltr->loc = fsp->location;

	fltr->q_index = q_index;

	list_for_each_entry(f, &user_config->flow_steer_list, list) {

		if (f->loc >= fltr->loc)

			break;

		parent = f;

	}



	idpf_vport_ctrl_unlock(netdev);

	parent ? list_add(&fltr->list, &parent->list) :

		 list_add(&fltr->list, &user_config->flow_steer_list);



	user_config->num_fsteer_fltrs++;



out:

	kfree(rule);

	return err;

}



/**

 * idpf_del_flow_steer - delete a Flow Steering filter

 * @netdev: network interface device structure

 * @cmd: command to add Flow Steering filter

 *

 * Return: 0 on success and negative values for failure

 */

static int idpf_del_flow_steer(struct net_device *netdev,

			       struct ethtool_rxnfc *cmd)

{

	struct idpf_netdev_priv *np = netdev_priv(netdev);

	struct idpf_vport_user_config_data *user_config;

	struct ethtool_rx_flow_spec *fsp = &cmd->fs;

	struct virtchnl2_flow_rule_add_del *rule;

	struct idpf_vport_config *vport_config;

	struct virtchnl2_flow_rule_info *info;

	struct idpf_fsteer_fltr *f, *iter;

	struct idpf_vport *vport;

	int err;



	vport = idpf_netdev_to_vport(netdev);

	vport_config = vport->adapter->vport_config[np->vport_idx];

	user_config = &vport_config->user_config;



	if (!idpf_sideband_action_ena(vport, fsp))

		return -EOPNOTSUPP;



	rule = kzalloc(struct_size(rule, rule_info, 1), GFP_KERNEL);

	if (!rule)

		return -ENOMEM;



	rule->vport_id = cpu_to_le32(vport->vport_id);

	rule->count = cpu_to_le32(1);

	info = &rule->rule_info[0];

	info->rule_id = cpu_to_le32(fsp->location);



	err = idpf_add_del_fsteer_filters(vport->adapter, rule,

					  VIRTCHNL2_OP_DEL_FLOW_RULE);

	if (err)

		goto out;



	if (info->status != cpu_to_le32(VIRTCHNL2_FLOW_RULE_SUCCESS)) {

		err = -EIO;

		goto out;

	}



	list_for_each_entry_safe(f, iter,

				 &user_config->flow_steer_list, list) {

		if (f->loc == fsp->location) {

			list_del(&f->list);

			kfree(f);

			user_config->num_fsteer_fltrs--;

			goto out;

		}

	}

	err = -EINVAL;



out:

	kfree(rule);

	return err;

}



static int idpf_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)

{

	int ret = -EOPNOTSUPP;



	idpf_vport_ctrl_lock(netdev);

	switch (cmd->cmd) {

	case ETHTOOL_SRXCLSRLINS:

		ret = idpf_add_flow_steer(netdev, cmd);

		break;

	case ETHTOOL_SRXCLSRLDEL:

		ret = idpf_del_flow_steer(netdev, cmd);

		break;

	default:

		break;

	}



	idpf_vport_ctrl_unlock(netdev);

	return ret;

}



/**
@@ -1394,6 +1681,7 @@ static const struct ethtool_ops idpf_ethtool_ops = { 
	.get_sset_count		= idpf_get_sset_count,

	.get_channels		= idpf_get_channels,

	.get_rxnfc		= idpf_get_rxnfc,

	.set_rxnfc		= idpf_set_rxnfc,

	.get_rxfh_key_size	= idpf_get_rxfh_key_size,

	.get_rxfh_indir_size	= idpf_get_rxfh_indir_size,

	.get_rxfh		= idpf_get_rxfh,

drivers/net/ethernet/intel/idpf/idpf_lib.c

+5 −0
Original line number Diff line number Diff line
@@ -804,6 +804,10 @@ static int idpf_cfg_netdev(struct idpf_vport *vport) 


	if (idpf_is_cap_ena_all(adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS))

		dflt_features |= NETIF_F_RXHASH;

	if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS,

			    VIRTCHNL2_CAP_FLOW_STEER) &&

	    idpf_vport_is_cap_ena(vport, VIRTCHNL2_VPORT_SIDEBAND_FLOW_STEER))

		dflt_features |= NETIF_F_NTUPLE;

	if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_CSUM_L4V4))

		csum_offloads |= NETIF_F_IP_CSUM;

	if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_CSUM_L4V6))
@@ -1532,6 +1536,7 @@ void idpf_init_task(struct work_struct *work) 
	spin_lock_init(&vport_config->mac_filter_list_lock);



	INIT_LIST_HEAD(&vport_config->user_config.mac_filter_list);

	INIT_LIST_HEAD(&vport_config->user_config.flow_steer_list);



	err = idpf_check_supported_desc_ids(vport);

	if (err) {

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

+108 −0
Original line number Diff line number Diff line
@@ -1015,6 +1015,41 @@ static int idpf_map_lan_mmio_regs(struct idpf_adapter *adapter) 
	return 0;

}



/**

 * idpf_add_del_fsteer_filters - Send virtchnl add/del Flow Steering message

 * @adapter: adapter info struct

 * @rule: Flow steering rule to add/delete

 * @opcode: VIRTCHNL2_OP_ADD_FLOW_RULE to add filter, or

 *          VIRTCHNL2_OP_DEL_FLOW_RULE to delete. All other values are invalid.

 *

 * Send ADD/DELETE flow steering virtchnl message and receive the result.

 *

 * Return: 0 on success, negative on failure.

 */

int idpf_add_del_fsteer_filters(struct idpf_adapter *adapter,

				struct virtchnl2_flow_rule_add_del *rule,

				enum virtchnl2_op opcode)

{

	int rule_count = le32_to_cpu(rule->count);

	struct idpf_vc_xn_params xn_params = {};

	ssize_t reply_sz;



	if (opcode != VIRTCHNL2_OP_ADD_FLOW_RULE &&

	    opcode != VIRTCHNL2_OP_DEL_FLOW_RULE)

		return -EINVAL;



	xn_params.vc_op = opcode;

	xn_params.timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC;

	xn_params.async = false;

	xn_params.send_buf.iov_base = rule;

	xn_params.send_buf.iov_len = struct_size(rule, rule_info, rule_count);

	xn_params.recv_buf.iov_base = rule;

	xn_params.recv_buf.iov_len = struct_size(rule, rule_info, rule_count);



	reply_sz = idpf_vc_xn_exec(adapter, &xn_params);

	return reply_sz < 0 ? reply_sz : 0;

}



/**

 * idpf_vport_alloc_max_qs - Allocate max queues for a vport

 * @adapter: Driver specific private structure
@@ -3642,6 +3677,79 @@ bool idpf_is_capability_ena(struct idpf_adapter *adapter, bool all, 
		return !!(*cap_field & flag);

}



/**

 * idpf_vport_is_cap_ena - Check if vport capability is enabled

 * @vport: Private data struct

 * @flag: flag(s) to check

 *

 * Return: true if the capability is supported, false otherwise

 */

bool idpf_vport_is_cap_ena(struct idpf_vport *vport, u16 flag)

{

	struct virtchnl2_create_vport *vport_msg;



	vport_msg = vport->adapter->vport_params_recvd[vport->idx];



	return !!(le16_to_cpu(vport_msg->vport_flags) & flag);

}



/**

 * idpf_sideband_flow_type_ena - Check if steering is enabled for flow type

 * @vport: Private data struct

 * @flow_type: flow type to check (from ethtool.h)

 *

 * Return: true if sideband filters are allowed for @flow_type, false otherwise

 */

bool idpf_sideband_flow_type_ena(struct idpf_vport *vport, u32 flow_type)

{

	struct virtchnl2_create_vport *vport_msg;

	__le64 caps;



	vport_msg = vport->adapter->vport_params_recvd[vport->idx];

	caps = vport_msg->sideband_flow_caps;



	switch (flow_type) {

	case TCP_V4_FLOW:

		return !!(caps & cpu_to_le64(VIRTCHNL2_FLOW_IPV4_TCP));

	case UDP_V4_FLOW:

		return !!(caps & cpu_to_le64(VIRTCHNL2_FLOW_IPV4_UDP));

	default:

		return false;

	}

}



/**

 * idpf_sideband_action_ena - Check if steering is enabled for action

 * @vport: Private data struct

 * @fsp: flow spec

 *

 * Return: true if sideband filters are allowed for @fsp, false otherwise

 */

bool idpf_sideband_action_ena(struct idpf_vport *vport,

			      struct ethtool_rx_flow_spec *fsp)

{

	struct virtchnl2_create_vport *vport_msg;

	unsigned int supp_actions;



	vport_msg = vport->adapter->vport_params_recvd[vport->idx];

	supp_actions = le32_to_cpu(vport_msg->sideband_flow_actions);



	/* Actions Drop/Wake are not supported */

	if (fsp->ring_cookie == RX_CLS_FLOW_DISC ||

	    fsp->ring_cookie == RX_CLS_FLOW_WAKE)

		return false;



	return !!(supp_actions & VIRTCHNL2_ACTION_QUEUE);

}



unsigned int idpf_fsteer_max_rules(struct idpf_vport *vport)

{

	struct virtchnl2_create_vport *vport_msg;



	vport_msg = vport->adapter->vport_params_recvd[vport->idx];

	return le32_to_cpu(vport_msg->flow_steer_max_rules);

}



/**

 * idpf_get_vport_id: Get vport id

 * @vport: virtual port structure

drivers/net/ethernet/intel/idpf/idpf_virtchnl.h

+6 −0
Original line number Diff line number Diff line
@@ -105,6 +105,12 @@ int idpf_get_reg_intr_vecs(struct idpf_vport *vport, 
int idpf_queue_reg_init(struct idpf_vport *vport);

int idpf_vport_queue_ids_init(struct idpf_vport *vport);



bool idpf_vport_is_cap_ena(struct idpf_vport *vport, u16 flag);

bool idpf_sideband_flow_type_ena(struct idpf_vport *vport, u32 flow_type);

bool idpf_sideband_action_ena(struct idpf_vport *vport,

			      struct ethtool_rx_flow_spec *fsp);

unsigned int idpf_fsteer_max_rules(struct idpf_vport *vport);



int idpf_recv_mb_msg(struct idpf_adapter *adapter);

int idpf_send_mb_msg(struct idpf_adapter *adapter, u32 op,

		     u16 msg_size, u8 *msg, u16 cookie);