const struct rte_flow_item_ipv4 *spec = item->spec;
const struct rte_flow_item_ipv4 *mask = item->mask;
struct filter_ipv4_5tuple *enic_5tup = &enic_filter->u.ipv4;
- struct ipv4_hdr supported_mask = {
+ struct rte_ipv4_hdr supported_mask = {
.src_addr = 0xffffffff,
.dst_addr = 0xffffffff,
};
const struct rte_flow_item_udp *spec = item->spec;
const struct rte_flow_item_udp *mask = item->mask;
struct filter_ipv4_5tuple *enic_5tup = &enic_filter->u.ipv4;
- struct udp_hdr supported_mask = {
+ struct rte_udp_hdr supported_mask = {
.src_port = 0xffff,
.dst_port = 0xffff,
};
const struct rte_flow_item_tcp *spec = item->spec;
const struct rte_flow_item_tcp *mask = item->mask;
struct filter_ipv4_5tuple *enic_5tup = &enic_filter->u.ipv4;
- struct tcp_hdr supported_mask = {
+ struct rte_tcp_hdr supported_mask = {
.src_port = 0xffff,
.dst_port = 0xffff,
};
FLOW_TRACE();
if (!mask)
mask = &rte_flow_item_eth_mask;
- arg->l2_proto_off = *off + offsetof(struct ether_hdr, ether_type);
+ arg->l2_proto_off = *off + offsetof(struct rte_ether_hdr, ether_type);
return copy_inner_common(&arg->filter->u.generic_1, off,
- arg->item->spec, mask, sizeof(struct ether_hdr),
+ arg->item->spec, mask, sizeof(struct rte_ether_hdr),
0 /* no previous protocol */, 0, 0);
}
mask = &rte_flow_item_vlan_mask;
/* Append vlan header to L5 and set ether type = TPID */
eth_type_off = arg->l2_proto_off;
- arg->l2_proto_off = *off + offsetof(struct vlan_hdr, eth_proto);
+ arg->l2_proto_off = *off + offsetof(struct rte_vlan_hdr, eth_proto);
return copy_inner_common(&arg->filter->u.generic_1, off,
- arg->item->spec, mask, sizeof(struct vlan_hdr),
- eth_type_off, rte_cpu_to_be_16(ETHER_TYPE_VLAN), 2);
+ arg->item->spec, mask, sizeof(struct rte_vlan_hdr),
+ eth_type_off, rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN), 2);
}
static int
if (!mask)
mask = &rte_flow_item_ipv4_mask;
/* Append ipv4 header to L5 and set ether type = ipv4 */
- arg->l3_proto_off = *off + offsetof(struct ipv4_hdr, next_proto_id);
+ arg->l3_proto_off = *off + offsetof(struct rte_ipv4_hdr, next_proto_id);
return copy_inner_common(&arg->filter->u.generic_1, off,
- arg->item->spec, mask, sizeof(struct ipv4_hdr),
- arg->l2_proto_off, rte_cpu_to_be_16(ETHER_TYPE_IPv4), 2);
+ arg->item->spec, mask, sizeof(struct rte_ipv4_hdr),
+ arg->l2_proto_off, rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv4), 2);
}
static int
if (!mask)
mask = &rte_flow_item_ipv6_mask;
/* Append ipv6 header to L5 and set ether type = ipv6 */
- arg->l3_proto_off = *off + offsetof(struct ipv6_hdr, proto);
+ arg->l3_proto_off = *off + offsetof(struct rte_ipv6_hdr, proto);
return copy_inner_common(&arg->filter->u.generic_1, off,
- arg->item->spec, mask, sizeof(struct ipv6_hdr),
- arg->l2_proto_off, rte_cpu_to_be_16(ETHER_TYPE_IPv6), 2);
+ arg->item->spec, mask, sizeof(struct rte_ipv6_hdr),
+ arg->l2_proto_off, rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv6), 2);
}
static int
mask = &rte_flow_item_udp_mask;
/* Append udp header to L5 and set ip proto = udp */
return copy_inner_common(&arg->filter->u.generic_1, off,
- arg->item->spec, mask, sizeof(struct udp_hdr),
+ arg->item->spec, mask, sizeof(struct rte_udp_hdr),
arg->l3_proto_off, IPPROTO_UDP, 1);
}
mask = &rte_flow_item_tcp_mask;
/* Append tcp header to L5 and set ip proto = tcp */
return copy_inner_common(&arg->filter->u.generic_1, off,
- arg->item->spec, mask, sizeof(struct tcp_hdr),
+ arg->item->spec, mask, sizeof(struct rte_tcp_hdr),
arg->l3_proto_off, IPPROTO_TCP, 1);
}
{
const struct rte_flow_item *item = arg->item;
struct filter_v2 *enic_filter = arg->filter;
- struct ether_hdr enic_spec;
- struct ether_hdr enic_mask;
+ struct rte_ether_hdr enic_spec;
+ struct rte_ether_hdr enic_mask;
const struct rte_flow_item_eth *spec = item->spec;
const struct rte_flow_item_eth *mask = item->mask;
struct filter_generic_1 *gp = &enic_filter->u.generic_1;
mask = &rte_flow_item_eth_mask;
memcpy(enic_spec.d_addr.addr_bytes, spec->dst.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
memcpy(enic_spec.s_addr.addr_bytes, spec->src.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
memcpy(enic_mask.d_addr.addr_bytes, mask->dst.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
memcpy(enic_mask.s_addr.addr_bytes, mask->src.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
enic_spec.ether_type = spec->type;
enic_mask.ether_type = mask->type;
/* outer header */
memcpy(gp->layer[FILTER_GENERIC_1_L2].mask, &enic_mask,
- sizeof(struct ether_hdr));
+ sizeof(struct rte_ether_hdr));
memcpy(gp->layer[FILTER_GENERIC_1_L2].val, &enic_spec,
- sizeof(struct ether_hdr));
+ sizeof(struct rte_ether_hdr));
return 0;
}
const struct rte_flow_item_vlan *spec = item->spec;
const struct rte_flow_item_vlan *mask = item->mask;
struct filter_generic_1 *gp = &enic_filter->u.generic_1;
- struct ether_hdr *eth_mask;
- struct ether_hdr *eth_val;
+ struct rte_ether_hdr *eth_mask;
+ struct rte_ether_hdr *eth_val;
FLOW_TRACE();
* vlan tag remains in the L2 buffer.
*/
if (!arg->enic->vxlan && !arg->enic->ig_vlan_strip_en) {
- struct vlan_hdr *vlan;
+ struct rte_vlan_hdr *vlan;
- vlan = (struct vlan_hdr *)(eth_mask + 1);
+ vlan = (struct rte_vlan_hdr *)(eth_mask + 1);
vlan->eth_proto = mask->inner_type;
- vlan = (struct vlan_hdr *)(eth_val + 1);
+ vlan = (struct rte_vlan_hdr *)(eth_val + 1);
vlan->eth_proto = spec->inner_type;
} else {
eth_mask->ether_type = mask->inner_type;
mask = &rte_flow_item_ipv4_mask;
memcpy(gp->layer[FILTER_GENERIC_1_L3].mask, &mask->hdr,
- sizeof(struct ipv4_hdr));
+ sizeof(struct rte_ipv4_hdr));
memcpy(gp->layer[FILTER_GENERIC_1_L3].val, &spec->hdr,
- sizeof(struct ipv4_hdr));
+ sizeof(struct rte_ipv4_hdr));
return 0;
}
mask = &rte_flow_item_ipv6_mask;
memcpy(gp->layer[FILTER_GENERIC_1_L3].mask, &mask->hdr,
- sizeof(struct ipv6_hdr));
+ sizeof(struct rte_ipv6_hdr));
memcpy(gp->layer[FILTER_GENERIC_1_L3].val, &spec->hdr,
- sizeof(struct ipv6_hdr));
+ sizeof(struct rte_ipv6_hdr));
return 0;
}
mask = &rte_flow_item_udp_mask;
memcpy(gp->layer[FILTER_GENERIC_1_L4].mask, &mask->hdr,
- sizeof(struct udp_hdr));
+ sizeof(struct rte_udp_hdr));
memcpy(gp->layer[FILTER_GENERIC_1_L4].val, &spec->hdr,
- sizeof(struct udp_hdr));
+ sizeof(struct rte_udp_hdr));
return 0;
}
return ENOTSUP;
memcpy(gp->layer[FILTER_GENERIC_1_L4].mask, &mask->hdr,
- sizeof(struct tcp_hdr));
+ sizeof(struct rte_tcp_hdr));
memcpy(gp->layer[FILTER_GENERIC_1_L4].val, &spec->hdr,
- sizeof(struct tcp_hdr));
+ sizeof(struct rte_tcp_hdr));
return 0;
}
* the protocol number in the IP pattern.
*/
if (gp->val_flags & FILTER_GENERIC_1_IPV4) {
- struct ipv4_hdr *ip;
- ip = (struct ipv4_hdr *)gp->layer[FILTER_GENERIC_1_L3].mask;
+ struct rte_ipv4_hdr *ip;
+ ip = (struct rte_ipv4_hdr *)gp->layer[FILTER_GENERIC_1_L3].mask;
ip_proto_mask = &ip->next_proto_id;
- ip = (struct ipv4_hdr *)gp->layer[FILTER_GENERIC_1_L3].val;
+ ip = (struct rte_ipv4_hdr *)gp->layer[FILTER_GENERIC_1_L3].val;
ip_proto = &ip->next_proto_id;
} else if (gp->val_flags & FILTER_GENERIC_1_IPV6) {
- struct ipv6_hdr *ip;
- ip = (struct ipv6_hdr *)gp->layer[FILTER_GENERIC_1_L3].mask;
+ struct rte_ipv6_hdr *ip;
+ ip = (struct rte_ipv6_hdr *)gp->layer[FILTER_GENERIC_1_L3].mask;
ip_proto_mask = &ip->proto;
- ip = (struct ipv6_hdr *)gp->layer[FILTER_GENERIC_1_L3].val;
+ ip = (struct rte_ipv6_hdr *)gp->layer[FILTER_GENERIC_1_L3].val;
ip_proto = &ip->proto;
} else {
/* Need IPv4/IPv6 pattern first */
mask = &rte_flow_item_sctp_mask;
memcpy(gp->layer[FILTER_GENERIC_1_L4].mask, &mask->hdr,
- sizeof(struct sctp_hdr));
+ sizeof(struct rte_sctp_hdr));
memcpy(gp->layer[FILTER_GENERIC_1_L4].val, &spec->hdr,
- sizeof(struct sctp_hdr));
+ sizeof(struct rte_sctp_hdr));
return 0;
}
const struct rte_flow_item_vxlan *spec = item->spec;
const struct rte_flow_item_vxlan *mask = item->mask;
struct filter_generic_1 *gp = &enic_filter->u.generic_1;
- struct udp_hdr *udp;
+ struct rte_udp_hdr *udp;
FLOW_TRACE();
*/
gp->mask_flags |= FILTER_GENERIC_1_UDP;
gp->val_flags |= FILTER_GENERIC_1_UDP;
- udp = (struct udp_hdr *)gp->layer[FILTER_GENERIC_1_L4].mask;
+ udp = (struct rte_udp_hdr *)gp->layer[FILTER_GENERIC_1_L4].mask;
udp->dst_port = 0xffff;
- udp = (struct udp_hdr *)gp->layer[FILTER_GENERIC_1_L4].val;
+ udp = (struct rte_udp_hdr *)gp->layer[FILTER_GENERIC_1_L4].val;
udp->dst_port = RTE_BE16(4789);
/* Match all if no spec */
if (!spec)
mask = &rte_flow_item_vxlan_mask;
memcpy(gp->layer[FILTER_GENERIC_1_L5].mask, mask,
- sizeof(struct vxlan_hdr));
+ sizeof(struct rte_vxlan_hdr));
memcpy(gp->layer[FILTER_GENERIC_1_L5].val, spec,
- sizeof(struct vxlan_hdr));
+ sizeof(struct rte_vxlan_hdr));
- *inner_ofst = sizeof(struct vxlan_hdr);
+ *inner_ofst = sizeof(struct rte_vxlan_hdr);
return 0;
}
return EINVAL;
/* Need non-null pattern that fits within the NIC's filter pattern */
if (spec->length == 0 ||
- spec->length + sizeof(struct udp_hdr) > FILTER_GENERIC_1_KEY_LEN ||
+ spec->length + sizeof(struct rte_udp_hdr) > FILTER_GENERIC_1_KEY_LEN ||
!spec->pattern || !mask->pattern)
return EINVAL;
/*
*/
if (mask->length != 0 && mask->length < spec->length)
return EINVAL;
- memcpy(gp->layer[FILTER_GENERIC_1_L4].mask + sizeof(struct udp_hdr),
+ memcpy(gp->layer[FILTER_GENERIC_1_L4].mask + sizeof(struct rte_udp_hdr),
mask->pattern, spec->length);
- memcpy(gp->layer[FILTER_GENERIC_1_L4].val + sizeof(struct udp_hdr),
+ memcpy(gp->layer[FILTER_GENERIC_1_L4].val + sizeof(struct rte_udp_hdr),
spec->pattern, spec->length);
return 0;
if (!(inner_ofst > 0 && enic->vxlan))
return;
FLOW_TRACE();
- vxlan = sizeof(struct vxlan_hdr);
- memcpy(gp->layer[FILTER_GENERIC_1_L4].mask + sizeof(struct udp_hdr),
+ vxlan = sizeof(struct rte_vxlan_hdr);
+ memcpy(gp->layer[FILTER_GENERIC_1_L4].mask + sizeof(struct rte_udp_hdr),
gp->layer[FILTER_GENERIC_1_L5].mask, vxlan);
- memcpy(gp->layer[FILTER_GENERIC_1_L4].val + sizeof(struct udp_hdr),
+ memcpy(gp->layer[FILTER_GENERIC_1_L4].val + sizeof(struct rte_udp_hdr),
gp->layer[FILTER_GENERIC_1_L5].val, vxlan);
inner = inner_ofst - vxlan;
memset(layer, 0, sizeof(layer));