#include <rte_flow.h>
#include <rte_hexdump.h>
#include <rte_vxlan.h>
+#include <rte_gre.h>
+#include <rte_mpls.h>
+#include <rte_gtp.h>
+#include <rte_geneve.h>
#include "testpmd.h"
SHARED_ACTION_CREATE_ID,
SHARED_ACTION_INGRESS,
SHARED_ACTION_EGRESS,
+ SHARED_ACTION_TRANSFER,
SHARED_ACTION_SPEC,
/* Shared action destroy arguments */
SHARED_ACTION_CREATE_ID,
SHARED_ACTION_INGRESS,
SHARED_ACTION_EGRESS,
+ SHARED_ACTION_TRANSFER,
SHARED_ACTION_SPEC,
ZERO,
};
ZERO,
};
-static const enum index tunnel_create_attr[] = {
- TUNNEL_CREATE,
- TUNNEL_CREATE_TYPE,
- END,
- ZERO,
-};
-
-static const enum index tunnel_destroy_attr[] = {
- TUNNEL_DESTROY,
- TUNNEL_DESTROY_ID,
- END,
- ZERO,
-};
-
-static const enum index tunnel_list_attr[] = {
- TUNNEL_LIST,
- END,
- ZERO,
-};
-
static const enum index next_destroy_attr[] = {
DESTROY_RULE,
END,
[TUNNEL_CREATE] = {
.name = "create",
.help = "create new tunnel object",
- .next = NEXT(tunnel_create_attr, NEXT_ENTRY(PORT_ID)),
+ .next = NEXT(NEXT_ENTRY(TUNNEL_CREATE_TYPE),
+ NEXT_ENTRY(PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_tunnel,
},
[TUNNEL_CREATE_TYPE] = {
.name = "type",
.help = "create new tunnel",
- .next = NEXT(tunnel_create_attr, NEXT_ENTRY(FILE_PATH)),
+ .next = NEXT(NEXT_ENTRY(FILE_PATH)),
.args = ARGS(ARGS_ENTRY(struct tunnel_ops, type)),
.call = parse_tunnel,
},
[TUNNEL_DESTROY] = {
.name = "destroy",
.help = "destroy tunel",
- .next = NEXT(tunnel_destroy_attr, NEXT_ENTRY(PORT_ID)),
+ .next = NEXT(NEXT_ENTRY(TUNNEL_DESTROY_ID),
+ NEXT_ENTRY(PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_tunnel,
},
[TUNNEL_DESTROY_ID] = {
.name = "id",
.help = "tunnel identifier to testroy",
- .next = NEXT(tunnel_destroy_attr, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(NEXT_ENTRY(UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
.call = parse_tunnel,
},
[TUNNEL_LIST] = {
.name = "list",
.help = "list existing tunnels",
- .next = NEXT(tunnel_list_attr, NEXT_ENTRY(PORT_ID)),
+ .next = NEXT(NEXT_ENTRY(PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_tunnel,
},
[ITEM_ECPRI_MSG_IQ_DATA_PCID] = {
.name = "pc_id",
.help = "Physical Channel ID",
- .next = NEXT(item_ecpri, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_IQ_DATA_PCID,
+ ITEM_ECPRI_COMMON, ITEM_NEXT),
+ NEXT_ENTRY(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type0.pc_id)),
},
[ITEM_ECPRI_MSG_RTC_CTRL_RTCID] = {
.name = "rtc_id",
.help = "Real-Time Control Data ID",
- .next = NEXT(item_ecpri, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_RTC_CTRL_RTCID,
+ ITEM_ECPRI_COMMON, ITEM_NEXT),
+ NEXT_ENTRY(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type2.rtc_id)),
},
[ITEM_ECPRI_MSG_DLY_MSR_MSRID] = {
.name = "msr_id",
.help = "Measurement ID",
- .next = NEXT(item_ecpri, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_DLY_MSR_MSRID,
+ ITEM_ECPRI_COMMON, ITEM_NEXT),
+ NEXT_ENTRY(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type5.msr_id)),
},
.next = NEXT(next_sa_create_attr),
.call = parse_sa,
},
+ [SHARED_ACTION_TRANSFER] = {
+ .name = "transfer",
+ .help = "affect rule to transfer",
+ .next = NEXT(next_sa_create_attr),
+ .call = parse_sa,
+ },
[SHARED_ACTION_SPEC] = {
.name = "action",
.help = "specify action to share",
case SHARED_ACTION_INGRESS:
out->args.vc.attr.ingress = 1;
return len;
+ case SHARED_ACTION_TRANSFER:
+ out->args.vc.attr.transfer = 1;
+ return len;
default:
return -1;
}
.func = RTE_ETH_HASH_FUNCTION_DEFAULT,
.level = 0,
.types = rss_hf,
- .key_len = sizeof(action_rss_data->key),
+ .key_len = 0,
.queue_num = RTE_MIN(nb_rxq, ACTION_RSS_QUEUE_NUM),
- .key = action_rss_data->key,
+ .key = NULL,
.queue = action_rss_data->queue,
},
- .key = "testpmd's default RSS hash key, "
- "override it for better balancing",
.queue = { 0 },
};
for (i = 0; i < action_rss_data->conf.queue_num; ++i)
action_rss_data->queue[i] = i;
- if (!port_id_is_invalid(ctx->port, DISABLED_WARN) &&
- ctx->port != (portid_t)RTE_PORT_ALL) {
- struct rte_eth_dev_info info;
- int ret2;
-
- ret2 = rte_eth_dev_info_get(ctx->port, &info);
- if (ret2 != 0)
- return ret2;
-
- action_rss_data->conf.key_len =
- RTE_MIN(sizeof(action_rss_data->key),
- info.hash_key_size);
- }
action->conf = &action_rss_data->conf;
return ret;
}
&((const struct rte_flow_shared_action_conf) {
.ingress = in->args.vc.attr.ingress,
.egress = in->args.vc.attr.egress,
+ .transfer = in->args.vc.attr.transfer,
}),
in->args.vc.actions);
break;
static void
update_fields(uint8_t *buf, struct rte_flow_item *item, uint16_t next_proto)
{
- struct rte_flow_item_ipv4 *ipv4;
- struct rte_flow_item_eth *eth;
- struct rte_flow_item_ipv6 *ipv6;
- struct rte_flow_item_vxlan *vxlan;
- struct rte_flow_item_vxlan_gpe *gpe;
+ struct rte_ipv4_hdr *ipv4;
+ struct rte_ether_hdr *eth;
+ struct rte_ipv6_hdr *ipv6;
+ struct rte_vxlan_hdr *vxlan;
+ struct rte_vxlan_gpe_hdr *gpe;
struct rte_flow_item_nvgre *nvgre;
uint32_t ipv6_vtc_flow;
switch (item->type) {
case RTE_FLOW_ITEM_TYPE_ETH:
- eth = (struct rte_flow_item_eth *)buf;
+ eth = (struct rte_ether_hdr *)buf;
if (next_proto)
- eth->type = rte_cpu_to_be_16(next_proto);
+ eth->ether_type = rte_cpu_to_be_16(next_proto);
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
- ipv4 = (struct rte_flow_item_ipv4 *)buf;
- ipv4->hdr.version_ihl = 0x45;
- if (next_proto && ipv4->hdr.next_proto_id == 0)
- ipv4->hdr.next_proto_id = (uint8_t)next_proto;
+ ipv4 = (struct rte_ipv4_hdr *)buf;
+ ipv4->version_ihl = 0x45;
+ if (next_proto && ipv4->next_proto_id == 0)
+ ipv4->next_proto_id = (uint8_t)next_proto;
break;
case RTE_FLOW_ITEM_TYPE_IPV6:
- ipv6 = (struct rte_flow_item_ipv6 *)buf;
- if (next_proto && ipv6->hdr.proto == 0)
- ipv6->hdr.proto = (uint8_t)next_proto;
- ipv6_vtc_flow = rte_be_to_cpu_32(ipv6->hdr.vtc_flow);
+ ipv6 = (struct rte_ipv6_hdr *)buf;
+ if (next_proto && ipv6->proto == 0)
+ ipv6->proto = (uint8_t)next_proto;
+ ipv6_vtc_flow = rte_be_to_cpu_32(ipv6->vtc_flow);
ipv6_vtc_flow &= 0x0FFFFFFF; /*< reset version bits. */
ipv6_vtc_flow |= 0x60000000; /*< set ipv6 version. */
- ipv6->hdr.vtc_flow = rte_cpu_to_be_32(ipv6_vtc_flow);
+ ipv6->vtc_flow = rte_cpu_to_be_32(ipv6_vtc_flow);
break;
case RTE_FLOW_ITEM_TYPE_VXLAN:
- vxlan = (struct rte_flow_item_vxlan *)buf;
- vxlan->flags = 0x08;
+ vxlan = (struct rte_vxlan_hdr *)buf;
+ vxlan->vx_flags = 0x08;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
- gpe = (struct rte_flow_item_vxlan_gpe *)buf;
- gpe->flags = 0x0C;
+ gpe = (struct rte_vxlan_gpe_hdr *)buf;
+ gpe->vx_flags = 0x0C;
break;
case RTE_FLOW_ITEM_TYPE_NVGRE:
nvgre = (struct rte_flow_item_nvgre *)buf;
uint16_t upper_layer = 0;
uint16_t proto = 0;
uint16_t idx = in->port; /* We borrow port field as index */
+ int gtp_psc = -1; /* GTP PSC option index. */
if (in->command == SET_SAMPLE_ACTIONS)
return cmd_set_raw_parsed_sample(in);
/* process hdr from upper layer to low layer (L3/L4 -> L2). */
data_tail = data + ACTION_RAW_ENCAP_MAX_DATA;
for (i = n - 1 ; i >= 0; --i) {
+ const struct rte_flow_item_gtp *gtp;
+
item = in->args.vc.pattern + i;
if (item->spec == NULL)
item->spec = flow_item_default_mask(item);
switch (item->type) {
case RTE_FLOW_ITEM_TYPE_ETH:
- size = sizeof(struct rte_flow_item_eth);
+ size = sizeof(struct rte_ether_hdr);
break;
case RTE_FLOW_ITEM_TYPE_VLAN:
- size = sizeof(struct rte_flow_item_vlan);
+ size = sizeof(struct rte_vlan_hdr);
proto = RTE_ETHER_TYPE_VLAN;
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
- size = sizeof(struct rte_flow_item_ipv4);
+ size = sizeof(struct rte_ipv4_hdr);
proto = RTE_ETHER_TYPE_IPV4;
break;
case RTE_FLOW_ITEM_TYPE_IPV6:
- size = sizeof(struct rte_flow_item_ipv6);
+ size = sizeof(struct rte_ipv6_hdr);
proto = RTE_ETHER_TYPE_IPV6;
break;
case RTE_FLOW_ITEM_TYPE_UDP:
- size = sizeof(struct rte_flow_item_udp);
+ size = sizeof(struct rte_udp_hdr);
proto = 0x11;
break;
case RTE_FLOW_ITEM_TYPE_TCP:
- size = sizeof(struct rte_flow_item_tcp);
+ size = sizeof(struct rte_tcp_hdr);
proto = 0x06;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN:
- size = sizeof(struct rte_flow_item_vxlan);
+ size = sizeof(struct rte_vxlan_hdr);
break;
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
- size = sizeof(struct rte_flow_item_vxlan_gpe);
+ size = sizeof(struct rte_vxlan_gpe_hdr);
break;
case RTE_FLOW_ITEM_TYPE_GRE:
- size = sizeof(struct rte_flow_item_gre);
+ size = sizeof(struct rte_gre_hdr);
proto = 0x2F;
break;
case RTE_FLOW_ITEM_TYPE_GRE_KEY:
proto = 0x0;
break;
case RTE_FLOW_ITEM_TYPE_MPLS:
- size = sizeof(struct rte_flow_item_mpls);
+ size = sizeof(struct rte_mpls_hdr);
proto = 0x0;
break;
case RTE_FLOW_ITEM_TYPE_NVGRE:
proto = 0x2F;
break;
case RTE_FLOW_ITEM_TYPE_GENEVE:
- size = sizeof(struct rte_flow_item_geneve);
+ size = sizeof(struct rte_geneve_hdr);
break;
case RTE_FLOW_ITEM_TYPE_L2TPV3OIP:
- size = sizeof(struct rte_flow_item_l2tpv3oip);
+ size = sizeof(rte_be32_t);
proto = 0x73;
break;
case RTE_FLOW_ITEM_TYPE_ESP:
- size = sizeof(struct rte_flow_item_esp);
+ size = sizeof(struct rte_esp_hdr);
proto = 0x32;
break;
case RTE_FLOW_ITEM_TYPE_AH:
proto = 0x33;
break;
case RTE_FLOW_ITEM_TYPE_GTP:
- size = sizeof(struct rte_flow_item_gtp);
+ if (gtp_psc < 0) {
+ size = sizeof(struct rte_gtp_hdr);
+ break;
+ }
+ if (gtp_psc != i + 1) {
+ printf("Error - GTP PSC does not follow GTP\n");
+ goto error;
+ }
+ gtp = item->spec;
+ if ((gtp->v_pt_rsv_flags & 0x07) != 0x04) {
+ /* Only E flag should be set. */
+ printf("Error - GTP unsupported flags\n");
+ goto error;
+ } else {
+ struct rte_gtp_hdr_ext_word ext_word = {
+ .next_ext = 0x85
+ };
+
+ /* We have to add GTP header extra word. */
+ *total_size += sizeof(ext_word);
+ rte_memcpy(data_tail - (*total_size),
+ &ext_word, sizeof(ext_word));
+ }
+ size = sizeof(struct rte_gtp_hdr);
+ break;
+ case RTE_FLOW_ITEM_TYPE_GTP_PSC:
+ if (gtp_psc >= 0) {
+ printf("Error - Multiple GTP PSC items\n");
+ goto error;
+ } else {
+ const struct rte_flow_item_gtp_psc
+ *opt = item->spec;
+ struct {
+ uint8_t len;
+ uint8_t pdu_type;
+ uint8_t qfi;
+ uint8_t next;
+ } psc;
+
+ if (opt->pdu_type & 0x0F) {
+ /* Support the minimal option only. */
+ printf("Error - GTP PSC option with "
+ "extra fields not supported\n");
+ goto error;
+ }
+ psc.len = sizeof(psc);
+ psc.pdu_type = opt->pdu_type;
+ psc.qfi = opt->qfi;
+ psc.next = 0;
+ *total_size += sizeof(psc);
+ rte_memcpy(data_tail - (*total_size),
+ &psc, sizeof(psc));
+ gtp_psc = i;
+ size = 0;
+ }
break;
case RTE_FLOW_ITEM_TYPE_PFCP:
size = sizeof(struct rte_flow_item_pfcp);
break;
default:
printf("Error - Not supported item\n");
- *total_size = 0;
- memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA);
- return;
+ goto error;
}
*total_size += size;
rte_memcpy(data_tail - (*total_size), item->spec, size);
printf("total data size is %zu\n", (*total_size));
RTE_ASSERT((*total_size) <= ACTION_RAW_ENCAP_MAX_DATA);
memmove(data, (data_tail - (*total_size)), *total_size);
+ return;
+
+error:
+ *total_size = 0;
+ memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA);
}
/** Populate help strings for current token (cmdline API). */
cmd_what, "raw_encap#raw_decap");
cmdline_parse_token_num_t cmd_show_set_raw_cmd_index =
TOKEN_NUM_INITIALIZER(struct cmd_show_set_raw_result,
- cmd_index, UINT16);
+ cmd_index, RTE_UINT16);
cmdline_parse_token_string_t cmd_show_set_raw_cmd_all =
TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result,
cmd_all, "all");
git.droids-corp.org / dpdk.git / blobdiff