Skip to content

Commit

Permalink
ice: Add FDIR pattern action parser for VF
Browse files Browse the repository at this point in the history 
Add basic FDIR flow list and pattern / action parse functions for VF.

Signed-off-by: Yahui Cao <yahui.cao@intel.com>
Signed-off-by: Qi Zhang <qi.z.zhang@intel.com>
Tested-by: Chen Bo <BoX.C.Chen@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
  • Loading branch information
Qi Zhang authored and Tony Nguyen committed Mar 22, 2021
1 parent 1f7ea1c commit 0ce332f
Showing 1 changed file with 345 additions and 2 deletions.
347 changes: 345 additions & 2 deletions drivers/net/ethernet/intel/ice/ice_virtchnl_fdir.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,77 @@ struct virtchnl_fdir_fltr_conf {
struct ice_fdir_fltr input;
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv4[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV4,
VIRTCHNL_PROTO_HDR_NONE,
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv4_tcp[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV4,
VIRTCHNL_PROTO_HDR_TCP,
VIRTCHNL_PROTO_HDR_NONE,
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv4_udp[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV4,
VIRTCHNL_PROTO_HDR_UDP,
VIRTCHNL_PROTO_HDR_NONE,
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv4_sctp[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV4,
VIRTCHNL_PROTO_HDR_SCTP,
VIRTCHNL_PROTO_HDR_NONE,
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv6[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV6,
VIRTCHNL_PROTO_HDR_NONE,
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv6_tcp[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV6,
VIRTCHNL_PROTO_HDR_TCP,
VIRTCHNL_PROTO_HDR_NONE,
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv6_udp[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV6,
VIRTCHNL_PROTO_HDR_UDP,
VIRTCHNL_PROTO_HDR_NONE,
};

static enum virtchnl_proto_hdr_type vc_pattern_ipv6_sctp[] = {
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_IPV6,
VIRTCHNL_PROTO_HDR_SCTP,
VIRTCHNL_PROTO_HDR_NONE,
};

struct virtchnl_fdir_pattern_match_item {
enum virtchnl_proto_hdr_type *list;
u64 input_set;
u64 *meta;
};

static const struct virtchnl_fdir_pattern_match_item vc_fdir_pattern[] = {
{vc_pattern_ipv4, 0, NULL},
{vc_pattern_ipv4_tcp, 0, NULL},
{vc_pattern_ipv4_udp, 0, NULL},
{vc_pattern_ipv4_sctp, 0, NULL},
{vc_pattern_ipv6, 0, NULL},
{vc_pattern_ipv6_tcp, 0, NULL},
{vc_pattern_ipv6_udp, 0, NULL},
{vc_pattern_ipv6_sctp, 0, NULL},
};

struct virtchnl_fdir_inset_map {
enum virtchnl_proto_hdr_field field;
enum ice_flow_field fld;
Expand Down Expand Up @@ -598,6 +669,269 @@ ice_vc_fdir_config_input_set(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
return ret;
}

/**
* ice_vc_fdir_match_pattern
* @fltr: virtual channel add cmd buffer
* @type: virtual channel protocol filter header type
*
* Matching the header type by comparing fltr and type's value.
*
* Return: true on success, and false on error.
*/
static bool
ice_vc_fdir_match_pattern(struct virtchnl_fdir_add *fltr,
enum virtchnl_proto_hdr_type *type)
{
struct virtchnl_proto_hdrs *proto = &fltr->rule_cfg.proto_hdrs;
int i = 0;

while ((i < proto->count) &&
(*type == proto->proto_hdr[i].type) &&
(*type != VIRTCHNL_PROTO_HDR_NONE)) {
type++;
i++;
}

return ((i == proto->count) && (*type == VIRTCHNL_PROTO_HDR_NONE));
}

/**
* ice_vc_fdir_get_pattern - get while list pattern
* @vf: pointer to the VF info
* @len: filter list length
*
* Return: pointer to allowed filter list
*/
static const struct virtchnl_fdir_pattern_match_item *
ice_vc_fdir_get_pattern(struct ice_vf *vf, int *len)
{
const struct virtchnl_fdir_pattern_match_item *item;

item = vc_fdir_pattern;
*len = ARRAY_SIZE(vc_fdir_pattern);

return item;
}

/**
* ice_vc_fdir_search_pattern
* @vf: pointer to the VF info
* @fltr: virtual channel add cmd buffer
*
* Search for matched pattern from supported pattern list
*
* Return: 0 on success, and other on error.
*/
static int
ice_vc_fdir_search_pattern(struct ice_vf *vf, struct virtchnl_fdir_add *fltr)
{
const struct virtchnl_fdir_pattern_match_item *pattern;
int len, i;

pattern = ice_vc_fdir_get_pattern(vf, &len);

for (i = 0; i < len; i++)
if (ice_vc_fdir_match_pattern(fltr, pattern[i].list))
return 0;

return -EINVAL;
}

/**
* ice_vc_fdir_parse_pattern
* @vf: pointer to the VF info
* @fltr: virtual channel add cmd buffer
* @conf: FDIR configuration for each filter
*
* Parse the virtual channel filter's pattern and store them into conf
*
* Return: 0 on success, and other on error.
*/
static int
ice_vc_fdir_parse_pattern(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
struct virtchnl_fdir_fltr_conf *conf)
{
struct virtchnl_proto_hdrs *proto = &fltr->rule_cfg.proto_hdrs;
enum virtchnl_proto_hdr_type l3 = VIRTCHNL_PROTO_HDR_NONE;
struct device *dev = ice_pf_to_dev(vf->pf);
struct ice_fdir_fltr *input = &conf->input;
int i;

if (proto->count > VIRTCHNL_MAX_NUM_PROTO_HDRS) {
dev_dbg(dev, "Invalid protocol count:0x%x for VF %d\n",
proto->count, vf->vf_id);
return -EINVAL;
}

for (i = 0; i < proto->count; i++) {
struct virtchnl_proto_hdr *hdr = &proto->proto_hdr[i];
struct sctphdr *sctph;
struct ipv6hdr *ip6h;
struct udphdr *udph;
struct tcphdr *tcph;
struct iphdr *iph;

switch (hdr->type) {
case VIRTCHNL_PROTO_HDR_ETH:
break;
case VIRTCHNL_PROTO_HDR_IPV4:
iph = (struct iphdr *)hdr->buffer;
l3 = VIRTCHNL_PROTO_HDR_IPV4;
input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_OTHER;

if (hdr->field_selector) {
input->ip.v4.src_ip = iph->saddr;
input->ip.v4.dst_ip = iph->daddr;
input->ip.v4.tos = iph->tos;
input->ip.v4.proto = iph->protocol;
}
break;
case VIRTCHNL_PROTO_HDR_IPV6:
ip6h = (struct ipv6hdr *)hdr->buffer;
l3 = VIRTCHNL_PROTO_HDR_IPV6;
input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_OTHER;

if (hdr->field_selector) {
memcpy(input->ip.v6.src_ip,
ip6h->saddr.in6_u.u6_addr8,
sizeof(ip6h->saddr));
memcpy(input->ip.v6.dst_ip,
ip6h->daddr.in6_u.u6_addr8,
sizeof(ip6h->daddr));
input->ip.v6.tc = ((u8)(ip6h->priority) << 4) |
(ip6h->flow_lbl[0] >> 4);
input->ip.v6.proto = ip6h->nexthdr;
}
break;
case VIRTCHNL_PROTO_HDR_TCP:
tcph = (struct tcphdr *)hdr->buffer;
if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_TCP;
else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_TCP;

if (hdr->field_selector) {
if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
input->ip.v4.src_port = tcph->source;
input->ip.v4.dst_port = tcph->dest;
} else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
input->ip.v6.src_port = tcph->source;
input->ip.v6.dst_port = tcph->dest;
}
}
break;
case VIRTCHNL_PROTO_HDR_UDP:
udph = (struct udphdr *)hdr->buffer;
if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_UDP;
else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_UDP;

if (hdr->field_selector) {
if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
input->ip.v4.src_port = udph->source;
input->ip.v4.dst_port = udph->dest;
} else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
input->ip.v6.src_port = udph->source;
input->ip.v6.dst_port = udph->dest;
}
}
break;
case VIRTCHNL_PROTO_HDR_SCTP:
sctph = (struct sctphdr *)hdr->buffer;
if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
input->flow_type =
ICE_FLTR_PTYPE_NONF_IPV4_SCTP;
else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
input->flow_type =
ICE_FLTR_PTYPE_NONF_IPV6_SCTP;

if (hdr->field_selector) {
if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
input->ip.v4.src_port = sctph->source;
input->ip.v4.dst_port = sctph->dest;
} else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
input->ip.v6.src_port = sctph->source;
input->ip.v6.dst_port = sctph->dest;
}
}
break;
default:
dev_dbg(dev, "Invalid header type 0x:%x for VF %d\n",
hdr->type, vf->vf_id);
return -EINVAL;
}
}

return 0;
}

/**
* ice_vc_fdir_parse_action
* @vf: pointer to the VF info
* @fltr: virtual channel add cmd buffer
* @conf: FDIR configuration for each filter
*
* Parse the virtual channel filter's action and store them into conf
*
* Return: 0 on success, and other on error.
*/
static int
ice_vc_fdir_parse_action(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
struct virtchnl_fdir_fltr_conf *conf)
{
struct virtchnl_filter_action_set *as = &fltr->rule_cfg.action_set;
struct device *dev = ice_pf_to_dev(vf->pf);
struct ice_fdir_fltr *input = &conf->input;
u32 dest_num = 0;
u32 mark_num = 0;
int i;

if (as->count > VIRTCHNL_MAX_NUM_ACTIONS) {
dev_dbg(dev, "Invalid action numbers:0x%x for VF %d\n",
as->count, vf->vf_id);
return -EINVAL;
}

for (i = 0; i < as->count; i++) {
struct virtchnl_filter_action *action = &as->actions[i];

switch (action->type) {
case VIRTCHNL_ACTION_DROP:
dest_num++;
input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DROP_PKT;
break;
case VIRTCHNL_ACTION_QUEUE:
dest_num++;
input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QINDEX;
input->q_index = action->act_conf.queue.index;
break;
case VIRTCHNL_ACTION_MARK:
mark_num++;
input->fltr_id = action->act_conf.mark_id;
input->fdid_prio = ICE_FXD_FLTR_QW1_FDID_PRI_THREE;
break;
default:
dev_dbg(dev, "Invalid action type:0x%x for VF %d\n",
action->type, vf->vf_id);
return -EINVAL;
}
}

if (dest_num == 0 || dest_num >= 2) {
dev_dbg(dev, "Invalid destination action for VF %d\n",
vf->vf_id);
return -EINVAL;
}

if (mark_num >= 2) {
dev_dbg(dev, "Too many mark actions for VF %d\n", vf->vf_id);
return -EINVAL;
}

return 0;
}

/**
* ice_vc_validate_fdir_fltr - validate the virtual channel filter
* @vf: pointer to the VF info
Expand All @@ -610,8 +944,17 @@ static int
ice_vc_validate_fdir_fltr(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
struct virtchnl_fdir_fltr_conf *conf)
{
/* Todo: rule validation */
return -EINVAL;
int ret;

ret = ice_vc_fdir_search_pattern(vf, fltr);
if (ret)
return ret;

ret = ice_vc_fdir_parse_pattern(vf, fltr, conf);
if (ret)
return ret;

return ice_vc_fdir_parse_action(vf, fltr, conf);
}

/**
Expand Down

0 comments on commit 0ce332f

Please sign in to comment.