d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
c4e442fa4c
numam-dpdk/app/test-pmd/cmdline_flow.c
Jiawei Wang c4e442fa4c ethdev: add IPv4/IPv6 ECN header rewrite action 
This patch introduces the IPv4/IPv6 ECN modify field support, and
adds the testpmd CLI commands support.

Usage:
	modify_field op set dst_type ipv4_ecn src_type ...

For example:

flow create 0 ingress group 1 pattern eth / ipv4 /  end actions
	modify_field op set dst_type ipv4_ecn src_type value src_value
	0x03 width 2 / queue index 0 / end

Signed-off-by: Jiawei Wang <jiaweiw@nvidia.com>
Acked-by: Ori Kam <orika@nvidia.com>
2022-06-02 11:58:38 +02:00

11266 lines
295 KiB
C
Raw Blame History

/* SPDX-License-Identifier: BSD-3-Clause
* Copyright 2016 6WIND S.A.
* Copyright 2016 Mellanox Technologies, Ltd
*/
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>
#include <errno.h>
#include <ctype.h>
#include <string.h>
#include <rte_string_fns.h>
#include <rte_common.h>
#include <rte_ethdev.h>
#include <rte_byteorder.h>
#include <cmdline_parse.h>
#include <cmdline_parse_etheraddr.h>
#include <cmdline_parse_string.h>
#include <cmdline_parse_num.h>
#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"
/** Parser token indices. */
enum index {
/* Special tokens. */
ZERO = 0,
END,
START_SET,
END_SET,
/* Common tokens. */
COMMON_INTEGER,
COMMON_UNSIGNED,
COMMON_PREFIX,
COMMON_BOOLEAN,
COMMON_STRING,
COMMON_HEX,
COMMON_FILE_PATH,
COMMON_MAC_ADDR,
COMMON_IPV4_ADDR,
COMMON_IPV6_ADDR,
COMMON_RULE_ID,
COMMON_PORT_ID,
COMMON_GROUP_ID,
COMMON_PRIORITY_LEVEL,
COMMON_INDIRECT_ACTION_ID,
COMMON_POLICY_ID,
COMMON_FLEX_HANDLE,
COMMON_FLEX_TOKEN,
COMMON_PATTERN_TEMPLATE_ID,
COMMON_ACTIONS_TEMPLATE_ID,
COMMON_TABLE_ID,
COMMON_QUEUE_ID,
/* TOP-level command. */
ADD,
/* Top-level command. */
SET,
/* Sub-leve commands. */
SET_RAW_ENCAP,
SET_RAW_DECAP,
SET_RAW_INDEX,
SET_SAMPLE_ACTIONS,
SET_SAMPLE_INDEX,
/* Top-level command. */
FLOW,
/* Sub-level commands. */
INFO,
CONFIGURE,
PATTERN_TEMPLATE,
ACTIONS_TEMPLATE,
TABLE,
INDIRECT_ACTION,
VALIDATE,
CREATE,
DESTROY,
FLUSH,
DUMP,
QUERY,
LIST,
AGED,
ISOLATE,
TUNNEL,
FLEX,
QUEUE,
PUSH,
PULL,
/* Flex arguments */
FLEX_ITEM_INIT,
FLEX_ITEM_CREATE,
FLEX_ITEM_DESTROY,
/* Pattern template arguments. */
PATTERN_TEMPLATE_CREATE,
PATTERN_TEMPLATE_DESTROY,
PATTERN_TEMPLATE_CREATE_ID,
PATTERN_TEMPLATE_DESTROY_ID,
PATTERN_TEMPLATE_RELAXED_MATCHING,
PATTERN_TEMPLATE_INGRESS,
PATTERN_TEMPLATE_EGRESS,
PATTERN_TEMPLATE_TRANSFER,
PATTERN_TEMPLATE_SPEC,
/* Actions template arguments. */
ACTIONS_TEMPLATE_CREATE,
ACTIONS_TEMPLATE_DESTROY,
ACTIONS_TEMPLATE_CREATE_ID,
ACTIONS_TEMPLATE_DESTROY_ID,
ACTIONS_TEMPLATE_INGRESS,
ACTIONS_TEMPLATE_EGRESS,
ACTIONS_TEMPLATE_TRANSFER,
ACTIONS_TEMPLATE_SPEC,
ACTIONS_TEMPLATE_MASK,
/* Queue arguments. */
QUEUE_CREATE,
QUEUE_DESTROY,
QUEUE_INDIRECT_ACTION,
/* Queue create arguments. */
QUEUE_CREATE_ID,
QUEUE_CREATE_POSTPONE,
QUEUE_TEMPLATE_TABLE,
QUEUE_PATTERN_TEMPLATE,
QUEUE_ACTIONS_TEMPLATE,
QUEUE_SPEC,
/* Queue destroy arguments. */
QUEUE_DESTROY_ID,
QUEUE_DESTROY_POSTPONE,
/* Queue indirect action arguments */
QUEUE_INDIRECT_ACTION_CREATE,
QUEUE_INDIRECT_ACTION_UPDATE,
QUEUE_INDIRECT_ACTION_DESTROY,
/* Queue indirect action create arguments */
QUEUE_INDIRECT_ACTION_CREATE_ID,
QUEUE_INDIRECT_ACTION_INGRESS,
QUEUE_INDIRECT_ACTION_EGRESS,
QUEUE_INDIRECT_ACTION_TRANSFER,
QUEUE_INDIRECT_ACTION_CREATE_POSTPONE,
QUEUE_INDIRECT_ACTION_SPEC,
/* Queue indirect action update arguments */
QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE,
/* Queue indirect action destroy arguments */
QUEUE_INDIRECT_ACTION_DESTROY_ID,
QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE,
/* Push arguments. */
PUSH_QUEUE,
/* Pull arguments. */
PULL_QUEUE,
/* Table arguments. */
TABLE_CREATE,
TABLE_DESTROY,
TABLE_CREATE_ID,
TABLE_DESTROY_ID,
TABLE_GROUP,
TABLE_PRIORITY,
TABLE_INGRESS,
TABLE_EGRESS,
TABLE_TRANSFER,
TABLE_RULES_NUMBER,
TABLE_PATTERN_TEMPLATE,
TABLE_ACTIONS_TEMPLATE,
/* Tunnel arguments. */
TUNNEL_CREATE,
TUNNEL_CREATE_TYPE,
TUNNEL_LIST,
TUNNEL_DESTROY,
TUNNEL_DESTROY_ID,
/* Destroy arguments. */
DESTROY_RULE,
/* Query arguments. */
QUERY_ACTION,
/* List arguments. */
LIST_GROUP,
/* Destroy aged flow arguments. */
AGED_DESTROY,
/* Validate/create arguments. */
VC_GROUP,
VC_PRIORITY,
VC_INGRESS,
VC_EGRESS,
VC_TRANSFER,
VC_TUNNEL_SET,
VC_TUNNEL_MATCH,
/* Dump arguments */
DUMP_ALL,
DUMP_ONE,
/* Configure arguments */
CONFIG_QUEUES_NUMBER,
CONFIG_QUEUES_SIZE,
CONFIG_COUNTERS_NUMBER,
CONFIG_AGING_OBJECTS_NUMBER,
CONFIG_METERS_NUMBER,
/* Indirect action arguments */
INDIRECT_ACTION_CREATE,
INDIRECT_ACTION_UPDATE,
INDIRECT_ACTION_DESTROY,
INDIRECT_ACTION_QUERY,
/* Indirect action create arguments */
INDIRECT_ACTION_CREATE_ID,
INDIRECT_ACTION_INGRESS,
INDIRECT_ACTION_EGRESS,
INDIRECT_ACTION_TRANSFER,
INDIRECT_ACTION_SPEC,
/* Indirect action destroy arguments */
INDIRECT_ACTION_DESTROY_ID,
/* Validate/create pattern. */
ITEM_PATTERN,
ITEM_PARAM_IS,
ITEM_PARAM_SPEC,
ITEM_PARAM_LAST,
ITEM_PARAM_MASK,
ITEM_PARAM_PREFIX,
ITEM_NEXT,
ITEM_END,
ITEM_VOID,
ITEM_INVERT,
ITEM_ANY,
ITEM_ANY_NUM,
ITEM_PF,
ITEM_VF,
ITEM_VF_ID,
ITEM_PHY_PORT,
ITEM_PHY_PORT_INDEX,
ITEM_PORT_ID,
ITEM_PORT_ID_ID,
ITEM_MARK,
ITEM_MARK_ID,
ITEM_RAW,
ITEM_RAW_RELATIVE,
ITEM_RAW_SEARCH,
ITEM_RAW_OFFSET,
ITEM_RAW_LIMIT,
ITEM_RAW_PATTERN,
ITEM_RAW_PATTERN_HEX,
ITEM_ETH,
ITEM_ETH_DST,
ITEM_ETH_SRC,
ITEM_ETH_TYPE,
ITEM_ETH_HAS_VLAN,
ITEM_VLAN,
ITEM_VLAN_TCI,
ITEM_VLAN_PCP,
ITEM_VLAN_DEI,
ITEM_VLAN_VID,
ITEM_VLAN_INNER_TYPE,
ITEM_VLAN_HAS_MORE_VLAN,
ITEM_IPV4,
ITEM_IPV4_VER_IHL,
ITEM_IPV4_TOS,
ITEM_IPV4_ID,
ITEM_IPV4_FRAGMENT_OFFSET,
ITEM_IPV4_TTL,
ITEM_IPV4_PROTO,
ITEM_IPV4_SRC,
ITEM_IPV4_DST,
ITEM_IPV6,
ITEM_IPV6_TC,
ITEM_IPV6_FLOW,
ITEM_IPV6_PROTO,
ITEM_IPV6_HOP,
ITEM_IPV6_SRC,
ITEM_IPV6_DST,
ITEM_IPV6_HAS_FRAG_EXT,
ITEM_ICMP,
ITEM_ICMP_TYPE,
ITEM_ICMP_CODE,
ITEM_ICMP_IDENT,
ITEM_ICMP_SEQ,
ITEM_UDP,
ITEM_UDP_SRC,
ITEM_UDP_DST,
ITEM_TCP,
ITEM_TCP_SRC,
ITEM_TCP_DST,
ITEM_TCP_FLAGS,
ITEM_SCTP,
ITEM_SCTP_SRC,
ITEM_SCTP_DST,
ITEM_SCTP_TAG,
ITEM_SCTP_CKSUM,
ITEM_VXLAN,
ITEM_VXLAN_VNI,
ITEM_VXLAN_LAST_RSVD,
ITEM_E_TAG,
ITEM_E_TAG_GRP_ECID_B,
ITEM_NVGRE,
ITEM_NVGRE_TNI,
ITEM_MPLS,
ITEM_MPLS_LABEL,
ITEM_MPLS_TC,
ITEM_MPLS_S,
ITEM_GRE,
ITEM_GRE_PROTO,
ITEM_GRE_C_RSVD0_VER,
ITEM_GRE_C_BIT,
ITEM_GRE_K_BIT,
ITEM_GRE_S_BIT,
ITEM_FUZZY,
ITEM_FUZZY_THRESH,
ITEM_GTP,
ITEM_GTP_FLAGS,
ITEM_GTP_MSG_TYPE,
ITEM_GTP_TEID,
ITEM_GTPC,
ITEM_GTPU,
ITEM_GENEVE,
ITEM_GENEVE_VNI,
ITEM_GENEVE_PROTO,
ITEM_GENEVE_OPTLEN,
ITEM_VXLAN_GPE,
ITEM_VXLAN_GPE_VNI,
ITEM_ARP_ETH_IPV4,
ITEM_ARP_ETH_IPV4_SHA,
ITEM_ARP_ETH_IPV4_SPA,
ITEM_ARP_ETH_IPV4_THA,
ITEM_ARP_ETH_IPV4_TPA,
ITEM_IPV6_EXT,
ITEM_IPV6_EXT_NEXT_HDR,
ITEM_IPV6_FRAG_EXT,
ITEM_IPV6_FRAG_EXT_NEXT_HDR,
ITEM_IPV6_FRAG_EXT_FRAG_DATA,
ITEM_IPV6_FRAG_EXT_ID,
ITEM_ICMP6,
ITEM_ICMP6_TYPE,
ITEM_ICMP6_CODE,
ITEM_ICMP6_ND_NS,
ITEM_ICMP6_ND_NS_TARGET_ADDR,
ITEM_ICMP6_ND_NA,
ITEM_ICMP6_ND_NA_TARGET_ADDR,
ITEM_ICMP6_ND_OPT,
ITEM_ICMP6_ND_OPT_TYPE,
ITEM_ICMP6_ND_OPT_SLA_ETH,
ITEM_ICMP6_ND_OPT_SLA_ETH_SLA,
ITEM_ICMP6_ND_OPT_TLA_ETH,
ITEM_ICMP6_ND_OPT_TLA_ETH_TLA,
ITEM_META,
ITEM_META_DATA,
ITEM_GRE_KEY,
ITEM_GRE_KEY_VALUE,
ITEM_GRE_OPTION,
ITEM_GRE_OPTION_CHECKSUM,
ITEM_GRE_OPTION_KEY,
ITEM_GRE_OPTION_SEQUENCE,
ITEM_GTP_PSC,
ITEM_GTP_PSC_QFI,
ITEM_GTP_PSC_PDU_T,
ITEM_PPPOES,
ITEM_PPPOED,
ITEM_PPPOE_SEID,
ITEM_PPPOE_PROTO_ID,
ITEM_HIGIG2,
ITEM_HIGIG2_CLASSIFICATION,
ITEM_HIGIG2_VID,
ITEM_TAG,
ITEM_TAG_DATA,
ITEM_TAG_INDEX,
ITEM_L2TPV3OIP,
ITEM_L2TPV3OIP_SESSION_ID,
ITEM_ESP,
ITEM_ESP_SPI,
ITEM_AH,
ITEM_AH_SPI,
ITEM_PFCP,
ITEM_PFCP_S_FIELD,
ITEM_PFCP_SEID,
ITEM_ECPRI,
ITEM_ECPRI_COMMON,
ITEM_ECPRI_COMMON_TYPE,
ITEM_ECPRI_COMMON_TYPE_IQ_DATA,
ITEM_ECPRI_COMMON_TYPE_RTC_CTRL,
ITEM_ECPRI_COMMON_TYPE_DLY_MSR,
ITEM_ECPRI_MSG_IQ_DATA_PCID,
ITEM_ECPRI_MSG_RTC_CTRL_RTCID,
ITEM_ECPRI_MSG_DLY_MSR_MSRID,
ITEM_GENEVE_OPT,
ITEM_GENEVE_OPT_CLASS,
ITEM_GENEVE_OPT_TYPE,
ITEM_GENEVE_OPT_LENGTH,
ITEM_GENEVE_OPT_DATA,
ITEM_INTEGRITY,
ITEM_INTEGRITY_LEVEL,
ITEM_INTEGRITY_VALUE,
ITEM_CONNTRACK,
ITEM_POL_PORT,
ITEM_POL_METER,
ITEM_POL_POLICY,
ITEM_PORT_REPRESENTOR,
ITEM_PORT_REPRESENTOR_PORT_ID,
ITEM_REPRESENTED_PORT,
ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID,
ITEM_FLEX,
ITEM_FLEX_ITEM_HANDLE,
ITEM_FLEX_PATTERN_HANDLE,
ITEM_L2TPV2,
ITEM_L2TPV2_TYPE,
ITEM_L2TPV2_TYPE_DATA,
ITEM_L2TPV2_TYPE_DATA_L,
ITEM_L2TPV2_TYPE_DATA_S,
ITEM_L2TPV2_TYPE_DATA_O,
ITEM_L2TPV2_TYPE_DATA_L_S,
ITEM_L2TPV2_TYPE_CTRL,
ITEM_L2TPV2_MSG_DATA_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_L_LENGTH,
ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_L_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_S_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_S_NS,
ITEM_L2TPV2_MSG_DATA_S_NR,
ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_O_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_O_OFFSET,
ITEM_L2TPV2_MSG_DATA_L_S_LENGTH,
ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_L_S_NS,
ITEM_L2TPV2_MSG_DATA_L_S_NR,
ITEM_L2TPV2_MSG_CTRL_LENGTH,
ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID,
ITEM_L2TPV2_MSG_CTRL_SESSION_ID,
ITEM_L2TPV2_MSG_CTRL_NS,
ITEM_L2TPV2_MSG_CTRL_NR,
ITEM_PPP,
ITEM_PPP_ADDR,
ITEM_PPP_CTRL,
ITEM_PPP_PROTO_ID,
/* Validate/create actions. */
ACTIONS,
ACTION_NEXT,
ACTION_END,
ACTION_VOID,
ACTION_PASSTHRU,
ACTION_JUMP,
ACTION_JUMP_GROUP,
ACTION_MARK,
ACTION_MARK_ID,
ACTION_FLAG,
ACTION_QUEUE,
ACTION_QUEUE_INDEX,
ACTION_DROP,
ACTION_COUNT,
ACTION_COUNT_ID,
ACTION_RSS,
ACTION_RSS_FUNC,
ACTION_RSS_LEVEL,
ACTION_RSS_FUNC_DEFAULT,
ACTION_RSS_FUNC_TOEPLITZ,
ACTION_RSS_FUNC_SIMPLE_XOR,
ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ,
ACTION_RSS_TYPES,
ACTION_RSS_TYPE,
ACTION_RSS_KEY,
ACTION_RSS_KEY_LEN,
ACTION_RSS_QUEUES,
ACTION_RSS_QUEUE,
ACTION_PF,
ACTION_VF,
ACTION_VF_ORIGINAL,
ACTION_VF_ID,
ACTION_PHY_PORT,
ACTION_PHY_PORT_ORIGINAL,
ACTION_PHY_PORT_INDEX,
ACTION_PORT_ID,
ACTION_PORT_ID_ORIGINAL,
ACTION_PORT_ID_ID,
ACTION_METER,
ACTION_METER_COLOR,
ACTION_METER_COLOR_TYPE,
ACTION_METER_COLOR_GREEN,
ACTION_METER_COLOR_YELLOW,
ACTION_METER_COLOR_RED,
ACTION_METER_ID,
ACTION_OF_SET_MPLS_TTL,
ACTION_OF_SET_MPLS_TTL_MPLS_TTL,
ACTION_OF_DEC_MPLS_TTL,
ACTION_OF_SET_NW_TTL,
ACTION_OF_SET_NW_TTL_NW_TTL,
ACTION_OF_DEC_NW_TTL,
ACTION_OF_COPY_TTL_OUT,
ACTION_OF_COPY_TTL_IN,
ACTION_OF_POP_VLAN,
ACTION_OF_PUSH_VLAN,
ACTION_OF_PUSH_VLAN_ETHERTYPE,
ACTION_OF_SET_VLAN_VID,
ACTION_OF_SET_VLAN_VID_VLAN_VID,
ACTION_OF_SET_VLAN_PCP,
ACTION_OF_SET_VLAN_PCP_VLAN_PCP,
ACTION_OF_POP_MPLS,
ACTION_OF_POP_MPLS_ETHERTYPE,
ACTION_OF_PUSH_MPLS,
ACTION_OF_PUSH_MPLS_ETHERTYPE,
ACTION_VXLAN_ENCAP,
ACTION_VXLAN_DECAP,
ACTION_NVGRE_ENCAP,
ACTION_NVGRE_DECAP,
ACTION_L2_ENCAP,
ACTION_L2_DECAP,
ACTION_MPLSOGRE_ENCAP,
ACTION_MPLSOGRE_DECAP,
ACTION_MPLSOUDP_ENCAP,
ACTION_MPLSOUDP_DECAP,
ACTION_SET_IPV4_SRC,
ACTION_SET_IPV4_SRC_IPV4_SRC,
ACTION_SET_IPV4_DST,
ACTION_SET_IPV4_DST_IPV4_DST,
ACTION_SET_IPV6_SRC,
ACTION_SET_IPV6_SRC_IPV6_SRC,
ACTION_SET_IPV6_DST,
ACTION_SET_IPV6_DST_IPV6_DST,
ACTION_SET_TP_SRC,
ACTION_SET_TP_SRC_TP_SRC,
ACTION_SET_TP_DST,
ACTION_SET_TP_DST_TP_DST,
ACTION_MAC_SWAP,
ACTION_DEC_TTL,
ACTION_SET_TTL,
ACTION_SET_TTL_TTL,
ACTION_SET_MAC_SRC,
ACTION_SET_MAC_SRC_MAC_SRC,
ACTION_SET_MAC_DST,
ACTION_SET_MAC_DST_MAC_DST,
ACTION_INC_TCP_SEQ,
ACTION_INC_TCP_SEQ_VALUE,
ACTION_DEC_TCP_SEQ,
ACTION_DEC_TCP_SEQ_VALUE,
ACTION_INC_TCP_ACK,
ACTION_INC_TCP_ACK_VALUE,
ACTION_DEC_TCP_ACK,
ACTION_DEC_TCP_ACK_VALUE,
ACTION_RAW_ENCAP,
ACTION_RAW_DECAP,
ACTION_RAW_ENCAP_INDEX,
ACTION_RAW_ENCAP_INDEX_VALUE,
ACTION_RAW_DECAP_INDEX,
ACTION_RAW_DECAP_INDEX_VALUE,
ACTION_SET_TAG,
ACTION_SET_TAG_DATA,
ACTION_SET_TAG_INDEX,
ACTION_SET_TAG_MASK,
ACTION_SET_META,
ACTION_SET_META_DATA,
ACTION_SET_META_MASK,
ACTION_SET_IPV4_DSCP,
ACTION_SET_IPV4_DSCP_VALUE,
ACTION_SET_IPV6_DSCP,
ACTION_SET_IPV6_DSCP_VALUE,
ACTION_AGE,
ACTION_AGE_TIMEOUT,
ACTION_SAMPLE,
ACTION_SAMPLE_RATIO,
ACTION_SAMPLE_INDEX,
ACTION_SAMPLE_INDEX_VALUE,
ACTION_INDIRECT,
INDIRECT_ACTION_ID2PTR,
ACTION_MODIFY_FIELD,
ACTION_MODIFY_FIELD_OP,
ACTION_MODIFY_FIELD_OP_VALUE,
ACTION_MODIFY_FIELD_DST_TYPE,
ACTION_MODIFY_FIELD_DST_TYPE_VALUE,
ACTION_MODIFY_FIELD_DST_LEVEL,
ACTION_MODIFY_FIELD_DST_OFFSET,
ACTION_MODIFY_FIELD_SRC_TYPE,
ACTION_MODIFY_FIELD_SRC_TYPE_VALUE,
ACTION_MODIFY_FIELD_SRC_LEVEL,
ACTION_MODIFY_FIELD_SRC_OFFSET,
ACTION_MODIFY_FIELD_SRC_VALUE,
ACTION_MODIFY_FIELD_SRC_POINTER,
ACTION_MODIFY_FIELD_WIDTH,
ACTION_CONNTRACK,
ACTION_CONNTRACK_UPDATE,
ACTION_CONNTRACK_UPDATE_DIR,
ACTION_CONNTRACK_UPDATE_CTX,
ACTION_POL_G,
ACTION_POL_Y,
ACTION_POL_R,
ACTION_PORT_REPRESENTOR,
ACTION_PORT_REPRESENTOR_PORT_ID,
ACTION_REPRESENTED_PORT,
ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID,
};
/** Maximum size for pattern in struct rte_flow_item_raw. */
#define ITEM_RAW_PATTERN_SIZE 512
/** Maximum size for GENEVE option data pattern in bytes. */
#define ITEM_GENEVE_OPT_DATA_SIZE 124
/** Storage size for struct rte_flow_item_raw including pattern. */
#define ITEM_RAW_SIZE \
(sizeof(struct rte_flow_item_raw) + ITEM_RAW_PATTERN_SIZE)
/** Maximum size for external pattern in struct rte_flow_action_modify_data. */
#define ACTION_MODIFY_PATTERN_SIZE 32
/** Storage size for struct rte_flow_action_modify_field including pattern. */
#define ACTION_MODIFY_SIZE \
(sizeof(struct rte_flow_action_modify_field) + \
ACTION_MODIFY_PATTERN_SIZE)
/** Maximum number of queue indices in struct rte_flow_action_rss. */
#define ACTION_RSS_QUEUE_NUM 128
/** Storage for struct rte_flow_action_rss including external data. */
struct action_rss_data {
struct rte_flow_action_rss conf;
uint8_t key[RSS_HASH_KEY_LENGTH];
uint16_t queue[ACTION_RSS_QUEUE_NUM];
};
/** Maximum data size in struct rte_flow_action_raw_encap. */
#define ACTION_RAW_ENCAP_MAX_DATA 512
#define RAW_ENCAP_CONFS_MAX_NUM 8
/** Storage for struct rte_flow_action_raw_encap. */
struct raw_encap_conf {
uint8_t data[ACTION_RAW_ENCAP_MAX_DATA];
uint8_t preserve[ACTION_RAW_ENCAP_MAX_DATA];
size_t size;
};
struct raw_encap_conf raw_encap_confs[RAW_ENCAP_CONFS_MAX_NUM];
/** Storage for struct rte_flow_action_raw_encap including external data. */
struct action_raw_encap_data {
struct rte_flow_action_raw_encap conf;
uint8_t data[ACTION_RAW_ENCAP_MAX_DATA];
uint8_t preserve[ACTION_RAW_ENCAP_MAX_DATA];
uint16_t idx;
};
/** Storage for struct rte_flow_action_raw_decap. */
struct raw_decap_conf {
uint8_t data[ACTION_RAW_ENCAP_MAX_DATA];
size_t size;
};
struct raw_decap_conf raw_decap_confs[RAW_ENCAP_CONFS_MAX_NUM];
/** Storage for struct rte_flow_action_raw_decap including external data. */
struct action_raw_decap_data {
struct rte_flow_action_raw_decap conf;
uint8_t data[ACTION_RAW_ENCAP_MAX_DATA];
uint16_t idx;
};
struct vxlan_encap_conf vxlan_encap_conf = {
.select_ipv4 = 1,
.select_vlan = 0,
.select_tos_ttl = 0,
.vni = "\x00\x00\x00",
.udp_src = 0,
.udp_dst = RTE_BE16(RTE_VXLAN_DEFAULT_PORT),
.ipv4_src = RTE_IPV4(127, 0, 0, 1),
.ipv4_dst = RTE_IPV4(255, 255, 255, 255),
.ipv6_src = "\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x01",
.ipv6_dst = "\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x11\x11",
.vlan_tci = 0,
.ip_tos = 0,
.ip_ttl = 255,
.eth_src = "\x00\x00\x00\x00\x00\x00",
.eth_dst = "\xff\xff\xff\xff\xff\xff",
};
/** Maximum number of items in struct rte_flow_action_vxlan_encap. */
#define ACTION_VXLAN_ENCAP_ITEMS_NUM 6
/** Storage for struct rte_flow_action_vxlan_encap including external data. */
struct action_vxlan_encap_data {
struct rte_flow_action_vxlan_encap conf;
struct rte_flow_item items[ACTION_VXLAN_ENCAP_ITEMS_NUM];
struct rte_flow_item_eth item_eth;
struct rte_flow_item_vlan item_vlan;
union {
struct rte_flow_item_ipv4 item_ipv4;
struct rte_flow_item_ipv6 item_ipv6;
};
struct rte_flow_item_udp item_udp;
struct rte_flow_item_vxlan item_vxlan;
};
struct nvgre_encap_conf nvgre_encap_conf = {
.select_ipv4 = 1,
.select_vlan = 0,
.tni = "\x00\x00\x00",
.ipv4_src = RTE_IPV4(127, 0, 0, 1),
.ipv4_dst = RTE_IPV4(255, 255, 255, 255),
.ipv6_src = "\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x01",
.ipv6_dst = "\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x11\x11",
.vlan_tci = 0,
.eth_src = "\x00\x00\x00\x00\x00\x00",
.eth_dst = "\xff\xff\xff\xff\xff\xff",
};
/** Maximum number of items in struct rte_flow_action_nvgre_encap. */
#define ACTION_NVGRE_ENCAP_ITEMS_NUM 5
/** Storage for struct rte_flow_action_nvgre_encap including external data. */
struct action_nvgre_encap_data {
struct rte_flow_action_nvgre_encap conf;
struct rte_flow_item items[ACTION_NVGRE_ENCAP_ITEMS_NUM];
struct rte_flow_item_eth item_eth;
struct rte_flow_item_vlan item_vlan;
union {
struct rte_flow_item_ipv4 item_ipv4;
struct rte_flow_item_ipv6 item_ipv6;
};
struct rte_flow_item_nvgre item_nvgre;
};
struct l2_encap_conf l2_encap_conf;
struct l2_decap_conf l2_decap_conf;
struct mplsogre_encap_conf mplsogre_encap_conf;
struct mplsogre_decap_conf mplsogre_decap_conf;
struct mplsoudp_encap_conf mplsoudp_encap_conf;
struct mplsoudp_decap_conf mplsoudp_decap_conf;
struct rte_flow_action_conntrack conntrack_context;
#define ACTION_SAMPLE_ACTIONS_NUM 10
#define RAW_SAMPLE_CONFS_MAX_NUM 8
/** Storage for struct rte_flow_action_sample including external data. */
struct action_sample_data {
struct rte_flow_action_sample conf;
uint32_t idx;
};
/** Storage for struct rte_flow_action_sample. */
struct raw_sample_conf {
struct rte_flow_action data[ACTION_SAMPLE_ACTIONS_NUM];
};
struct raw_sample_conf raw_sample_confs[RAW_SAMPLE_CONFS_MAX_NUM];
struct rte_flow_action_mark sample_mark[RAW_SAMPLE_CONFS_MAX_NUM];
struct rte_flow_action_queue sample_queue[RAW_SAMPLE_CONFS_MAX_NUM];
struct rte_flow_action_count sample_count[RAW_SAMPLE_CONFS_MAX_NUM];
struct rte_flow_action_port_id sample_port_id[RAW_SAMPLE_CONFS_MAX_NUM];
struct rte_flow_action_raw_encap sample_encap[RAW_SAMPLE_CONFS_MAX_NUM];
struct action_vxlan_encap_data sample_vxlan_encap[RAW_SAMPLE_CONFS_MAX_NUM];
struct action_nvgre_encap_data sample_nvgre_encap[RAW_SAMPLE_CONFS_MAX_NUM];
struct action_rss_data sample_rss_data[RAW_SAMPLE_CONFS_MAX_NUM];
struct rte_flow_action_vf sample_vf[RAW_SAMPLE_CONFS_MAX_NUM];
static const char *const modify_field_ops[] = {
"set", "add", "sub", NULL
};
static const char *const modify_field_ids[] = {
"start", "mac_dst", "mac_src",
"vlan_type", "vlan_id", "mac_type",
"ipv4_dscp", "ipv4_ttl", "ipv4_src", "ipv4_dst",
"ipv6_dscp", "ipv6_hoplimit", "ipv6_src", "ipv6_dst",
"tcp_port_src", "tcp_port_dst",
"tcp_seq_num", "tcp_ack_num", "tcp_flags",
"udp_port_src", "udp_port_dst",
"vxlan_vni", "geneve_vni", "gtp_teid",
"tag", "mark", "meta", "pointer", "value",
"ipv4_ecn", "ipv6_ecn", NULL
};
/** Maximum number of subsequent tokens and arguments on the stack. */
#define CTX_STACK_SIZE 16
/** Parser context. */
struct context {
/** Stack of subsequent token lists to process. */
const enum index *next[CTX_STACK_SIZE];
/** Arguments for stacked tokens. */
const void *args[CTX_STACK_SIZE];
enum index curr; /**< Current token index. */
enum index prev; /**< Index of the last token seen. */
int next_num; /**< Number of entries in next[]. */
int args_num; /**< Number of entries in args[]. */
uint32_t eol:1; /**< EOL has been detected. */
uint32_t last:1; /**< No more arguments. */
portid_t port; /**< Current port ID (for completions). */
uint32_t objdata; /**< Object-specific data. */
void *object; /**< Address of current object for relative offsets. */
void *objmask; /**< Object a full mask must be written to. */
};
/** Token argument. */
struct arg {
uint32_t hton:1; /**< Use network byte ordering. */
uint32_t sign:1; /**< Value is signed. */
uint32_t bounded:1; /**< Value is bounded. */
uintmax_t min; /**< Minimum value if bounded. */
uintmax_t max; /**< Maximum value if bounded. */
uint32_t offset; /**< Relative offset from ctx->object. */
uint32_t size; /**< Field size. */
const uint8_t *mask; /**< Bit-mask to use instead of offset/size. */
};
/** Parser token definition. */
struct token {
/** Type displayed during completion (defaults to "TOKEN"). */
const char *type;
/** Help displayed during completion (defaults to token name). */
const char *help;
/** Private data used by parser functions. */
const void *priv;
/**
* Lists of subsequent tokens to push on the stack. Each call to the
* parser consumes the last entry of that stack.
*/
const enum index *const *next;
/** Arguments stack for subsequent tokens that need them. */
const struct arg *const *args;
/**
* Token-processing callback, returns -1 in case of error, the
* length of the matched string otherwise. If NULL, attempts to
* match the token name.
*
* If buf is not NULL, the result should be stored in it according
* to context. An error is returned if not large enough.
*/
int (*call)(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size);
/**
* Callback that provides possible values for this token, used for
* completion. Returns -1 in case of error, the number of possible
* values otherwise. If NULL, the token name is used.
*
* If buf is not NULL, entry index ent is written to buf and the
* full length of the entry is returned (same behavior as
* snprintf()).
*/
int (*comp)(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size);
/** Mandatory token name, no default value. */
const char *name;
};
/** Static initializer for the next field. */
#define NEXT(...) (const enum index *const []){ __VA_ARGS__, NULL, }
/** Static initializer for a NEXT() entry. */
#define NEXT_ENTRY(...) (const enum index []){ __VA_ARGS__, ZERO, }
/** Static initializer for the args field. */
#define ARGS(...) (const struct arg *const []){ __VA_ARGS__, NULL, }
/** Static initializer for ARGS() to target a field. */
#define ARGS_ENTRY(s, f) \
(&(const struct arg){ \
.offset = offsetof(s, f), \
.size = sizeof(((s *)0)->f), \
})
/** Static initializer for ARGS() to target a bit-field. */
#define ARGS_ENTRY_BF(s, f, b) \
(&(const struct arg){ \
.size = sizeof(s), \
.mask = (const void *)&(const s){ .f = (1 << (b)) - 1 }, \
})
/** Static initializer for ARGS() to target a field with limits. */
#define ARGS_ENTRY_BOUNDED(s, f, i, a) \
(&(const struct arg){ \
.bounded = 1, \
.min = (i), \
.max = (a), \
.offset = offsetof(s, f), \
.size = sizeof(((s *)0)->f), \
})
/** Static initializer for ARGS() to target an arbitrary bit-mask. */
#define ARGS_ENTRY_MASK(s, f, m) \
(&(const struct arg){ \
.offset = offsetof(s, f), \
.size = sizeof(((s *)0)->f), \
.mask = (const void *)(m), \
})
/** Same as ARGS_ENTRY_MASK() using network byte ordering for the value. */
#define ARGS_ENTRY_MASK_HTON(s, f, m) \
(&(const struct arg){ \
.hton = 1, \
.offset = offsetof(s, f), \
.size = sizeof(((s *)0)->f), \
.mask = (const void *)(m), \
})
/** Static initializer for ARGS() to target a pointer. */
#define ARGS_ENTRY_PTR(s, f) \
(&(const struct arg){ \
.size = sizeof(*((s *)0)->f), \
})
/** Static initializer for ARGS() with arbitrary offset and size. */
#define ARGS_ENTRY_ARB(o, s) \
(&(const struct arg){ \
.offset = (o), \
.size = (s), \
})
/** Same as ARGS_ENTRY_ARB() with bounded values. */
#define ARGS_ENTRY_ARB_BOUNDED(o, s, i, a) \
(&(const struct arg){ \
.bounded = 1, \
.min = (i), \
.max = (a), \
.offset = (o), \
.size = (s), \
})
/** Same as ARGS_ENTRY() using network byte ordering. */
#define ARGS_ENTRY_HTON(s, f) \
(&(const struct arg){ \
.hton = 1, \
.offset = offsetof(s, f), \
.size = sizeof(((s *)0)->f), \
})
/** Same as ARGS_ENTRY_HTON() for a single argument, without structure. */
#define ARG_ENTRY_HTON(s) \
(&(const struct arg){ \
.hton = 1, \
.offset = 0, \
.size = sizeof(s), \
})
/** Parser output buffer layout expected by cmd_flow_parsed(). */
struct buffer {
enum index command; /**< Flow command. */
portid_t port; /**< Affected port ID. */
queueid_t queue; /** Async queue ID. */
bool postpone; /** Postpone async operation */
union {
struct {
struct rte_flow_port_attr port_attr;
uint32_t nb_queue;
struct rte_flow_queue_attr queue_attr;
} configure; /**< Configuration arguments. */
struct {
uint32_t *template_id;
uint32_t template_id_n;
} templ_destroy; /**< Template destroy arguments. */
struct {
uint32_t id;
struct rte_flow_template_table_attr attr;
uint32_t *pat_templ_id;
uint32_t pat_templ_id_n;
uint32_t *act_templ_id;
uint32_t act_templ_id_n;
} table; /**< Table arguments. */
struct {
uint32_t *table_id;
uint32_t table_id_n;
} table_destroy; /**< Template destroy arguments. */
struct {
uint32_t *action_id;
uint32_t action_id_n;
} ia_destroy; /**< Indirect action destroy arguments. */
struct {
uint32_t action_id;
} ia; /* Indirect action query arguments */
struct {
uint32_t table_id;
uint32_t pat_templ_id;
uint32_t act_templ_id;
struct rte_flow_attr attr;
struct tunnel_ops tunnel_ops;
struct rte_flow_item *pattern;
struct rte_flow_action *actions;
struct rte_flow_action *masks;
uint32_t pattern_n;
uint32_t actions_n;
uint8_t *data;
} vc; /**< Validate/create arguments. */
struct {
uint32_t *rule;
uint32_t rule_n;
} destroy; /**< Destroy arguments. */
struct {
char file[128];
bool mode;
uint32_t rule;
} dump; /**< Dump arguments. */
struct {
uint32_t rule;
struct rte_flow_action action;
} query; /**< Query arguments. */
struct {
uint32_t *group;
uint32_t group_n;
} list; /**< List arguments. */
struct {
int set;
} isolate; /**< Isolated mode arguments. */
struct {
int destroy;
} aged; /**< Aged arguments. */
struct {
uint32_t policy_id;
} policy;/**< Policy arguments. */
struct {
uint16_t token;
uintptr_t uintptr;
char filename[128];
} flex; /**< Flex arguments*/
} args; /**< Command arguments. */
};
/** Private data for pattern items. */
struct parse_item_priv {
enum rte_flow_item_type type; /**< Item type. */
uint32_t size; /**< Size of item specification structure. */
};
#define PRIV_ITEM(t, s) \
(&(const struct parse_item_priv){ \
.type = RTE_FLOW_ITEM_TYPE_ ## t, \
.size = s, \
})
/** Private data for actions. */
struct parse_action_priv {
enum rte_flow_action_type type; /**< Action type. */
uint32_t size; /**< Size of action configuration structure. */
};
#define PRIV_ACTION(t, s) \
(&(const struct parse_action_priv){ \
.type = RTE_FLOW_ACTION_TYPE_ ## t, \
.size = s, \
})
static const enum index next_flex_item[] = {
FLEX_ITEM_INIT,
FLEX_ITEM_CREATE,
FLEX_ITEM_DESTROY,
ZERO,
};
static const enum index next_config_attr[] = {
CONFIG_QUEUES_NUMBER,
CONFIG_QUEUES_SIZE,
CONFIG_COUNTERS_NUMBER,
CONFIG_AGING_OBJECTS_NUMBER,
CONFIG_METERS_NUMBER,
END,
ZERO,
};
static const enum index next_pt_subcmd[] = {
PATTERN_TEMPLATE_CREATE,
PATTERN_TEMPLATE_DESTROY,
ZERO,
};
static const enum index next_pt_attr[] = {
PATTERN_TEMPLATE_CREATE_ID,
PATTERN_TEMPLATE_RELAXED_MATCHING,
PATTERN_TEMPLATE_INGRESS,
PATTERN_TEMPLATE_EGRESS,
PATTERN_TEMPLATE_TRANSFER,
PATTERN_TEMPLATE_SPEC,
ZERO,
};
static const enum index next_pt_destroy_attr[] = {
PATTERN_TEMPLATE_DESTROY_ID,
END,
ZERO,
};
static const enum index next_at_subcmd[] = {
ACTIONS_TEMPLATE_CREATE,
ACTIONS_TEMPLATE_DESTROY,
ZERO,
};
static const enum index next_at_attr[] = {
ACTIONS_TEMPLATE_CREATE_ID,
ACTIONS_TEMPLATE_INGRESS,
ACTIONS_TEMPLATE_EGRESS,
ACTIONS_TEMPLATE_TRANSFER,
ACTIONS_TEMPLATE_SPEC,
ZERO,
};
static const enum index next_at_destroy_attr[] = {
ACTIONS_TEMPLATE_DESTROY_ID,
END,
ZERO,
};
static const enum index next_table_subcmd[] = {
TABLE_CREATE,
TABLE_DESTROY,
ZERO,
};
static const enum index next_table_attr[] = {
TABLE_CREATE_ID,
TABLE_GROUP,
TABLE_PRIORITY,
TABLE_INGRESS,
TABLE_EGRESS,
TABLE_TRANSFER,
TABLE_RULES_NUMBER,
TABLE_PATTERN_TEMPLATE,
TABLE_ACTIONS_TEMPLATE,
END,
ZERO,
};
static const enum index next_table_destroy_attr[] = {
TABLE_DESTROY_ID,
END,
ZERO,
};
static const enum index next_queue_subcmd[] = {
QUEUE_CREATE,
QUEUE_DESTROY,
QUEUE_INDIRECT_ACTION,
ZERO,
};
static const enum index next_queue_destroy_attr[] = {
QUEUE_DESTROY_ID,
END,
ZERO,
};
static const enum index next_qia_subcmd[] = {
QUEUE_INDIRECT_ACTION_CREATE,
QUEUE_INDIRECT_ACTION_UPDATE,
QUEUE_INDIRECT_ACTION_DESTROY,
ZERO,
};
static const enum index next_qia_create_attr[] = {
QUEUE_INDIRECT_ACTION_CREATE_ID,
QUEUE_INDIRECT_ACTION_INGRESS,
QUEUE_INDIRECT_ACTION_EGRESS,
QUEUE_INDIRECT_ACTION_TRANSFER,
QUEUE_INDIRECT_ACTION_CREATE_POSTPONE,
QUEUE_INDIRECT_ACTION_SPEC,
ZERO,
};
static const enum index next_qia_update_attr[] = {
QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE,
QUEUE_INDIRECT_ACTION_SPEC,
ZERO,
};
static const enum index next_qia_destroy_attr[] = {
QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE,
QUEUE_INDIRECT_ACTION_DESTROY_ID,
END,
ZERO,
};
static const enum index next_ia_create_attr[] = {
INDIRECT_ACTION_CREATE_ID,
INDIRECT_ACTION_INGRESS,
INDIRECT_ACTION_EGRESS,
INDIRECT_ACTION_TRANSFER,
INDIRECT_ACTION_SPEC,
ZERO,
};
static const enum index next_dump_subcmd[] = {
DUMP_ALL,
DUMP_ONE,
ZERO,
};
static const enum index next_ia_subcmd[] = {
INDIRECT_ACTION_CREATE,
INDIRECT_ACTION_UPDATE,
INDIRECT_ACTION_DESTROY,
INDIRECT_ACTION_QUERY,
ZERO,
};
static const enum index next_vc_attr[] = {
VC_GROUP,
VC_PRIORITY,
VC_INGRESS,
VC_EGRESS,
VC_TRANSFER,
VC_TUNNEL_SET,
VC_TUNNEL_MATCH,
ITEM_PATTERN,
ZERO,
};
static const enum index next_destroy_attr[] = {
DESTROY_RULE,
END,
ZERO,
};
static const enum index next_dump_attr[] = {
COMMON_FILE_PATH,
END,
ZERO,
};
static const enum index next_list_attr[] = {
LIST_GROUP,
END,
ZERO,
};
static const enum index next_aged_attr[] = {
AGED_DESTROY,
END,
ZERO,
};
static const enum index next_ia_destroy_attr[] = {
INDIRECT_ACTION_DESTROY_ID,
END,
ZERO,
};
static const enum index item_param[] = {
ITEM_PARAM_IS,
ITEM_PARAM_SPEC,
ITEM_PARAM_LAST,
ITEM_PARAM_MASK,
ITEM_PARAM_PREFIX,
ZERO,
};
static const enum index next_item[] = {
ITEM_END,
ITEM_VOID,
ITEM_INVERT,
ITEM_ANY,
ITEM_PF,
ITEM_VF,
ITEM_PHY_PORT,
ITEM_PORT_ID,
ITEM_MARK,
ITEM_RAW,
ITEM_ETH,
ITEM_VLAN,
ITEM_IPV4,
ITEM_IPV6,
ITEM_ICMP,
ITEM_UDP,
ITEM_TCP,
ITEM_SCTP,
ITEM_VXLAN,
ITEM_E_TAG,
ITEM_NVGRE,
ITEM_MPLS,
ITEM_GRE,
ITEM_FUZZY,
ITEM_GTP,
ITEM_GTPC,
ITEM_GTPU,
ITEM_GENEVE,
ITEM_VXLAN_GPE,
ITEM_ARP_ETH_IPV4,
ITEM_IPV6_EXT,
ITEM_IPV6_FRAG_EXT,
ITEM_ICMP6,
ITEM_ICMP6_ND_NS,
ITEM_ICMP6_ND_NA,
ITEM_ICMP6_ND_OPT,
ITEM_ICMP6_ND_OPT_SLA_ETH,
ITEM_ICMP6_ND_OPT_TLA_ETH,
ITEM_META,
ITEM_GRE_KEY,
ITEM_GRE_OPTION,
ITEM_GTP_PSC,
ITEM_PPPOES,
ITEM_PPPOED,
ITEM_PPPOE_PROTO_ID,
ITEM_HIGIG2,
ITEM_TAG,
ITEM_L2TPV3OIP,
ITEM_ESP,
ITEM_AH,
ITEM_PFCP,
ITEM_ECPRI,
ITEM_GENEVE_OPT,
ITEM_INTEGRITY,
ITEM_CONNTRACK,
ITEM_PORT_REPRESENTOR,
ITEM_REPRESENTED_PORT,
ITEM_FLEX,
ITEM_L2TPV2,
ITEM_PPP,
END_SET,
ZERO,
};
static const enum index item_fuzzy[] = {
ITEM_FUZZY_THRESH,
ITEM_NEXT,
ZERO,
};
static const enum index item_any[] = {
ITEM_ANY_NUM,
ITEM_NEXT,
ZERO,
};
static const enum index item_vf[] = {
ITEM_VF_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_phy_port[] = {
ITEM_PHY_PORT_INDEX,
ITEM_NEXT,
ZERO,
};
static const enum index item_port_id[] = {
ITEM_PORT_ID_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_mark[] = {
ITEM_MARK_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_raw[] = {
ITEM_RAW_RELATIVE,
ITEM_RAW_SEARCH,
ITEM_RAW_OFFSET,
ITEM_RAW_LIMIT,
ITEM_RAW_PATTERN,
ITEM_RAW_PATTERN_HEX,
ITEM_NEXT,
ZERO,
};
static const enum index item_eth[] = {
ITEM_ETH_DST,
ITEM_ETH_SRC,
ITEM_ETH_TYPE,
ITEM_ETH_HAS_VLAN,
ITEM_NEXT,
ZERO,
};
static const enum index item_vlan[] = {
ITEM_VLAN_TCI,
ITEM_VLAN_PCP,
ITEM_VLAN_DEI,
ITEM_VLAN_VID,
ITEM_VLAN_INNER_TYPE,
ITEM_VLAN_HAS_MORE_VLAN,
ITEM_NEXT,
ZERO,
};
static const enum index item_ipv4[] = {
ITEM_IPV4_VER_IHL,
ITEM_IPV4_TOS,
ITEM_IPV4_ID,
ITEM_IPV4_FRAGMENT_OFFSET,
ITEM_IPV4_TTL,
ITEM_IPV4_PROTO,
ITEM_IPV4_SRC,
ITEM_IPV4_DST,
ITEM_NEXT,
ZERO,
};
static const enum index item_ipv6[] = {
ITEM_IPV6_TC,
ITEM_IPV6_FLOW,
ITEM_IPV6_PROTO,
ITEM_IPV6_HOP,
ITEM_IPV6_SRC,
ITEM_IPV6_DST,
ITEM_IPV6_HAS_FRAG_EXT,
ITEM_NEXT,
ZERO,
};
static const enum index item_icmp[] = {
ITEM_ICMP_TYPE,
ITEM_ICMP_CODE,
ITEM_ICMP_IDENT,
ITEM_ICMP_SEQ,
ITEM_NEXT,
ZERO,
};
static const enum index item_udp[] = {
ITEM_UDP_SRC,
ITEM_UDP_DST,
ITEM_NEXT,
ZERO,
};
static const enum index item_tcp[] = {
ITEM_TCP_SRC,
ITEM_TCP_DST,
ITEM_TCP_FLAGS,
ITEM_NEXT,
ZERO,
};
static const enum index item_sctp[] = {
ITEM_SCTP_SRC,
ITEM_SCTP_DST,
ITEM_SCTP_TAG,
ITEM_SCTP_CKSUM,
ITEM_NEXT,
ZERO,
};
static const enum index item_vxlan[] = {
ITEM_VXLAN_VNI,
ITEM_VXLAN_LAST_RSVD,
ITEM_NEXT,
ZERO,
};
static const enum index item_e_tag[] = {
ITEM_E_TAG_GRP_ECID_B,
ITEM_NEXT,
ZERO,
};
static const enum index item_nvgre[] = {
ITEM_NVGRE_TNI,
ITEM_NEXT,
ZERO,
};
static const enum index item_mpls[] = {
ITEM_MPLS_LABEL,
ITEM_MPLS_TC,
ITEM_MPLS_S,
ITEM_NEXT,
ZERO,
};
static const enum index item_gre[] = {
ITEM_GRE_PROTO,
ITEM_GRE_C_RSVD0_VER,
ITEM_GRE_C_BIT,
ITEM_GRE_K_BIT,
ITEM_GRE_S_BIT,
ITEM_NEXT,
ZERO,
};
static const enum index item_gre_key[] = {
ITEM_GRE_KEY_VALUE,
ITEM_NEXT,
ZERO,
};
static const enum index item_gre_option[] = {
ITEM_GRE_OPTION_CHECKSUM,
ITEM_GRE_OPTION_KEY,
ITEM_GRE_OPTION_SEQUENCE,
ITEM_NEXT,
ZERO,
};
static const enum index item_gtp[] = {
ITEM_GTP_FLAGS,
ITEM_GTP_MSG_TYPE,
ITEM_GTP_TEID,
ITEM_NEXT,
ZERO,
};
static const enum index item_geneve[] = {
ITEM_GENEVE_VNI,
ITEM_GENEVE_PROTO,
ITEM_GENEVE_OPTLEN,
ITEM_NEXT,
ZERO,
};
static const enum index item_vxlan_gpe[] = {
ITEM_VXLAN_GPE_VNI,
ITEM_NEXT,
ZERO,
};
static const enum index item_arp_eth_ipv4[] = {
ITEM_ARP_ETH_IPV4_SHA,
ITEM_ARP_ETH_IPV4_SPA,
ITEM_ARP_ETH_IPV4_THA,
ITEM_ARP_ETH_IPV4_TPA,
ITEM_NEXT,
ZERO,
};
static const enum index item_ipv6_ext[] = {
ITEM_IPV6_EXT_NEXT_HDR,
ITEM_NEXT,
ZERO,
};
static const enum index item_ipv6_frag_ext[] = {
ITEM_IPV6_FRAG_EXT_NEXT_HDR,
ITEM_IPV6_FRAG_EXT_FRAG_DATA,
ITEM_IPV6_FRAG_EXT_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_icmp6[] = {
ITEM_ICMP6_TYPE,
ITEM_ICMP6_CODE,
ITEM_NEXT,
ZERO,
};
static const enum index item_icmp6_nd_ns[] = {
ITEM_ICMP6_ND_NS_TARGET_ADDR,
ITEM_NEXT,
ZERO,
};
static const enum index item_icmp6_nd_na[] = {
ITEM_ICMP6_ND_NA_TARGET_ADDR,
ITEM_NEXT,
ZERO,
};
static const enum index item_icmp6_nd_opt[] = {
ITEM_ICMP6_ND_OPT_TYPE,
ITEM_NEXT,
ZERO,
};
static const enum index item_icmp6_nd_opt_sla_eth[] = {
ITEM_ICMP6_ND_OPT_SLA_ETH_SLA,
ITEM_NEXT,
ZERO,
};
static const enum index item_icmp6_nd_opt_tla_eth[] = {
ITEM_ICMP6_ND_OPT_TLA_ETH_TLA,
ITEM_NEXT,
ZERO,
};
static const enum index item_meta[] = {
ITEM_META_DATA,
ITEM_NEXT,
ZERO,
};
static const enum index item_gtp_psc[] = {
ITEM_GTP_PSC_QFI,
ITEM_GTP_PSC_PDU_T,
ITEM_NEXT,
ZERO,
};
static const enum index item_pppoed[] = {
ITEM_PPPOE_SEID,
ITEM_NEXT,
ZERO,
};
static const enum index item_pppoes[] = {
ITEM_PPPOE_SEID,
ITEM_NEXT,
ZERO,
};
static const enum index item_pppoe_proto_id[] = {
ITEM_NEXT,
ZERO,
};
static const enum index item_higig2[] = {
ITEM_HIGIG2_CLASSIFICATION,
ITEM_HIGIG2_VID,
ITEM_NEXT,
ZERO,
};
static const enum index item_esp[] = {
ITEM_ESP_SPI,
ITEM_NEXT,
ZERO,
};
static const enum index item_ah[] = {
ITEM_AH_SPI,
ITEM_NEXT,
ZERO,
};
static const enum index item_pfcp[] = {
ITEM_PFCP_S_FIELD,
ITEM_PFCP_SEID,
ITEM_NEXT,
ZERO,
};
static const enum index next_set_raw[] = {
SET_RAW_INDEX,
ITEM_ETH,
ZERO,
};
static const enum index item_tag[] = {
ITEM_TAG_DATA,
ITEM_TAG_INDEX,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv3oip[] = {
ITEM_L2TPV3OIP_SESSION_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_ecpri[] = {
ITEM_ECPRI_COMMON,
ITEM_NEXT,
ZERO,
};
static const enum index item_ecpri_common[] = {
ITEM_ECPRI_COMMON_TYPE,
ZERO,
};
static const enum index item_ecpri_common_type[] = {
ITEM_ECPRI_COMMON_TYPE_IQ_DATA,
ITEM_ECPRI_COMMON_TYPE_RTC_CTRL,
ITEM_ECPRI_COMMON_TYPE_DLY_MSR,
ZERO,
};
static const enum index item_geneve_opt[] = {
ITEM_GENEVE_OPT_CLASS,
ITEM_GENEVE_OPT_TYPE,
ITEM_GENEVE_OPT_LENGTH,
ITEM_GENEVE_OPT_DATA,
ITEM_NEXT,
ZERO,
};
static const enum index item_integrity[] = {
ITEM_INTEGRITY_LEVEL,
ITEM_INTEGRITY_VALUE,
ZERO,
};
static const enum index item_integrity_lv[] = {
ITEM_INTEGRITY_LEVEL,
ITEM_INTEGRITY_VALUE,
ITEM_NEXT,
ZERO,
};
static const enum index item_port_representor[] = {
ITEM_PORT_REPRESENTOR_PORT_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_represented_port[] = {
ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_flex[] = {
ITEM_FLEX_PATTERN_HANDLE,
ITEM_FLEX_ITEM_HANDLE,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv2[] = {
ITEM_L2TPV2_TYPE,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv2_type[] = {
ITEM_L2TPV2_TYPE_DATA,
ITEM_L2TPV2_TYPE_DATA_L,
ITEM_L2TPV2_TYPE_DATA_S,
ITEM_L2TPV2_TYPE_DATA_O,
ITEM_L2TPV2_TYPE_DATA_L_S,
ITEM_L2TPV2_TYPE_CTRL,
ZERO,
};
static const enum index item_l2tpv2_type_data[] = {
ITEM_L2TPV2_MSG_DATA_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_SESSION_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv2_type_data_l[] = {
ITEM_L2TPV2_MSG_DATA_L_LENGTH,
ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_L_SESSION_ID,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv2_type_data_s[] = {
ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_S_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_S_NS,
ITEM_L2TPV2_MSG_DATA_S_NR,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv2_type_data_o[] = {
ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_O_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_O_OFFSET,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv2_type_data_l_s[] = {
ITEM_L2TPV2_MSG_DATA_L_S_LENGTH,
ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID,
ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID,
ITEM_L2TPV2_MSG_DATA_L_S_NS,
ITEM_L2TPV2_MSG_DATA_L_S_NR,
ITEM_NEXT,
ZERO,
};
static const enum index item_l2tpv2_type_ctrl[] = {
ITEM_L2TPV2_MSG_CTRL_LENGTH,
ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID,
ITEM_L2TPV2_MSG_CTRL_SESSION_ID,
ITEM_L2TPV2_MSG_CTRL_NS,
ITEM_L2TPV2_MSG_CTRL_NR,
ITEM_NEXT,
ZERO,
};
static const enum index item_ppp[] = {
ITEM_PPP_ADDR,
ITEM_PPP_CTRL,
ITEM_PPP_PROTO_ID,
ITEM_NEXT,
ZERO,
};
static const enum index next_action[] = {
ACTION_END,
ACTION_VOID,
ACTION_PASSTHRU,
ACTION_JUMP,
ACTION_MARK,
ACTION_FLAG,
ACTION_QUEUE,
ACTION_DROP,
ACTION_COUNT,
ACTION_RSS,
ACTION_PF,
ACTION_VF,
ACTION_PHY_PORT,
ACTION_PORT_ID,
ACTION_METER,
ACTION_METER_COLOR,
ACTION_OF_SET_MPLS_TTL,
ACTION_OF_DEC_MPLS_TTL,
ACTION_OF_SET_NW_TTL,
ACTION_OF_DEC_NW_TTL,
ACTION_OF_COPY_TTL_OUT,
ACTION_OF_COPY_TTL_IN,
ACTION_OF_POP_VLAN,
ACTION_OF_PUSH_VLAN,
ACTION_OF_SET_VLAN_VID,
ACTION_OF_SET_VLAN_PCP,
ACTION_OF_POP_MPLS,
ACTION_OF_PUSH_MPLS,
ACTION_VXLAN_ENCAP,
ACTION_VXLAN_DECAP,
ACTION_NVGRE_ENCAP,
ACTION_NVGRE_DECAP,
ACTION_L2_ENCAP,
ACTION_L2_DECAP,
ACTION_MPLSOGRE_ENCAP,
ACTION_MPLSOGRE_DECAP,
ACTION_MPLSOUDP_ENCAP,
ACTION_MPLSOUDP_DECAP,
ACTION_SET_IPV4_SRC,
ACTION_SET_IPV4_DST,
ACTION_SET_IPV6_SRC,
ACTION_SET_IPV6_DST,
ACTION_SET_TP_SRC,
ACTION_SET_TP_DST,
ACTION_MAC_SWAP,
ACTION_DEC_TTL,
ACTION_SET_TTL,
ACTION_SET_MAC_SRC,
ACTION_SET_MAC_DST,
ACTION_INC_TCP_SEQ,
ACTION_DEC_TCP_SEQ,
ACTION_INC_TCP_ACK,
ACTION_DEC_TCP_ACK,
ACTION_RAW_ENCAP,
ACTION_RAW_DECAP,
ACTION_SET_TAG,
ACTION_SET_META,
ACTION_SET_IPV4_DSCP,
ACTION_SET_IPV6_DSCP,
ACTION_AGE,
ACTION_SAMPLE,
ACTION_INDIRECT,
ACTION_MODIFY_FIELD,
ACTION_CONNTRACK,
ACTION_CONNTRACK_UPDATE,
ACTION_PORT_REPRESENTOR,
ACTION_REPRESENTED_PORT,
ZERO,
};
static const enum index action_mark[] = {
ACTION_MARK_ID,
ACTION_NEXT,
ZERO,
};
static const enum index action_queue[] = {
ACTION_QUEUE_INDEX,
ACTION_NEXT,
ZERO,
};
static const enum index action_count[] = {
ACTION_COUNT_ID,
ACTION_NEXT,
ZERO,
};
static const enum index action_rss[] = {
ACTION_RSS_FUNC,
ACTION_RSS_LEVEL,
ACTION_RSS_TYPES,
ACTION_RSS_KEY,
ACTION_RSS_KEY_LEN,
ACTION_RSS_QUEUES,
ACTION_NEXT,
ZERO,
};
static const enum index action_vf[] = {
ACTION_VF_ORIGINAL,
ACTION_VF_ID,
ACTION_NEXT,
ZERO,
};
static const enum index action_phy_port[] = {
ACTION_PHY_PORT_ORIGINAL,
ACTION_PHY_PORT_INDEX,
ACTION_NEXT,
ZERO,
};
static const enum index action_port_id[] = {
ACTION_PORT_ID_ORIGINAL,
ACTION_PORT_ID_ID,
ACTION_NEXT,
ZERO,
};
static const enum index action_meter[] = {
ACTION_METER_ID,
ACTION_NEXT,
ZERO,
};
static const enum index action_meter_color[] = {
ACTION_METER_COLOR_TYPE,
ACTION_NEXT,
ZERO,
};
static const enum index action_of_set_mpls_ttl[] = {
ACTION_OF_SET_MPLS_TTL_MPLS_TTL,
ACTION_NEXT,
ZERO,
};
static const enum index action_of_set_nw_ttl[] = {
ACTION_OF_SET_NW_TTL_NW_TTL,
ACTION_NEXT,
ZERO,
};
static const enum index action_of_push_vlan[] = {
ACTION_OF_PUSH_VLAN_ETHERTYPE,
ACTION_NEXT,
ZERO,
};
static const enum index action_of_set_vlan_vid[] = {
ACTION_OF_SET_VLAN_VID_VLAN_VID,
ACTION_NEXT,
ZERO,
};
static const enum index action_of_set_vlan_pcp[] = {
ACTION_OF_SET_VLAN_PCP_VLAN_PCP,
ACTION_NEXT,
ZERO,
};
static const enum index action_of_pop_mpls[] = {
ACTION_OF_POP_MPLS_ETHERTYPE,
ACTION_NEXT,
ZERO,
};
static const enum index action_of_push_mpls[] = {
ACTION_OF_PUSH_MPLS_ETHERTYPE,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_ipv4_src[] = {
ACTION_SET_IPV4_SRC_IPV4_SRC,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_mac_src[] = {
ACTION_SET_MAC_SRC_MAC_SRC,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_ipv4_dst[] = {
ACTION_SET_IPV4_DST_IPV4_DST,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_ipv6_src[] = {
ACTION_SET_IPV6_SRC_IPV6_SRC,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_ipv6_dst[] = {
ACTION_SET_IPV6_DST_IPV6_DST,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_tp_src[] = {
ACTION_SET_TP_SRC_TP_SRC,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_tp_dst[] = {
ACTION_SET_TP_DST_TP_DST,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_ttl[] = {
ACTION_SET_TTL_TTL,
ACTION_NEXT,
ZERO,
};
static const enum index action_jump[] = {
ACTION_JUMP_GROUP,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_mac_dst[] = {
ACTION_SET_MAC_DST_MAC_DST,
ACTION_NEXT,
ZERO,
};
static const enum index action_inc_tcp_seq[] = {
ACTION_INC_TCP_SEQ_VALUE,
ACTION_NEXT,
ZERO,
};
static const enum index action_dec_tcp_seq[] = {
ACTION_DEC_TCP_SEQ_VALUE,
ACTION_NEXT,
ZERO,
};
static const enum index action_inc_tcp_ack[] = {
ACTION_INC_TCP_ACK_VALUE,
ACTION_NEXT,
ZERO,
};
static const enum index action_dec_tcp_ack[] = {
ACTION_DEC_TCP_ACK_VALUE,
ACTION_NEXT,
ZERO,
};
static const enum index action_raw_encap[] = {
ACTION_RAW_ENCAP_INDEX,
ACTION_NEXT,
ZERO,
};
static const enum index action_raw_decap[] = {
ACTION_RAW_DECAP_INDEX,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_tag[] = {
ACTION_SET_TAG_DATA,
ACTION_SET_TAG_INDEX,
ACTION_SET_TAG_MASK,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_meta[] = {
ACTION_SET_META_DATA,
ACTION_SET_META_MASK,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_ipv4_dscp[] = {
ACTION_SET_IPV4_DSCP_VALUE,
ACTION_NEXT,
ZERO,
};
static const enum index action_set_ipv6_dscp[] = {
ACTION_SET_IPV6_DSCP_VALUE,
ACTION_NEXT,
ZERO,
};
static const enum index action_age[] = {
ACTION_AGE,
ACTION_AGE_TIMEOUT,
ACTION_NEXT,
ZERO,
};
static const enum index action_sample[] = {
ACTION_SAMPLE,
ACTION_SAMPLE_RATIO,
ACTION_SAMPLE_INDEX,
ACTION_NEXT,
ZERO,
};
static const enum index next_action_sample[] = {
ACTION_QUEUE,
ACTION_RSS,
ACTION_MARK,
ACTION_COUNT,
ACTION_PORT_ID,
ACTION_RAW_ENCAP,
ACTION_VXLAN_ENCAP,
ACTION_NVGRE_ENCAP,
ACTION_NEXT,
ZERO,
};
static const enum index action_modify_field_dst[] = {
ACTION_MODIFY_FIELD_DST_LEVEL,
ACTION_MODIFY_FIELD_DST_OFFSET,
ACTION_MODIFY_FIELD_SRC_TYPE,
ZERO,
};
static const enum index action_modify_field_src[] = {
ACTION_MODIFY_FIELD_SRC_LEVEL,
ACTION_MODIFY_FIELD_SRC_OFFSET,
ACTION_MODIFY_FIELD_SRC_VALUE,
ACTION_MODIFY_FIELD_SRC_POINTER,
ACTION_MODIFY_FIELD_WIDTH,
ZERO,
};
static const enum index action_update_conntrack[] = {
ACTION_CONNTRACK_UPDATE_DIR,
ACTION_CONNTRACK_UPDATE_CTX,
ACTION_NEXT,
ZERO,
};
static const enum index action_port_representor[] = {
ACTION_PORT_REPRESENTOR_PORT_ID,
ACTION_NEXT,
ZERO,
};
static const enum index action_represented_port[] = {
ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID,
ACTION_NEXT,
ZERO,
};
static int parse_set_raw_encap_decap(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_set_sample_action(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_set_init(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int
parse_flex_handle(struct context *, const struct token *,
const char *, unsigned int, void *, unsigned int);
static int parse_init(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_vc(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_vc_spec(struct context *, const struct token *,
const char *, unsigned int, void *, unsigned int);
static int parse_vc_conf(struct context *, const struct token *,
const char *, unsigned int, void *, unsigned int);
static int parse_vc_item_ecpri_type(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_vc_item_l2tpv2_type(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_vc_action_meter_color_type(struct context *,
const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_rss(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_rss_func(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_rss_type(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_rss_queue(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_vxlan_encap(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_nvgre_encap(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_l2_encap(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_l2_decap(struct context *, const struct token *,
const char *, unsigned int, void *,
unsigned int);
static int parse_vc_action_mplsogre_encap(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_mplsogre_decap(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_mplsoudp_encap(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_mplsoudp_decap(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_raw_encap(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_raw_decap(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_raw_encap_index(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_raw_decap_index(struct context *,
const struct token *, const char *,
unsigned int, void *, unsigned int);
static int parse_vc_action_set_meta(struct context *ctx,
const struct token *token, const char *str,
unsigned int len, void *buf,
unsigned int size);
static int parse_vc_action_sample(struct context *ctx,
const struct token *token, const char *str,
unsigned int len, void *buf,
unsigned int size);
static int
parse_vc_action_sample_index(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size);
static int
parse_vc_modify_field_op(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size);
static int
parse_vc_modify_field_id(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size);
static int
parse_vc_action_conntrack_update(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size);
static int parse_destroy(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_flush(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_dump(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_query(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_action(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_list(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_aged(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_isolate(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_configure(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_template(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_template_destroy(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_table(struct context *, const struct token *,
const char *, unsigned int, void *, unsigned int);
static int parse_table_destroy(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_qo(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_qo_destroy(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_qia(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_qia_destroy(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_push(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_pull(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_tunnel(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_flex(struct context *, const struct token *,
const char *, unsigned int, void *, unsigned int);
static int parse_int(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_prefix(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_boolean(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_string(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_hex(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size);
static int parse_string0(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_mac_addr(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_ipv4_addr(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_ipv6_addr(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_port(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_ia(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int parse_ia_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size);
static int parse_ia_id2ptr(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size);
static int parse_mp(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
static int comp_none(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_boolean(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_action(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_port(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_rule_id(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_vc_action_rss_type(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_vc_action_rss_queue(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_set_raw_index(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_set_sample_index(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_set_modify_field_op(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_set_modify_field_id(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_pattern_template_id(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_actions_template_id(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_table_id(struct context *, const struct token *,
unsigned int, char *, unsigned int);
static int comp_queue_id(struct context *, const struct token *,
unsigned int, char *, unsigned int);
/** Token definitions. */
static const struct token token_list[] = {
/* Special tokens. */
[ZERO] = {
.name = "ZERO",
.help = "null entry, abused as the entry point",
.next = NEXT(NEXT_ENTRY(FLOW, ADD)),
},
[END] = {
.name = "",
.type = "RETURN",
.help = "command may end here",
},
[START_SET] = {
.name = "START_SET",
.help = "null entry, abused as the entry point for set",
.next = NEXT(NEXT_ENTRY(SET)),
},
[END_SET] = {
.name = "end_set",
.type = "RETURN",
.help = "set command may end here",
},
/* Common tokens. */
[COMMON_INTEGER] = {
.name = "{int}",
.type = "INTEGER",
.help = "integer value",
.call = parse_int,
.comp = comp_none,
},
[COMMON_UNSIGNED] = {
.name = "{unsigned}",
.type = "UNSIGNED",
.help = "unsigned integer value",
.call = parse_int,
.comp = comp_none,
},
[COMMON_PREFIX] = {
.name = "{prefix}",
.type = "PREFIX",
.help = "prefix length for bit-mask",
.call = parse_prefix,
.comp = comp_none,
},
[COMMON_BOOLEAN] = {
.name = "{boolean}",
.type = "BOOLEAN",
.help = "any boolean value",
.call = parse_boolean,
.comp = comp_boolean,
},
[COMMON_STRING] = {
.name = "{string}",
.type = "STRING",
.help = "fixed string",
.call = parse_string,
.comp = comp_none,
},
[COMMON_HEX] = {
.name = "{hex}",
.type = "HEX",
.help = "fixed string",
.call = parse_hex,
},
[COMMON_FILE_PATH] = {
.name = "{file path}",
.type = "STRING",
.help = "file path",
.call = parse_string0,
.comp = comp_none,
},
[COMMON_MAC_ADDR] = {
.name = "{MAC address}",
.type = "MAC-48",
.help = "standard MAC address notation",
.call = parse_mac_addr,
.comp = comp_none,
},
[COMMON_IPV4_ADDR] = {
.name = "{IPv4 address}",
.type = "IPV4 ADDRESS",
.help = "standard IPv4 address notation",
.call = parse_ipv4_addr,
.comp = comp_none,
},
[COMMON_IPV6_ADDR] = {
.name = "{IPv6 address}",
.type = "IPV6 ADDRESS",
.help = "standard IPv6 address notation",
.call = parse_ipv6_addr,
.comp = comp_none,
},
[COMMON_RULE_ID] = {
.name = "{rule id}",
.type = "RULE ID",
.help = "rule identifier",
.call = parse_int,
.comp = comp_rule_id,
},
[COMMON_PORT_ID] = {
.name = "{port_id}",
.type = "PORT ID",
.help = "port identifier",
.call = parse_port,
.comp = comp_port,
},
[COMMON_GROUP_ID] = {
.name = "{group_id}",
.type = "GROUP ID",
.help = "group identifier",
.call = parse_int,
.comp = comp_none,
},
[COMMON_PRIORITY_LEVEL] = {
.name = "{level}",
.type = "PRIORITY",
.help = "priority level",
.call = parse_int,
.comp = comp_none,
},
[COMMON_INDIRECT_ACTION_ID] = {
.name = "{indirect_action_id}",
.type = "INDIRECT_ACTION_ID",
.help = "indirect action id",
.call = parse_int,
.comp = comp_none,
},
[COMMON_POLICY_ID] = {
.name = "{policy_id}",
.type = "POLICY_ID",
.help = "policy id",
.call = parse_int,
.comp = comp_none,
},
[COMMON_FLEX_TOKEN] = {
.name = "{flex token}",
.type = "flex token",
.help = "flex token",
.call = parse_int,
.comp = comp_none,
},
[COMMON_FLEX_HANDLE] = {
.name = "{flex handle}",
.type = "FLEX HANDLE",
.help = "fill flex item data",
.call = parse_flex_handle,
.comp = comp_none,
},
[COMMON_PATTERN_TEMPLATE_ID] = {
.name = "{pattern_template_id}",
.type = "PATTERN_TEMPLATE_ID",
.help = "pattern template id",
.call = parse_int,
.comp = comp_pattern_template_id,
},
[COMMON_ACTIONS_TEMPLATE_ID] = {
.name = "{actions_template_id}",
.type = "ACTIONS_TEMPLATE_ID",
.help = "actions template id",
.call = parse_int,
.comp = comp_actions_template_id,
},
[COMMON_TABLE_ID] = {
.name = "{table_id}",
.type = "TABLE_ID",
.help = "table id",
.call = parse_int,
.comp = comp_table_id,
},
[COMMON_QUEUE_ID] = {
.name = "{queue_id}",
.type = "QUEUE_ID",
.help = "queue id",
.call = parse_int,
.comp = comp_queue_id,
},
/* Top-level command. */
[FLOW] = {
.name = "flow",
.type = "{command} {port_id} [{arg} [...]]",
.help = "manage ingress/egress flow rules",
.next = NEXT(NEXT_ENTRY
(INFO,
CONFIGURE,
PATTERN_TEMPLATE,
ACTIONS_TEMPLATE,
TABLE,
INDIRECT_ACTION,
VALIDATE,
CREATE,
DESTROY,
FLUSH,
DUMP,
LIST,
AGED,
QUERY,
ISOLATE,
TUNNEL,
FLEX,
QUEUE,
PUSH,
PULL)),
.call = parse_init,
},
/* Top-level command. */
[INFO] = {
.name = "info",
.help = "get information about flow engine",
.next = NEXT(NEXT_ENTRY(END),
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_configure,
},
/* Top-level command. */
[CONFIGURE] = {
.name = "configure",
.help = "configure flow engine",
.next = NEXT(next_config_attr,
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_configure,
},
/* Configure arguments. */
[CONFIG_QUEUES_NUMBER] = {
.name = "queues_number",
.help = "number of queues",
.next = NEXT(next_config_attr,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.configure.nb_queue)),
},
[CONFIG_QUEUES_SIZE] = {
.name = "queues_size",
.help = "number of elements in queues",
.next = NEXT(next_config_attr,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.configure.queue_attr.size)),
},
[CONFIG_COUNTERS_NUMBER] = {
.name = "counters_number",
.help = "number of counters",
.next = NEXT(next_config_attr,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.configure.port_attr.nb_counters)),
},
[CONFIG_AGING_OBJECTS_NUMBER] = {
.name = "aging_counters_number",
.help = "number of aging objects",
.next = NEXT(next_config_attr,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.configure.port_attr.nb_aging_objects)),
},
[CONFIG_METERS_NUMBER] = {
.name = "meters_number",
.help = "number of meters",
.next = NEXT(next_config_attr,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.configure.port_attr.nb_meters)),
},
/* Top-level command. */
[PATTERN_TEMPLATE] = {
.name = "pattern_template",
.type = "{command} {port_id} [{arg} [...]]",
.help = "manage pattern templates",
.next = NEXT(next_pt_subcmd, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_template,
},
/* Sub-level commands. */
[PATTERN_TEMPLATE_CREATE] = {
.name = "create",
.help = "create pattern template",
.next = NEXT(next_pt_attr),
.call = parse_template,
},
[PATTERN_TEMPLATE_DESTROY] = {
.name = "destroy",
.help = "destroy pattern template",
.next = NEXT(NEXT_ENTRY(PATTERN_TEMPLATE_DESTROY_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_template_destroy,
},
/* Pattern template arguments. */
[PATTERN_TEMPLATE_CREATE_ID] = {
.name = "pattern_template_id",
.help = "specify a pattern template id to create",
.next = NEXT(next_pt_attr,
NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.vc.pat_templ_id)),
},
[PATTERN_TEMPLATE_DESTROY_ID] = {
.name = "pattern_template",
.help = "specify a pattern template id to destroy",
.next = NEXT(next_pt_destroy_attr,
NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.templ_destroy.template_id)),
.call = parse_template_destroy,
},
[PATTERN_TEMPLATE_RELAXED_MATCHING] = {
.name = "relaxed",
.help = "is matching relaxed",
.next = NEXT(next_pt_attr,
NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY_BF(struct buffer,
args.vc.attr.reserved, 1)),
},
[PATTERN_TEMPLATE_INGRESS] = {
.name = "ingress",
.help = "attribute pattern to ingress",
.next = NEXT(next_pt_attr),
.call = parse_template,
},
[PATTERN_TEMPLATE_EGRESS] = {
.name = "egress",
.help = "attribute pattern to egress",
.next = NEXT(next_pt_attr),
.call = parse_template,
},
[PATTERN_TEMPLATE_TRANSFER] = {
.name = "transfer",
.help = "attribute pattern to transfer",
.next = NEXT(next_pt_attr),
.call = parse_template,
},
[PATTERN_TEMPLATE_SPEC] = {
.name = "template",
.help = "specify item to create pattern template",
.next = NEXT(next_item),
},
/* Top-level command. */
[ACTIONS_TEMPLATE] = {
.name = "actions_template",
.type = "{command} {port_id} [{arg} [...]]",
.help = "manage actions templates",
.next = NEXT(next_at_subcmd, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_template,
},
/* Sub-level commands. */
[ACTIONS_TEMPLATE_CREATE] = {
.name = "create",
.help = "create actions template",
.next = NEXT(next_at_attr),
.call = parse_template,
},
[ACTIONS_TEMPLATE_DESTROY] = {
.name = "destroy",
.help = "destroy actions template",
.next = NEXT(NEXT_ENTRY(ACTIONS_TEMPLATE_DESTROY_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_template_destroy,
},
/* Actions template arguments. */
[ACTIONS_TEMPLATE_CREATE_ID] = {
.name = "actions_template_id",
.help = "specify an actions template id to create",
.next = NEXT(NEXT_ENTRY(ACTIONS_TEMPLATE_MASK),
NEXT_ENTRY(ACTIONS_TEMPLATE_SPEC),
NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.vc.act_templ_id)),
},
[ACTIONS_TEMPLATE_DESTROY_ID] = {
.name = "actions_template",
.help = "specify an actions template id to destroy",
.next = NEXT(next_at_destroy_attr,
NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.templ_destroy.template_id)),
.call = parse_template_destroy,
},
[ACTIONS_TEMPLATE_INGRESS] = {
.name = "ingress",
.help = "attribute actions to ingress",
.next = NEXT(next_at_attr),
.call = parse_template,
},
[ACTIONS_TEMPLATE_EGRESS] = {
.name = "egress",
.help = "attribute actions to egress",
.next = NEXT(next_at_attr),
.call = parse_template,
},
[ACTIONS_TEMPLATE_TRANSFER] = {
.name = "transfer",
.help = "attribute actions to transfer",
.next = NEXT(next_at_attr),
.call = parse_template,
},
[ACTIONS_TEMPLATE_SPEC] = {
.name = "template",
.help = "specify action to create actions template",
.next = NEXT(next_action),
.call = parse_template,
},
[ACTIONS_TEMPLATE_MASK] = {
.name = "mask",
.help = "specify action mask to create actions template",
.next = NEXT(next_action),
.call = parse_template,
},
/* Top-level command. */
[TABLE] = {
.name = "template_table",
.type = "{command} {port_id} [{arg} [...]]",
.help = "manage template tables",
.next = NEXT(next_table_subcmd, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_table,
},
/* Sub-level commands. */
[TABLE_CREATE] = {
.name = "create",
.help = "create template table",
.next = NEXT(next_table_attr),
.call = parse_table,
},
[TABLE_DESTROY] = {
.name = "destroy",
.help = "destroy template table",
.next = NEXT(NEXT_ENTRY(TABLE_DESTROY_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_table_destroy,
},
/* Table arguments. */
[TABLE_CREATE_ID] = {
.name = "table_id",
.help = "specify table id to create",
.next = NEXT(next_table_attr,
NEXT_ENTRY(COMMON_TABLE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.table.id)),
},
[TABLE_DESTROY_ID] = {
.name = "table",
.help = "specify table id to destroy",
.next = NEXT(next_table_destroy_attr,
NEXT_ENTRY(COMMON_TABLE_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.table_destroy.table_id)),
.call = parse_table_destroy,
},
[TABLE_GROUP] = {
.name = "group",
.help = "specify a group",
.next = NEXT(next_table_attr, NEXT_ENTRY(COMMON_GROUP_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.table.attr.flow_attr.group)),
},
[TABLE_PRIORITY] = {
.name = "priority",
.help = "specify a priority level",
.next = NEXT(next_table_attr, NEXT_ENTRY(COMMON_PRIORITY_LEVEL)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.table.attr.flow_attr.priority)),
},
[TABLE_EGRESS] = {
.name = "egress",
.help = "affect rule to egress",
.next = NEXT(next_table_attr),
.call = parse_table,
},
[TABLE_INGRESS] = {
.name = "ingress",
.help = "affect rule to ingress",
.next = NEXT(next_table_attr),
.call = parse_table,
},
[TABLE_TRANSFER] = {
.name = "transfer",
.help = "affect rule to transfer",
.next = NEXT(next_table_attr),
.call = parse_table,
},
[TABLE_RULES_NUMBER] = {
.name = "rules_number",
.help = "number of rules in table",
.next = NEXT(next_table_attr,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.table.attr.nb_flows)),
},
[TABLE_PATTERN_TEMPLATE] = {
.name = "pattern_template",
.help = "specify pattern template id",
.next = NEXT(next_table_attr,
NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.table.pat_templ_id)),
.call = parse_table,
},
[TABLE_ACTIONS_TEMPLATE] = {
.name = "actions_template",
.help = "specify actions template id",
.next = NEXT(next_table_attr,
NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.table.act_templ_id)),
.call = parse_table,
},
/* Top-level command. */
[QUEUE] = {
.name = "queue",
.help = "queue a flow rule operation",
.next = NEXT(next_queue_subcmd, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_qo,
},
/* Sub-level commands. */
[QUEUE_CREATE] = {
.name = "create",
.help = "create a flow rule",
.next = NEXT(NEXT_ENTRY(QUEUE_TEMPLATE_TABLE),
NEXT_ENTRY(COMMON_QUEUE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, queue)),
.call = parse_qo,
},
[QUEUE_DESTROY] = {
.name = "destroy",
.help = "destroy a flow rule",
.next = NEXT(NEXT_ENTRY(QUEUE_DESTROY_ID),
NEXT_ENTRY(COMMON_QUEUE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, queue)),
.call = parse_qo_destroy,
},
[QUEUE_INDIRECT_ACTION] = {
.name = "indirect_action",
.help = "queue indirect actions",
.next = NEXT(next_qia_subcmd, NEXT_ENTRY(COMMON_QUEUE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, queue)),
.call = parse_qia,
},
/* Queue arguments. */
[QUEUE_TEMPLATE_TABLE] = {
.name = "template table",
.help = "specify table id",
.next = NEXT(NEXT_ENTRY(QUEUE_PATTERN_TEMPLATE),
NEXT_ENTRY(COMMON_TABLE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.vc.table_id)),
.call = parse_qo,
},
[QUEUE_PATTERN_TEMPLATE] = {
.name = "pattern_template",
.help = "specify pattern template index",
.next = NEXT(NEXT_ENTRY(QUEUE_ACTIONS_TEMPLATE),
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.vc.pat_templ_id)),
.call = parse_qo,
},
[QUEUE_ACTIONS_TEMPLATE] = {
.name = "actions_template",
.help = "specify actions template index",
.next = NEXT(NEXT_ENTRY(QUEUE_CREATE_POSTPONE),
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct buffer,
args.vc.act_templ_id)),
.call = parse_qo,
},
[QUEUE_CREATE_POSTPONE] = {
.name = "postpone",
.help = "postpone create operation",
.next = NEXT(NEXT_ENTRY(ITEM_PATTERN),
NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY(struct buffer, postpone)),
.call = parse_qo,
},
[QUEUE_DESTROY_POSTPONE] = {
.name = "postpone",
.help = "postpone destroy operation",
.next = NEXT(NEXT_ENTRY(QUEUE_DESTROY_ID),
NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY(struct buffer, postpone)),
.call = parse_qo_destroy,
},
[QUEUE_DESTROY_ID] = {
.name = "rule",
.help = "specify rule id to destroy",
.next = NEXT(next_queue_destroy_attr,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.destroy.rule)),
.call = parse_qo_destroy,
},
/* Queue indirect action arguments */
[QUEUE_INDIRECT_ACTION_CREATE] = {
.name = "create",
.help = "create indirect action",
.next = NEXT(next_qia_create_attr),
.call = parse_qia,
},
[QUEUE_INDIRECT_ACTION_UPDATE] = {
.name = "update",
.help = "update indirect action",
.next = NEXT(next_qia_update_attr,
NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)),
.call = parse_qia,
},
[QUEUE_INDIRECT_ACTION_DESTROY] = {
.name = "destroy",
.help = "destroy indirect action",
.next = NEXT(next_qia_destroy_attr),
.call = parse_qia_destroy,
},
/* Indirect action destroy arguments. */
[QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE] = {
.name = "postpone",
.help = "postpone destroy operation",
.next = NEXT(next_qia_destroy_attr,
NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY(struct buffer, postpone)),
},
[QUEUE_INDIRECT_ACTION_DESTROY_ID] = {
.name = "action_id",
.help = "specify a indirect action id to destroy",
.next = NEXT(next_qia_destroy_attr,
NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.ia_destroy.action_id)),
.call = parse_qia_destroy,
},
/* Indirect action update arguments. */
[QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE] = {
.name = "postpone",
.help = "postpone update operation",
.next = NEXT(next_qia_update_attr,
NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY(struct buffer, postpone)),
},
/* Indirect action create arguments. */
[QUEUE_INDIRECT_ACTION_CREATE_ID] = {
.name = "action_id",
.help = "specify a indirect action id to create",
.next = NEXT(next_qia_create_attr,
NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)),
},
[QUEUE_INDIRECT_ACTION_INGRESS] = {
.name = "ingress",
.help = "affect rule to ingress",
.next = NEXT(next_qia_create_attr),
.call = parse_qia,
},
[QUEUE_INDIRECT_ACTION_EGRESS] = {
.name = "egress",
.help = "affect rule to egress",
.next = NEXT(next_qia_create_attr),
.call = parse_qia,
},
[QUEUE_INDIRECT_ACTION_TRANSFER] = {
.name = "transfer",
.help = "affect rule to transfer",
.next = NEXT(next_qia_create_attr),
.call = parse_qia,
},
[QUEUE_INDIRECT_ACTION_CREATE_POSTPONE] = {
.name = "postpone",
.help = "postpone create operation",
.next = NEXT(next_qia_create_attr,
NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY(struct buffer, postpone)),
},
[QUEUE_INDIRECT_ACTION_SPEC] = {
.name = "action",
.help = "specify action to create indirect handle",
.next = NEXT(next_action),
},
/* Top-level command. */
[PUSH] = {
.name = "push",
.help = "push enqueued operations",
.next = NEXT(NEXT_ENTRY(PUSH_QUEUE), NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_push,
},
/* Sub-level commands. */
[PUSH_QUEUE] = {
.name = "queue",
.help = "specify queue id",
.next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(COMMON_QUEUE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, queue)),
},
/* Top-level command. */
[PULL] = {
.name = "pull",
.help = "pull flow operations results",
.next = NEXT(NEXT_ENTRY(PULL_QUEUE), NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_pull,
},
/* Sub-level commands. */
[PULL_QUEUE] = {
.name = "queue",
.help = "specify queue id",
.next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(COMMON_QUEUE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, queue)),
},
/* Top-level command. */
[INDIRECT_ACTION] = {
.name = "indirect_action",
.type = "{command} {port_id} [{arg} [...]]",
.help = "manage indirect actions",
.next = NEXT(next_ia_subcmd, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_ia,
},
/* Sub-level commands. */
[INDIRECT_ACTION_CREATE] = {
.name = "create",
.help = "create indirect action",
.next = NEXT(next_ia_create_attr),
.call = parse_ia,
},
[INDIRECT_ACTION_UPDATE] = {
.name = "update",
.help = "update indirect action",
.next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_SPEC),
NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)),
.call = parse_ia,
},
[INDIRECT_ACTION_DESTROY] = {
.name = "destroy",
.help = "destroy indirect action",
.next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_DESTROY_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_ia_destroy,
},
[INDIRECT_ACTION_QUERY] = {
.name = "query",
.help = "query indirect action",
.next = NEXT(NEXT_ENTRY(END),
NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.ia.action_id)),
.call = parse_ia,
},
[VALIDATE] = {
.name = "validate",
.help = "check whether a flow rule can be created",
.next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_vc,
},
[CREATE] = {
.name = "create",
.help = "create a flow rule",
.next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_vc,
},
[DESTROY] = {
.name = "destroy",
.help = "destroy specific flow rules",
.next = NEXT(NEXT_ENTRY(DESTROY_RULE),
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_destroy,
},
[FLUSH] = {
.name = "flush",
.help = "destroy all flow rules",
.next = NEXT(NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_flush,
},
[DUMP] = {
.name = "dump",
.help = "dump single/all flow rules to file",
.next = NEXT(next_dump_subcmd, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_dump,
},
[QUERY] = {
.name = "query",
.help = "query an existing flow rule",
.next = NEXT(NEXT_ENTRY(QUERY_ACTION),
NEXT_ENTRY(COMMON_RULE_ID),
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.query.action.type),
ARGS_ENTRY(struct buffer, args.query.rule),
ARGS_ENTRY(struct buffer, port)),
.call = parse_query,
},
[LIST] = {
.name = "list",
.help = "list existing flow rules",
.next = NEXT(next_list_attr, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_list,
},
[AGED] = {
.name = "aged",
.help = "list and destroy aged flows",
.next = NEXT(next_aged_attr, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_aged,
},
[ISOLATE] = {
.name = "isolate",
.help = "restrict ingress traffic to the defined flow rules",
.next = NEXT(NEXT_ENTRY(COMMON_BOOLEAN),
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.isolate.set),
ARGS_ENTRY(struct buffer, port)),
.call = parse_isolate,
},
[FLEX] = {
.name = "flex_item",
.help = "flex item API",
.next = NEXT(next_flex_item),
.call = parse_flex,
},
[FLEX_ITEM_INIT] = {
.name = "init",
.help = "flex item init",
.args = ARGS(ARGS_ENTRY(struct buffer, args.flex.token),
ARGS_ENTRY(struct buffer, port)),
.next = NEXT(NEXT_ENTRY(COMMON_FLEX_TOKEN),
NEXT_ENTRY(COMMON_PORT_ID)),
.call = parse_flex
},
[FLEX_ITEM_CREATE] = {
.name = "create",
.help = "flex item create",
.args = ARGS(ARGS_ENTRY(struct buffer, args.flex.filename),
ARGS_ENTRY(struct buffer, args.flex.token),
ARGS_ENTRY(struct buffer, port)),
.next = NEXT(NEXT_ENTRY(COMMON_FILE_PATH),
NEXT_ENTRY(COMMON_FLEX_TOKEN),
NEXT_ENTRY(COMMON_PORT_ID)),
.call = parse_flex
},
[FLEX_ITEM_DESTROY] = {
.name = "destroy",
.help = "flex item destroy",
.args = ARGS(ARGS_ENTRY(struct buffer, args.flex.token),
ARGS_ENTRY(struct buffer, port)),
.next = NEXT(NEXT_ENTRY(COMMON_FLEX_TOKEN),
NEXT_ENTRY(COMMON_PORT_ID)),
.call = parse_flex
},
[TUNNEL] = {
.name = "tunnel",
.help = "new tunnel API",
.next = NEXT(NEXT_ENTRY
(TUNNEL_CREATE, TUNNEL_LIST, TUNNEL_DESTROY)),
.call = parse_tunnel,
},
/* Tunnel arguments. */
[TUNNEL_CREATE] = {
.name = "create",
.help = "create new tunnel object",
.next = NEXT(NEXT_ENTRY(TUNNEL_CREATE_TYPE),
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_tunnel,
},
[TUNNEL_CREATE_TYPE] = {
.name = "type",
.help = "create new tunnel",
.next = NEXT(NEXT_ENTRY(COMMON_FILE_PATH)),
.args = ARGS(ARGS_ENTRY(struct tunnel_ops, type)),
.call = parse_tunnel,
},
[TUNNEL_DESTROY] = {
.name = "destroy",
.help = "destroy tunnel",
.next = NEXT(NEXT_ENTRY(TUNNEL_DESTROY_ID),
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_tunnel,
},
[TUNNEL_DESTROY_ID] = {
.name = "id",
.help = "tunnel identifier to destroy",
.next = NEXT(NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
.call = parse_tunnel,
},
[TUNNEL_LIST] = {
.name = "list",
.help = "list existing tunnels",
.next = NEXT(NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_tunnel,
},
/* Destroy arguments. */
[DESTROY_RULE] = {
.name = "rule",
.help = "specify a rule identifier",
.next = NEXT(next_destroy_attr, NEXT_ENTRY(COMMON_RULE_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.destroy.rule)),
.call = parse_destroy,
},
/* Dump arguments. */
[DUMP_ALL] = {
.name = "all",
.help = "dump all",
.next = NEXT(next_dump_attr),
.args = ARGS(ARGS_ENTRY(struct buffer, args.dump.file)),
.call = parse_dump,
},
[DUMP_ONE] = {
.name = "rule",
.help = "dump one rule",
.next = NEXT(next_dump_attr, NEXT_ENTRY(COMMON_RULE_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.dump.file),
ARGS_ENTRY(struct buffer, args.dump.rule)),
.call = parse_dump,
},
/* Query arguments. */
[QUERY_ACTION] = {
.name = "{action}",
.type = "ACTION",
.help = "action to query, must be part of the rule",
.call = parse_action,
.comp = comp_action,
},
/* List arguments. */
[LIST_GROUP] = {
.name = "group",
.help = "specify a group",
.next = NEXT(next_list_attr, NEXT_ENTRY(COMMON_GROUP_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.list.group)),
.call = parse_list,
},
[AGED_DESTROY] = {
.name = "destroy",
.help = "specify aged flows need be destroyed",
.call = parse_aged,
.comp = comp_none,
},
/* Validate/create attributes. */
[VC_GROUP] = {
.name = "group",
.help = "specify a group",
.next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_GROUP_ID)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, group)),
.call = parse_vc,
},
[VC_PRIORITY] = {
.name = "priority",
.help = "specify a priority level",
.next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PRIORITY_LEVEL)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, priority)),
.call = parse_vc,
},
[VC_INGRESS] = {
.name = "ingress",
.help = "affect rule to ingress",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
[VC_EGRESS] = {
.name = "egress",
.help = "affect rule to egress",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
[VC_TRANSFER] = {
.name = "transfer",
.help = "apply rule directly to endpoints found in pattern",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
[VC_TUNNEL_SET] = {
.name = "tunnel_set",
.help = "tunnel steer rule",
.next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
.call = parse_vc,
},
[VC_TUNNEL_MATCH] = {
.name = "tunnel_match",
.help = "tunnel match rule",
.next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
.call = parse_vc,
},
/* Validate/create pattern. */
[ITEM_PATTERN] = {
.name = "pattern",
.help = "submit a list of pattern items",
.next = NEXT(next_item),
.call = parse_vc,
},
[ITEM_PARAM_IS] = {
.name = "is",
.help = "match value perfectly (with full bit-mask)",
.call = parse_vc_spec,
},
[ITEM_PARAM_SPEC] = {
.name = "spec",
.help = "match value according to configured bit-mask",
.call = parse_vc_spec,
},
[ITEM_PARAM_LAST] = {
.name = "last",
.help = "specify upper bound to establish a range",
.call = parse_vc_spec,
},
[ITEM_PARAM_MASK] = {
.name = "mask",
.help = "specify bit-mask with relevant bits set to one",
.call = parse_vc_spec,
},
[ITEM_PARAM_PREFIX] = {
.name = "prefix",
.help = "generate bit-mask from a prefix length",
.call = parse_vc_spec,
},
[ITEM_NEXT] = {
.name = "/",
.help = "specify next pattern item",
.next = NEXT(next_item),
},
[ITEM_END] = {
.name = "end",
.help = "end list of pattern items",
.priv = PRIV_ITEM(END, 0),
.next = NEXT(NEXT_ENTRY(ACTIONS, END)),
.call = parse_vc,
},
[ITEM_VOID] = {
.name = "void",
.help = "no-op pattern item",
.priv = PRIV_ITEM(VOID, 0),
.next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
.call = parse_vc,
},
[ITEM_INVERT] = {
.name = "invert",
.help = "perform actions when pattern does not match",
.priv = PRIV_ITEM(INVERT, 0),
.next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
.call = parse_vc,
},
[ITEM_ANY] = {
.name = "any",
.help = "match any protocol for the current layer",
.priv = PRIV_ITEM(ANY, sizeof(struct rte_flow_item_any)),
.next = NEXT(item_any),
.call = parse_vc,
},
[ITEM_ANY_NUM] = {
.name = "num",
.help = "number of layers covered",
.next = NEXT(item_any, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_any, num)),
},
[ITEM_PF] = {
.name = "pf",
.help = "match traffic from/to the physical function",
.priv = PRIV_ITEM(PF, 0),
.next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
.call = parse_vc,
},
[ITEM_VF] = {
.name = "vf",
.help = "match traffic from/to a virtual function ID",
.priv = PRIV_ITEM(VF, sizeof(struct rte_flow_item_vf)),
.next = NEXT(item_vf),
.call = parse_vc,
},
[ITEM_VF_ID] = {
.name = "id",
.help = "VF ID",
.next = NEXT(item_vf, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_vf, id)),
},
[ITEM_PHY_PORT] = {
.name = "phy_port",
.help = "match traffic from/to a specific physical port",
.priv = PRIV_ITEM(PHY_PORT,
sizeof(struct rte_flow_item_phy_port)),
.next = NEXT(item_phy_port),
.call = parse_vc,
},
[ITEM_PHY_PORT_INDEX] = {
.name = "index",
.help = "physical port index",
.next = NEXT(item_phy_port, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_phy_port, index)),
},
[ITEM_PORT_ID] = {
.name = "port_id",
.help = "match traffic from/to a given DPDK port ID",
.priv = PRIV_ITEM(PORT_ID,
sizeof(struct rte_flow_item_port_id)),
.next = NEXT(item_port_id),
.call = parse_vc,
},
[ITEM_PORT_ID_ID] = {
.name = "id",
.help = "DPDK port ID",
.next = NEXT(item_port_id, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_port_id, id)),
},
[ITEM_MARK] = {
.name = "mark",
.help = "match traffic against value set in previously matched rule",
.priv = PRIV_ITEM(MARK, sizeof(struct rte_flow_item_mark)),
.next = NEXT(item_mark),
.call = parse_vc,
},
[ITEM_MARK_ID] = {
.name = "id",
.help = "Integer value to match against",
.next = NEXT(item_mark, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_mark, id)),
},
[ITEM_RAW] = {
.name = "raw",
.help = "match an arbitrary byte string",
.priv = PRIV_ITEM(RAW, ITEM_RAW_SIZE),
.next = NEXT(item_raw),
.call = parse_vc,
},
[ITEM_RAW_RELATIVE] = {
.name = "relative",
.help = "look for pattern after the previous item",
.next = NEXT(item_raw, NEXT_ENTRY(COMMON_BOOLEAN), item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_raw,
relative, 1)),
},
[ITEM_RAW_SEARCH] = {
.name = "search",
.help = "search pattern from offset (see also limit)",
.next = NEXT(item_raw, NEXT_ENTRY(COMMON_BOOLEAN), item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_raw,
search, 1)),
},
[ITEM_RAW_OFFSET] = {
.name = "offset",
.help = "absolute or relative offset for pattern",
.next = NEXT(item_raw, NEXT_ENTRY(COMMON_INTEGER), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, offset)),
},
[ITEM_RAW_LIMIT] = {
.name = "limit",
.help = "search area limit for start of pattern",
.next = NEXT(item_raw, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, limit)),
},
[ITEM_RAW_PATTERN] = {
.name = "pattern",
.help = "byte string to look for",
.next = NEXT(item_raw,
NEXT_ENTRY(COMMON_STRING),
NEXT_ENTRY(ITEM_PARAM_IS,
ITEM_PARAM_SPEC,
ITEM_PARAM_MASK)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, pattern),
ARGS_ENTRY(struct rte_flow_item_raw, length),
ARGS_ENTRY_ARB(sizeof(struct rte_flow_item_raw),
ITEM_RAW_PATTERN_SIZE)),
},
[ITEM_RAW_PATTERN_HEX] = {
.name = "pattern_hex",
.help = "hex string to look for",
.next = NEXT(item_raw,
NEXT_ENTRY(COMMON_HEX),
NEXT_ENTRY(ITEM_PARAM_IS,
ITEM_PARAM_SPEC,
ITEM_PARAM_MASK)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, pattern),
ARGS_ENTRY(struct rte_flow_item_raw, length),
ARGS_ENTRY_ARB(sizeof(struct rte_flow_item_raw),
ITEM_RAW_PATTERN_SIZE)),
},
[ITEM_ETH] = {
.name = "eth",
.help = "match Ethernet header",
.priv = PRIV_ITEM(ETH, sizeof(struct rte_flow_item_eth)),
.next = NEXT(item_eth),
.call = parse_vc,
},
[ITEM_ETH_DST] = {
.name = "dst",
.help = "destination MAC",
.next = NEXT(item_eth, NEXT_ENTRY(COMMON_MAC_ADDR), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, dst)),
},
[ITEM_ETH_SRC] = {
.name = "src",
.help = "source MAC",
.next = NEXT(item_eth, NEXT_ENTRY(COMMON_MAC_ADDR), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, src)),
},
[ITEM_ETH_TYPE] = {
.name = "type",
.help = "EtherType",
.next = NEXT(item_eth, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, type)),
},
[ITEM_ETH_HAS_VLAN] = {
.name = "has_vlan",
.help = "packet header contains VLAN",
.next = NEXT(item_eth, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_eth,
has_vlan, 1)),
},
[ITEM_VLAN] = {
.name = "vlan",
.help = "match 802.1Q/ad VLAN tag",
.priv = PRIV_ITEM(VLAN, sizeof(struct rte_flow_item_vlan)),
.next = NEXT(item_vlan),
.call = parse_vc,
},
[ITEM_VLAN_TCI] = {
.name = "tci",
.help = "tag control information",
.next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan, tci)),
},
[ITEM_VLAN_PCP] = {
.name = "pcp",
.help = "priority code point",
.next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
tci, "\xe0\x00")),
},
[ITEM_VLAN_DEI] = {
.name = "dei",
.help = "drop eligible indicator",
.next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
tci, "\x10\x00")),
},
[ITEM_VLAN_VID] = {
.name = "vid",
.help = "VLAN identifier",
.next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
tci, "\x0f\xff")),
},
[ITEM_VLAN_INNER_TYPE] = {
.name = "inner_type",
.help = "inner EtherType",
.next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan,
inner_type)),
},
[ITEM_VLAN_HAS_MORE_VLAN] = {
.name = "has_more_vlan",
.help = "packet header contains another VLAN",
.next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_vlan,
has_more_vlan, 1)),
},
[ITEM_IPV4] = {
.name = "ipv4",
.help = "match IPv4 header",
.priv = PRIV_ITEM(IPV4, sizeof(struct rte_flow_item_ipv4)),
.next = NEXT(item_ipv4),
.call = parse_vc,
},
[ITEM_IPV4_VER_IHL] = {
.name = "version_ihl",
.help = "match header length",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ipv4,
hdr.version_ihl)),
},
[ITEM_IPV4_TOS] = {
.name = "tos",
.help = "type of service",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.type_of_service)),
},
[ITEM_IPV4_ID] = {
.name = "packet_id",
.help = "fragment packet id",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.packet_id)),
},
[ITEM_IPV4_FRAGMENT_OFFSET] = {
.name = "fragment_offset",
.help = "fragmentation flags and fragment offset",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.fragment_offset)),
},
[ITEM_IPV4_TTL] = {
.name = "ttl",
.help = "time to live",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.time_to_live)),
},
[ITEM_IPV4_PROTO] = {
.name = "proto",
.help = "next protocol ID",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.next_proto_id)),
},
[ITEM_IPV4_SRC] = {
.name = "src",
.help = "source address",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_IPV4_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.src_addr)),
},
[ITEM_IPV4_DST] = {
.name = "dst",
.help = "destination address",
.next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_IPV4_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.dst_addr)),
},
[ITEM_IPV6] = {
.name = "ipv6",
.help = "match IPv6 header",
.priv = PRIV_ITEM(IPV6, sizeof(struct rte_flow_item_ipv6)),
.next = NEXT(item_ipv6),
.call = parse_vc,
},
[ITEM_IPV6_TC] = {
.name = "tc",
.help = "traffic class",
.next = NEXT(item_ipv6, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_ipv6,
hdr.vtc_flow,
"\x0f\xf0\x00\x00")),
},
[ITEM_IPV6_FLOW] = {
.name = "flow",
.help = "flow label",
.next = NEXT(item_ipv6, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_ipv6,
hdr.vtc_flow,
"\x00\x0f\xff\xff")),
},
[ITEM_IPV6_PROTO] = {
.name = "proto",
.help = "protocol (next header)",
.next = NEXT(item_ipv6, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
hdr.proto)),
},
[ITEM_IPV6_HOP] = {
.name = "hop",
.help = "hop limit",
.next = NEXT(item_ipv6, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
hdr.hop_limits)),
},
[ITEM_IPV6_SRC] = {
.name = "src",
.help = "source address",
.next = NEXT(item_ipv6, NEXT_ENTRY(COMMON_IPV6_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
hdr.src_addr)),
},
[ITEM_IPV6_DST] = {
.name = "dst",
.help = "destination address",
.next = NEXT(item_ipv6, NEXT_ENTRY(COMMON_IPV6_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
hdr.dst_addr)),
},
[ITEM_IPV6_HAS_FRAG_EXT] = {
.name = "has_frag_ext",
.help = "fragment packet attribute",
.next = NEXT(item_ipv6, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_ipv6,
has_frag_ext, 1)),
},
[ITEM_ICMP] = {
.name = "icmp",
.help = "match ICMP header",
.priv = PRIV_ITEM(ICMP, sizeof(struct rte_flow_item_icmp)),
.next = NEXT(item_icmp),
.call = parse_vc,
},
[ITEM_ICMP_TYPE] = {
.name = "type",
.help = "ICMP packet type",
.next = NEXT(item_icmp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
hdr.icmp_type)),
},
[ITEM_ICMP_CODE] = {
.name = "code",
.help = "ICMP packet code",
.next = NEXT(item_icmp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
hdr.icmp_code)),
},
[ITEM_ICMP_IDENT] = {
.name = "ident",
.help = "ICMP packet identifier",
.next = NEXT(item_icmp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
hdr.icmp_ident)),
},
[ITEM_ICMP_SEQ] = {
.name = "seq",
.help = "ICMP packet sequence number",
.next = NEXT(item_icmp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
hdr.icmp_seq_nb)),
},
[ITEM_UDP] = {
.name = "udp",
.help = "match UDP header",
.priv = PRIV_ITEM(UDP, sizeof(struct rte_flow_item_udp)),
.next = NEXT(item_udp),
.call = parse_vc,
},
[ITEM_UDP_SRC] = {
.name = "src",
.help = "UDP source port",
.next = NEXT(item_udp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_udp,
hdr.src_port)),
},
[ITEM_UDP_DST] = {
.name = "dst",
.help = "UDP destination port",
.next = NEXT(item_udp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_udp,
hdr.dst_port)),
},
[ITEM_TCP] = {
.name = "tcp",
.help = "match TCP header",
.priv = PRIV_ITEM(TCP, sizeof(struct rte_flow_item_tcp)),
.next = NEXT(item_tcp),
.call = parse_vc,
},
[ITEM_TCP_SRC] = {
.name = "src",
.help = "TCP source port",
.next = NEXT(item_tcp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
hdr.src_port)),
},
[ITEM_TCP_DST] = {
.name = "dst",
.help = "TCP destination port",
.next = NEXT(item_tcp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
hdr.dst_port)),
},
[ITEM_TCP_FLAGS] = {
.name = "flags",
.help = "TCP flags",
.next = NEXT(item_tcp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
hdr.tcp_flags)),
},
[ITEM_SCTP] = {
.name = "sctp",
.help = "match SCTP header",
.priv = PRIV_ITEM(SCTP, sizeof(struct rte_flow_item_sctp)),
.next = NEXT(item_sctp),
.call = parse_vc,
},
[ITEM_SCTP_SRC] = {
.name = "src",
.help = "SCTP source port",
.next = NEXT(item_sctp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
hdr.src_port)),
},
[ITEM_SCTP_DST] = {
.name = "dst",
.help = "SCTP destination port",
.next = NEXT(item_sctp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
hdr.dst_port)),
},
[ITEM_SCTP_TAG] = {
.name = "tag",
.help = "validation tag",
.next = NEXT(item_sctp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
hdr.tag)),
},
[ITEM_SCTP_CKSUM] = {
.name = "cksum",
.help = "checksum",
.next = NEXT(item_sctp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
hdr.cksum)),
},
[ITEM_VXLAN] = {
.name = "vxlan",
.help = "match VXLAN header",
.priv = PRIV_ITEM(VXLAN, sizeof(struct rte_flow_item_vxlan)),
.next = NEXT(item_vxlan),
.call = parse_vc,
},
[ITEM_VXLAN_VNI] = {
.name = "vni",
.help = "VXLAN identifier",
.next = NEXT(item_vxlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan, vni)),
},
[ITEM_VXLAN_LAST_RSVD] = {
.name = "last_rsvd",
.help = "VXLAN last reserved bits",
.next = NEXT(item_vxlan, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan,
rsvd1)),
},
[ITEM_E_TAG] = {
.name = "e_tag",
.help = "match E-Tag header",
.priv = PRIV_ITEM(E_TAG, sizeof(struct rte_flow_item_e_tag)),
.next = NEXT(item_e_tag),
.call = parse_vc,
},
[ITEM_E_TAG_GRP_ECID_B] = {
.name = "grp_ecid_b",
.help = "GRP and E-CID base",
.next = NEXT(item_e_tag, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_e_tag,
rsvd_grp_ecid_b,
"\x3f\xff")),
},
[ITEM_NVGRE] = {
.name = "nvgre",
.help = "match NVGRE header",
.priv = PRIV_ITEM(NVGRE, sizeof(struct rte_flow_item_nvgre)),
.next = NEXT(item_nvgre),
.call = parse_vc,
},
[ITEM_NVGRE_TNI] = {
.name = "tni",
.help = "virtual subnet ID",
.next = NEXT(item_nvgre, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_nvgre, tni)),
},
[ITEM_MPLS] = {
.name = "mpls",
.help = "match MPLS header",
.priv = PRIV_ITEM(MPLS, sizeof(struct rte_flow_item_mpls)),
.next = NEXT(item_mpls),
.call = parse_vc,
},
[ITEM_MPLS_LABEL] = {
.name = "label",
.help = "MPLS label",
.next = NEXT(item_mpls, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_mpls,
label_tc_s,
"\xff\xff\xf0")),
},
[ITEM_MPLS_TC] = {
.name = "tc",
.help = "MPLS Traffic Class",
.next = NEXT(item_mpls, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_mpls,
label_tc_s,
"\x00\x00\x0e")),
},
[ITEM_MPLS_S] = {
.name = "s",
.help = "MPLS Bottom-of-Stack",
.next = NEXT(item_mpls, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_mpls,
label_tc_s,
"\x00\x00\x01")),
},
[ITEM_GRE] = {
.name = "gre",
.help = "match GRE header",
.priv = PRIV_ITEM(GRE, sizeof(struct rte_flow_item_gre)),
.next = NEXT(item_gre),
.call = parse_vc,
},
[ITEM_GRE_PROTO] = {
.name = "protocol",
.help = "GRE protocol type",
.next = NEXT(item_gre, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre,
protocol)),
},
[ITEM_GRE_C_RSVD0_VER] = {
.name = "c_rsvd0_ver",
.help =
"checksum (1b), undefined (1b), key bit (1b),"
" sequence number (1b), reserved 0 (9b),"
" version (3b)",
.next = NEXT(item_gre, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre,
c_rsvd0_ver)),
},
[ITEM_GRE_C_BIT] = {
.name = "c_bit",
.help = "checksum bit (C)",
.next = NEXT(item_gre, NEXT_ENTRY(COMMON_BOOLEAN),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_gre,
c_rsvd0_ver,
"\x80\x00\x00\x00")),
},
[ITEM_GRE_S_BIT] = {
.name = "s_bit",
.help = "sequence number bit (S)",
.next = NEXT(item_gre, NEXT_ENTRY(COMMON_BOOLEAN), item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_gre,
c_rsvd0_ver,
"\x10\x00\x00\x00")),
},
[ITEM_GRE_K_BIT] = {
.name = "k_bit",
.help = "key bit (K)",
.next = NEXT(item_gre, NEXT_ENTRY(COMMON_BOOLEAN), item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_gre,
c_rsvd0_ver,
"\x20\x00\x00\x00")),
},
[ITEM_FUZZY] = {
.name = "fuzzy",
.help = "fuzzy pattern match, expect faster than default",
.priv = PRIV_ITEM(FUZZY,
sizeof(struct rte_flow_item_fuzzy)),
.next = NEXT(item_fuzzy),
.call = parse_vc,
},
[ITEM_FUZZY_THRESH] = {
.name = "thresh",
.help = "match accuracy threshold",
.next = NEXT(item_fuzzy, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_fuzzy,
thresh)),
},
[ITEM_GTP] = {
.name = "gtp",
.help = "match GTP header",
.priv = PRIV_ITEM(GTP, sizeof(struct rte_flow_item_gtp)),
.next = NEXT(item_gtp),
.call = parse_vc,
},
[ITEM_GTP_FLAGS] = {
.name = "v_pt_rsv_flags",
.help = "GTP flags",
.next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_gtp,
v_pt_rsv_flags)),
},
[ITEM_GTP_MSG_TYPE] = {
.name = "msg_type",
.help = "GTP message type",
.next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_gtp, msg_type)),
},
[ITEM_GTP_TEID] = {
.name = "teid",
.help = "tunnel endpoint identifier",
.next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp, teid)),
},
[ITEM_GTPC] = {
.name = "gtpc",
.help = "match GTP header",
.priv = PRIV_ITEM(GTPC, sizeof(struct rte_flow_item_gtp)),
.next = NEXT(item_gtp),
.call = parse_vc,
},
[ITEM_GTPU] = {
.name = "gtpu",
.help = "match GTP header",
.priv = PRIV_ITEM(GTPU, sizeof(struct rte_flow_item_gtp)),
.next = NEXT(item_gtp),
.call = parse_vc,
},
[ITEM_GENEVE] = {
.name = "geneve",
.help = "match GENEVE header",
.priv = PRIV_ITEM(GENEVE, sizeof(struct rte_flow_item_geneve)),
.next = NEXT(item_geneve),
.call = parse_vc,
},
[ITEM_GENEVE_VNI] = {
.name = "vni",
.help = "virtual network identifier",
.next = NEXT(item_geneve, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_geneve, vni)),
},
[ITEM_GENEVE_PROTO] = {
.name = "protocol",
.help = "GENEVE protocol type",
.next = NEXT(item_geneve, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_geneve,
protocol)),
},
[ITEM_GENEVE_OPTLEN] = {
.name = "optlen",
.help = "GENEVE options length in dwords",
.next = NEXT(item_geneve, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_geneve,
ver_opt_len_o_c_rsvd0,
"\x3f\x00")),
},
[ITEM_VXLAN_GPE] = {
.name = "vxlan-gpe",
.help = "match VXLAN-GPE header",
.priv = PRIV_ITEM(VXLAN_GPE,
sizeof(struct rte_flow_item_vxlan_gpe)),
.next = NEXT(item_vxlan_gpe),
.call = parse_vc,
},
[ITEM_VXLAN_GPE_VNI] = {
.name = "vni",
.help = "VXLAN-GPE identifier",
.next = NEXT(item_vxlan_gpe, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan_gpe,
vni)),
},
[ITEM_ARP_ETH_IPV4] = {
.name = "arp_eth_ipv4",
.help = "match ARP header for Ethernet/IPv4",
.priv = PRIV_ITEM(ARP_ETH_IPV4,
sizeof(struct rte_flow_item_arp_eth_ipv4)),
.next = NEXT(item_arp_eth_ipv4),
.call = parse_vc,
},
[ITEM_ARP_ETH_IPV4_SHA] = {
.name = "sha",
.help = "sender hardware address",
.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_MAC_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
sha)),
},
[ITEM_ARP_ETH_IPV4_SPA] = {
.name = "spa",
.help = "sender IPv4 address",
.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_IPV4_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
spa)),
},
[ITEM_ARP_ETH_IPV4_THA] = {
.name = "tha",
.help = "target hardware address",
.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_MAC_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
tha)),
},
[ITEM_ARP_ETH_IPV4_TPA] = {
.name = "tpa",
.help = "target IPv4 address",
.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(COMMON_IPV4_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
tpa)),
},
[ITEM_IPV6_EXT] = {
.name = "ipv6_ext",
.help = "match presence of any IPv6 extension header",
.priv = PRIV_ITEM(IPV6_EXT,
sizeof(struct rte_flow_item_ipv6_ext)),
.next = NEXT(item_ipv6_ext),
.call = parse_vc,
},
[ITEM_IPV6_EXT_NEXT_HDR] = {
.name = "next_hdr",
.help = "next header",
.next = NEXT(item_ipv6_ext, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6_ext,
next_hdr)),
},
[ITEM_IPV6_FRAG_EXT] = {
.name = "ipv6_frag_ext",
.help = "match presence of IPv6 fragment extension header",
.priv = PRIV_ITEM(IPV6_FRAG_EXT,
sizeof(struct rte_flow_item_ipv6_frag_ext)),
.next = NEXT(item_ipv6_frag_ext),
.call = parse_vc,
},
[ITEM_IPV6_FRAG_EXT_NEXT_HDR] = {
.name = "next_hdr",
.help = "next header",
.next = NEXT(item_ipv6_frag_ext, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ipv6_frag_ext,
hdr.next_header)),
},
[ITEM_IPV6_FRAG_EXT_FRAG_DATA] = {
.name = "frag_data",
.help = "fragment flags and offset",
.next = NEXT(item_ipv6_frag_ext, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6_frag_ext,
hdr.frag_data)),
},
[ITEM_IPV6_FRAG_EXT_ID] = {
.name = "packet_id",
.help = "fragment packet id",
.next = NEXT(item_ipv6_frag_ext, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6_frag_ext,
hdr.id)),
},
[ITEM_ICMP6] = {
.name = "icmp6",
.help = "match any ICMPv6 header",
.priv = PRIV_ITEM(ICMP6, sizeof(struct rte_flow_item_icmp6)),
.next = NEXT(item_icmp6),
.call = parse_vc,
},
[ITEM_ICMP6_TYPE] = {
.name = "type",
.help = "ICMPv6 type",
.next = NEXT(item_icmp6, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6,
type)),
},
[ITEM_ICMP6_CODE] = {
.name = "code",
.help = "ICMPv6 code",
.next = NEXT(item_icmp6, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6,
code)),
},
[ITEM_ICMP6_ND_NS] = {
.name = "icmp6_nd_ns",
.help = "match ICMPv6 neighbor discovery solicitation",
.priv = PRIV_ITEM(ICMP6_ND_NS,
sizeof(struct rte_flow_item_icmp6_nd_ns)),
.next = NEXT(item_icmp6_nd_ns),
.call = parse_vc,
},
[ITEM_ICMP6_ND_NS_TARGET_ADDR] = {
.name = "target_addr",
.help = "target address",
.next = NEXT(item_icmp6_nd_ns, NEXT_ENTRY(COMMON_IPV6_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6_nd_ns,
target_addr)),
},
[ITEM_ICMP6_ND_NA] = {
.name = "icmp6_nd_na",
.help = "match ICMPv6 neighbor discovery advertisement",
.priv = PRIV_ITEM(ICMP6_ND_NA,
sizeof(struct rte_flow_item_icmp6_nd_na)),
.next = NEXT(item_icmp6_nd_na),
.call = parse_vc,
},
[ITEM_ICMP6_ND_NA_TARGET_ADDR] = {
.name = "target_addr",
.help = "target address",
.next = NEXT(item_icmp6_nd_na, NEXT_ENTRY(COMMON_IPV6_ADDR),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6_nd_na,
target_addr)),
},
[ITEM_ICMP6_ND_OPT] = {
.name = "icmp6_nd_opt",
.help = "match presence of any ICMPv6 neighbor discovery"
" option",
.priv = PRIV_ITEM(ICMP6_ND_OPT,
sizeof(struct rte_flow_item_icmp6_nd_opt)),
.next = NEXT(item_icmp6_nd_opt),
.call = parse_vc,
},
[ITEM_ICMP6_ND_OPT_TYPE] = {
.name = "type",
.help = "ND option type",
.next = NEXT(item_icmp6_nd_opt, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6_nd_opt,
type)),
},
[ITEM_ICMP6_ND_OPT_SLA_ETH] = {
.name = "icmp6_nd_opt_sla_eth",
.help = "match ICMPv6 neighbor discovery source Ethernet"
" link-layer address option",
.priv = PRIV_ITEM
(ICMP6_ND_OPT_SLA_ETH,
sizeof(struct rte_flow_item_icmp6_nd_opt_sla_eth)),
.next = NEXT(item_icmp6_nd_opt_sla_eth),
.call = parse_vc,
},
[ITEM_ICMP6_ND_OPT_SLA_ETH_SLA] = {
.name = "sla",
.help = "source Ethernet LLA",
.next = NEXT(item_icmp6_nd_opt_sla_eth,
NEXT_ENTRY(COMMON_MAC_ADDR), item_param),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_item_icmp6_nd_opt_sla_eth, sla)),
},
[ITEM_ICMP6_ND_OPT_TLA_ETH] = {
.name = "icmp6_nd_opt_tla_eth",
.help = "match ICMPv6 neighbor discovery target Ethernet"
" link-layer address option",
.priv = PRIV_ITEM
(ICMP6_ND_OPT_TLA_ETH,
sizeof(struct rte_flow_item_icmp6_nd_opt_tla_eth)),
.next = NEXT(item_icmp6_nd_opt_tla_eth),
.call = parse_vc,
},
[ITEM_ICMP6_ND_OPT_TLA_ETH_TLA] = {
.name = "tla",
.help = "target Ethernet LLA",
.next = NEXT(item_icmp6_nd_opt_tla_eth,
NEXT_ENTRY(COMMON_MAC_ADDR), item_param),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_item_icmp6_nd_opt_tla_eth, tla)),
},
[ITEM_META] = {
.name = "meta",
.help = "match metadata header",
.priv = PRIV_ITEM(META, sizeof(struct rte_flow_item_meta)),
.next = NEXT(item_meta),
.call = parse_vc,
},
[ITEM_META_DATA] = {
.name = "data",
.help = "metadata value",
.next = NEXT(item_meta, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_MASK(struct rte_flow_item_meta,
data, "\xff\xff\xff\xff")),
},
[ITEM_GRE_KEY] = {
.name = "gre_key",
.help = "match GRE key",
.priv = PRIV_ITEM(GRE_KEY, sizeof(rte_be32_t)),
.next = NEXT(item_gre_key),
.call = parse_vc,
},
[ITEM_GRE_KEY_VALUE] = {
.name = "value",
.help = "key value",
.next = NEXT(item_gre_key, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
},
[ITEM_GRE_OPTION] = {
.name = "gre_option",
.help = "match GRE optional fields",
.priv = PRIV_ITEM(GRE_OPTION,
sizeof(struct rte_flow_item_gre_opt)),
.next = NEXT(item_gre_option),
.call = parse_vc,
},
[ITEM_GRE_OPTION_CHECKSUM] = {
.name = "checksum",
.help = "match GRE checksum",
.next = NEXT(item_gre_option, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre_opt,
checksum_rsvd.checksum)),
},
[ITEM_GRE_OPTION_KEY] = {
.name = "key",
.help = "match GRE key",
.next = NEXT(item_gre_option, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre_opt,
key.key)),
},
[ITEM_GRE_OPTION_SEQUENCE] = {
.name = "sequence",
.help = "match GRE sequence",
.next = NEXT(item_gre_option, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre_opt,
sequence.sequence)),
},
[ITEM_GTP_PSC] = {
.name = "gtp_psc",
.help = "match GTP extension header with type 0x85",
.priv = PRIV_ITEM(GTP_PSC,
sizeof(struct rte_flow_item_gtp_psc)),
.next = NEXT(item_gtp_psc),
.call = parse_vc,
},
[ITEM_GTP_PSC_QFI] = {
.name = "qfi",
.help = "QoS flow identifier",
.next = NEXT(item_gtp_psc, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_gtp_psc,
hdr.qfi, 6)),
},
[ITEM_GTP_PSC_PDU_T] = {
.name = "pdu_t",
.help = "PDU type",
.next = NEXT(item_gtp_psc, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_gtp_psc,
hdr.type, 4)),
},
[ITEM_PPPOES] = {
.name = "pppoes",
.help = "match PPPoE session header",
.priv = PRIV_ITEM(PPPOES, sizeof(struct rte_flow_item_pppoe)),
.next = NEXT(item_pppoes),
.call = parse_vc,
},
[ITEM_PPPOED] = {
.name = "pppoed",
.help = "match PPPoE discovery header",
.priv = PRIV_ITEM(PPPOED, sizeof(struct rte_flow_item_pppoe)),
.next = NEXT(item_pppoed),
.call = parse_vc,
},
[ITEM_PPPOE_SEID] = {
.name = "seid",
.help = "session identifier",
.next = NEXT(item_pppoes, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_pppoe,
session_id)),
},
[ITEM_PPPOE_PROTO_ID] = {
.name = "pppoe_proto_id",
.help = "match PPPoE session protocol identifier",
.priv = PRIV_ITEM(PPPOE_PROTO_ID,
sizeof(struct rte_flow_item_pppoe_proto_id)),
.next = NEXT(item_pppoe_proto_id, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_item_pppoe_proto_id, proto_id)),
.call = parse_vc,
},
[ITEM_HIGIG2] = {
.name = "higig2",
.help = "matches higig2 header",
.priv = PRIV_ITEM(HIGIG2,
sizeof(struct rte_flow_item_higig2_hdr)),
.next = NEXT(item_higig2),
.call = parse_vc,
},
[ITEM_HIGIG2_CLASSIFICATION] = {
.name = "classification",
.help = "matches classification of higig2 header",
.next = NEXT(item_higig2, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_higig2_hdr,
hdr.ppt1.classification)),
},
[ITEM_HIGIG2_VID] = {
.name = "vid",
.help = "matches vid of higig2 header",
.next = NEXT(item_higig2, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_higig2_hdr,
hdr.ppt1.vid)),
},
[ITEM_TAG] = {
.name = "tag",
.help = "match tag value",
.priv = PRIV_ITEM(TAG, sizeof(struct rte_flow_item_tag)),
.next = NEXT(item_tag),
.call = parse_vc,
},
[ITEM_TAG_DATA] = {
.name = "data",
.help = "tag value to match",
.next = NEXT(item_tag, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_tag, data)),
},
[ITEM_TAG_INDEX] = {
.name = "index",
.help = "index of tag array to match",
.next = NEXT(item_tag, NEXT_ENTRY(COMMON_UNSIGNED),
NEXT_ENTRY(ITEM_PARAM_IS)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_tag, index)),
},
[ITEM_L2TPV3OIP] = {
.name = "l2tpv3oip",
.help = "match L2TPv3 over IP header",
.priv = PRIV_ITEM(L2TPV3OIP,
sizeof(struct rte_flow_item_l2tpv3oip)),
.next = NEXT(item_l2tpv3oip),
.call = parse_vc,
},
[ITEM_L2TPV3OIP_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
.next = NEXT(item_l2tpv3oip, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv3oip,
session_id)),
},
[ITEM_ESP] = {
.name = "esp",
.help = "match ESP header",
.priv = PRIV_ITEM(ESP, sizeof(struct rte_flow_item_esp)),
.next = NEXT(item_esp),
.call = parse_vc,
},
[ITEM_ESP_SPI] = {
.name = "spi",
.help = "security policy index",
.next = NEXT(item_esp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_esp,
hdr.spi)),
},
[ITEM_AH] = {
.name = "ah",
.help = "match AH header",
.priv = PRIV_ITEM(AH, sizeof(struct rte_flow_item_ah)),
.next = NEXT(item_ah),
.call = parse_vc,
},
[ITEM_AH_SPI] = {
.name = "spi",
.help = "security parameters index",
.next = NEXT(item_ah, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ah, spi)),
},
[ITEM_PFCP] = {
.name = "pfcp",
.help = "match pfcp header",
.priv = PRIV_ITEM(PFCP, sizeof(struct rte_flow_item_pfcp)),
.next = NEXT(item_pfcp),
.call = parse_vc,
},
[ITEM_PFCP_S_FIELD] = {
.name = "s_field",
.help = "S field",
.next = NEXT(item_pfcp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_pfcp,
s_field)),
},
[ITEM_PFCP_SEID] = {
.name = "seid",
.help = "session endpoint identifier",
.next = NEXT(item_pfcp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_pfcp, seid)),
},
[ITEM_ECPRI] = {
.name = "ecpri",
.help = "match eCPRI header",
.priv = PRIV_ITEM(ECPRI, sizeof(struct rte_flow_item_ecpri)),
.next = NEXT(item_ecpri),
.call = parse_vc,
},
[ITEM_ECPRI_COMMON] = {
.name = "common",
.help = "eCPRI common header",
.next = NEXT(item_ecpri_common),
},
[ITEM_ECPRI_COMMON_TYPE] = {
.name = "type",
.help = "type of common header",
.next = NEXT(item_ecpri_common_type),
.args = ARGS(ARG_ENTRY_HTON(struct rte_flow_item_ecpri)),
},
[ITEM_ECPRI_COMMON_TYPE_IQ_DATA] = {
.name = "iq_data",
.help = "Type #0: IQ Data",
.next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_IQ_DATA_PCID,
ITEM_NEXT)),
.call = parse_vc_item_ecpri_type,
},
[ITEM_ECPRI_MSG_IQ_DATA_PCID] = {
.name = "pc_id",
.help = "Physical Channel ID",
.next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_IQ_DATA_PCID,
ITEM_ECPRI_COMMON, ITEM_NEXT),
NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type0.pc_id)),
},
[ITEM_ECPRI_COMMON_TYPE_RTC_CTRL] = {
.name = "rtc_ctrl",
.help = "Type #2: Real-Time Control Data",
.next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_RTC_CTRL_RTCID,
ITEM_NEXT)),
.call = parse_vc_item_ecpri_type,
},
[ITEM_ECPRI_MSG_RTC_CTRL_RTCID] = {
.name = "rtc_id",
.help = "Real-Time Control Data ID",
.next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_RTC_CTRL_RTCID,
ITEM_ECPRI_COMMON, ITEM_NEXT),
NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type2.rtc_id)),
},
[ITEM_ECPRI_COMMON_TYPE_DLY_MSR] = {
.name = "delay_measure",
.help = "Type #5: One-Way Delay Measurement",
.next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_DLY_MSR_MSRID,
ITEM_NEXT)),
.call = parse_vc_item_ecpri_type,
},
[ITEM_ECPRI_MSG_DLY_MSR_MSRID] = {
.name = "msr_id",
.help = "Measurement ID",
.next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_DLY_MSR_MSRID,
ITEM_ECPRI_COMMON, ITEM_NEXT),
NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type5.msr_id)),
},
[ITEM_GENEVE_OPT] = {
.name = "geneve-opt",
.help = "GENEVE header option",
.priv = PRIV_ITEM(GENEVE_OPT,
sizeof(struct rte_flow_item_geneve_opt) +
ITEM_GENEVE_OPT_DATA_SIZE),
.next = NEXT(item_geneve_opt),
.call = parse_vc,
},
[ITEM_GENEVE_OPT_CLASS] = {
.name = "class",
.help = "GENEVE option class",
.next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_geneve_opt,
option_class)),
},
[ITEM_GENEVE_OPT_TYPE] = {
.name = "type",
.help = "GENEVE option type",
.next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_geneve_opt,
option_type)),
},
[ITEM_GENEVE_OPT_LENGTH] = {
.name = "length",
.help = "GENEVE option data length (in 32b words)",
.next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_BOUNDED(
struct rte_flow_item_geneve_opt, option_len,
0, 31)),
},
[ITEM_GENEVE_OPT_DATA] = {
.name = "data",
.help = "GENEVE option data pattern",
.next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_HEX),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_geneve_opt, data),
ARGS_ENTRY_ARB(0, 0),
ARGS_ENTRY_ARB
(sizeof(struct rte_flow_item_geneve_opt),
ITEM_GENEVE_OPT_DATA_SIZE)),
},
[ITEM_INTEGRITY] = {
.name = "integrity",
.help = "match packet integrity",
.priv = PRIV_ITEM(INTEGRITY,
sizeof(struct rte_flow_item_integrity)),
.next = NEXT(item_integrity),
.call = parse_vc,
},
[ITEM_INTEGRITY_LEVEL] = {
.name = "level",
.help = "integrity level",
.next = NEXT(item_integrity_lv, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_integrity, level)),
},
[ITEM_INTEGRITY_VALUE] = {
.name = "value",
.help = "integrity value",
.next = NEXT(item_integrity_lv, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_integrity, value)),
},
[ITEM_CONNTRACK] = {
.name = "conntrack",
.help = "conntrack state",
.next = NEXT(NEXT_ENTRY(ITEM_NEXT), NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_conntrack, flags)),
},
[ITEM_PORT_REPRESENTOR] = {
.name = "port_representor",
.help = "match traffic entering the embedded switch from the given ethdev",
.priv = PRIV_ITEM(PORT_REPRESENTOR,
sizeof(struct rte_flow_item_ethdev)),
.next = NEXT(item_port_representor),
.call = parse_vc,
},
[ITEM_PORT_REPRESENTOR_PORT_ID] = {
.name = "port_id",
.help = "ethdev port ID",
.next = NEXT(item_port_representor, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)),
},
[ITEM_REPRESENTED_PORT] = {
.name = "represented_port",
.help = "match traffic entering the embedded switch from the entity represented by the given ethdev",
.priv = PRIV_ITEM(REPRESENTED_PORT,
sizeof(struct rte_flow_item_ethdev)),
.next = NEXT(item_represented_port),
.call = parse_vc,
},
[ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID] = {
.name = "ethdev_port_id",
.help = "ethdev port ID",
.next = NEXT(item_represented_port, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)),
},
[ITEM_FLEX] = {
.name = "flex",
.help = "match flex header",
.priv = PRIV_ITEM(FLEX, sizeof(struct rte_flow_item_flex)),
.next = NEXT(item_flex),
.call = parse_vc,
},
[ITEM_FLEX_ITEM_HANDLE] = {
.name = "item",
.help = "flex item handle",
.next = NEXT(item_flex, NEXT_ENTRY(COMMON_FLEX_HANDLE),
NEXT_ENTRY(ITEM_PARAM_IS)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_flex, handle)),
},
[ITEM_FLEX_PATTERN_HANDLE] = {
.name = "pattern",
.help = "flex pattern handle",
.next = NEXT(item_flex, NEXT_ENTRY(COMMON_FLEX_HANDLE),
NEXT_ENTRY(ITEM_PARAM_IS)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_flex, pattern)),
},
[ITEM_L2TPV2] = {
.name = "l2tpv2",
.help = "match L2TPv2 header",
.priv = PRIV_ITEM(L2TPV2, sizeof(struct rte_flow_item_l2tpv2)),
.next = NEXT(item_l2tpv2),
.call = parse_vc,
},
[ITEM_L2TPV2_TYPE] = {
.name = "type",
.help = "type of l2tpv2",
.next = NEXT(item_l2tpv2_type),
.args = ARGS(ARG_ENTRY_HTON(struct rte_flow_item_l2tpv2)),
},
[ITEM_L2TPV2_TYPE_DATA] = {
.name = "data",
.help = "Type #7: data message without any options",
.next = NEXT(item_l2tpv2_type_data),
.call = parse_vc_item_l2tpv2_type,
},
[ITEM_L2TPV2_MSG_DATA_TUNNEL_ID] = {
.name = "tunnel_id",
.help = "tunnel identifier",
.next = NEXT(item_l2tpv2_type_data,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type7.tunnel_id)),
},
[ITEM_L2TPV2_MSG_DATA_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
.next = NEXT(item_l2tpv2_type_data,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type7.session_id)),
},
[ITEM_L2TPV2_TYPE_DATA_L] = {
.name = "data_l",
.help = "Type #6: data message with length option",
.next = NEXT(item_l2tpv2_type_data_l),
.call = parse_vc_item_l2tpv2_type,
},
[ITEM_L2TPV2_MSG_DATA_L_LENGTH] = {
.name = "length",
.help = "message length",
.next = NEXT(item_l2tpv2_type_data_l,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type6.length)),
},
[ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID] = {
.name = "tunnel_id",
.help = "tunnel identifier",
.next = NEXT(item_l2tpv2_type_data_l,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type6.tunnel_id)),
},
[ITEM_L2TPV2_MSG_DATA_L_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
.next = NEXT(item_l2tpv2_type_data_l,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type6.session_id)),
},
[ITEM_L2TPV2_TYPE_DATA_S] = {
.name = "data_s",
.help = "Type #5: data message with ns, nr option",
.next = NEXT(item_l2tpv2_type_data_s),
.call = parse_vc_item_l2tpv2_type,
},
[ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID] = {
.name = "tunnel_id",
.help = "tunnel identifier",
.next = NEXT(item_l2tpv2_type_data_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type5.tunnel_id)),
},
[ITEM_L2TPV2_MSG_DATA_S_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
.next = NEXT(item_l2tpv2_type_data_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type5.session_id)),
},
[ITEM_L2TPV2_MSG_DATA_S_NS] = {
.name = "ns",
.help = "sequence number for message",
.next = NEXT(item_l2tpv2_type_data_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type5.ns)),
},
[ITEM_L2TPV2_MSG_DATA_S_NR] = {
.name = "nr",
.help = "sequence number for next receive message",
.next = NEXT(item_l2tpv2_type_data_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type5.nr)),
},
[ITEM_L2TPV2_TYPE_DATA_O] = {
.name = "data_o",
.help = "Type #4: data message with offset option",
.next = NEXT(item_l2tpv2_type_data_o),
.call = parse_vc_item_l2tpv2_type,
},
[ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID] = {
.name = "tunnel_id",
.help = "tunnel identifier",
.next = NEXT(item_l2tpv2_type_data_o,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type4.tunnel_id)),
},
[ITEM_L2TPV2_MSG_DATA_O_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
.next = NEXT(item_l2tpv2_type_data_o,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type5.session_id)),
},
[ITEM_L2TPV2_MSG_DATA_O_OFFSET] = {
.name = "offset_size",
.help = "the size of offset padding",
.next = NEXT(item_l2tpv2_type_data_o,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type4.offset_size)),
},
[ITEM_L2TPV2_TYPE_DATA_L_S] = {
.name = "data_l_s",
.help = "Type #3: data message contains length, ns, nr "
"options",
.next = NEXT(item_l2tpv2_type_data_l_s),
.call = parse_vc_item_l2tpv2_type,
},
[ITEM_L2TPV2_MSG_DATA_L_S_LENGTH] = {
.name = "length",
.help = "message length",
.next = NEXT(item_l2tpv2_type_data_l_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.length)),
},
[ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID] = {
.name = "tunnel_id",
.help = "tunnel identifier",
.next = NEXT(item_l2tpv2_type_data_l_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.tunnel_id)),
},
[ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
.next = NEXT(item_l2tpv2_type_data_l_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.session_id)),
},
[ITEM_L2TPV2_MSG_DATA_L_S_NS] = {
.name = "ns",
.help = "sequence number for message",
.next = NEXT(item_l2tpv2_type_data_l_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.ns)),
},
[ITEM_L2TPV2_MSG_DATA_L_S_NR] = {
.name = "nr",
.help = "sequence number for next receive message",
.next = NEXT(item_l2tpv2_type_data_l_s,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.nr)),
},
[ITEM_L2TPV2_TYPE_CTRL] = {
.name = "control",
.help = "Type #3: conrtol message contains length, ns, nr "
"options",
.next = NEXT(item_l2tpv2_type_ctrl),
.call = parse_vc_item_l2tpv2_type,
},
[ITEM_L2TPV2_MSG_CTRL_LENGTH] = {
.name = "length",
.help = "message length",
.next = NEXT(item_l2tpv2_type_ctrl,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.length)),
},
[ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID] = {
.name = "tunnel_id",
.help = "tunnel identifier",
.next = NEXT(item_l2tpv2_type_ctrl,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.tunnel_id)),
},
[ITEM_L2TPV2_MSG_CTRL_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
.next = NEXT(item_l2tpv2_type_ctrl,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.session_id)),
},
[ITEM_L2TPV2_MSG_CTRL_NS] = {
.name = "ns",
.help = "sequence number for message",
.next = NEXT(item_l2tpv2_type_ctrl,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.ns)),
},
[ITEM_L2TPV2_MSG_CTRL_NR] = {
.name = "nr",
.help = "sequence number for next receive message",
.next = NEXT(item_l2tpv2_type_ctrl,
NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2,
hdr.type3.nr)),
},
[ITEM_PPP] = {
.name = "ppp",
.help = "match PPP header",
.priv = PRIV_ITEM(PPP, sizeof(struct rte_flow_item_ppp)),
.next = NEXT(item_ppp),
.call = parse_vc,
},
[ITEM_PPP_ADDR] = {
.name = "addr",
.help = "PPP address",
.next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, hdr.addr)),
},
[ITEM_PPP_CTRL] = {
.name = "ctrl",
.help = "PPP control",
.next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, hdr.ctrl)),
},
[ITEM_PPP_PROTO_ID] = {
.name = "proto_id",
.help = "PPP protocol identifier",
.next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED),
item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp,
hdr.proto_id)),
},
/* Validate/create actions. */
[ACTIONS] = {
.name = "actions",
.help = "submit a list of associated actions",
.next = NEXT(next_action),
.call = parse_vc,
},
[ACTION_NEXT] = {
.name = "/",
.help = "specify next action",
.next = NEXT(next_action),
},
[ACTION_END] = {
.name = "end",
.help = "end list of actions",
.priv = PRIV_ACTION(END, 0),
.call = parse_vc,
},
[ACTION_VOID] = {
.name = "void",
.help = "no-op action",
.priv = PRIV_ACTION(VOID, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_PASSTHRU] = {
.name = "passthru",
.help = "let subsequent rule process matched packets",
.priv = PRIV_ACTION(PASSTHRU, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_JUMP] = {
.name = "jump",
.help = "redirect traffic to a given group",
.priv = PRIV_ACTION(JUMP, sizeof(struct rte_flow_action_jump)),
.next = NEXT(action_jump),
.call = parse_vc,
},
[ACTION_JUMP_GROUP] = {
.name = "group",
.help = "group to redirect traffic to",
.next = NEXT(action_jump, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_jump, group)),
.call = parse_vc_conf,
},
[ACTION_MARK] = {
.name = "mark",
.help = "attach 32 bit value to packets",
.priv = PRIV_ACTION(MARK, sizeof(struct rte_flow_action_mark)),
.next = NEXT(action_mark),
.call = parse_vc,
},
[ACTION_MARK_ID] = {
.name = "id",
.help = "32 bit value to return with packets",
.next = NEXT(action_mark, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_mark, id)),
.call = parse_vc_conf,
},
[ACTION_FLAG] = {
.name = "flag",
.help = "flag packets",
.priv = PRIV_ACTION(FLAG, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_QUEUE] = {
.name = "queue",
.help = "assign packets to a given queue index",
.priv = PRIV_ACTION(QUEUE,
sizeof(struct rte_flow_action_queue)),
.next = NEXT(action_queue),
.call = parse_vc,
},
[ACTION_QUEUE_INDEX] = {
.name = "index",
.help = "queue index to use",
.next = NEXT(action_queue, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_queue, index)),
.call = parse_vc_conf,
},
[ACTION_DROP] = {
.name = "drop",
.help = "drop packets (note: passthru has priority)",
.priv = PRIV_ACTION(DROP, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_COUNT] = {
.name = "count",
.help = "enable counters for this rule",
.priv = PRIV_ACTION(COUNT,
sizeof(struct rte_flow_action_count)),
.next = NEXT(action_count),
.call = parse_vc,
},
[ACTION_COUNT_ID] = {
.name = "identifier",
.help = "counter identifier to use",
.next = NEXT(action_count, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_count, id)),
.call = parse_vc_conf,
},
[ACTION_RSS] = {
.name = "rss",
.help = "spread packets among several queues",
.priv = PRIV_ACTION(RSS, sizeof(struct action_rss_data)),
.next = NEXT(action_rss),
.call = parse_vc_action_rss,
},
[ACTION_RSS_FUNC] = {
.name = "func",
.help = "RSS hash function to apply",
.next = NEXT(action_rss,
NEXT_ENTRY(ACTION_RSS_FUNC_DEFAULT,
ACTION_RSS_FUNC_TOEPLITZ,
ACTION_RSS_FUNC_SIMPLE_XOR,
ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ)),
},
[ACTION_RSS_FUNC_DEFAULT] = {
.name = "default",
.help = "default hash function",
.call = parse_vc_action_rss_func,
},
[ACTION_RSS_FUNC_TOEPLITZ] = {
.name = "toeplitz",
.help = "Toeplitz hash function",
.call = parse_vc_action_rss_func,
},
[ACTION_RSS_FUNC_SIMPLE_XOR] = {
.name = "simple_xor",
.help = "simple XOR hash function",
.call = parse_vc_action_rss_func,
},
[ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ] = {
.name = "symmetric_toeplitz",
.help = "Symmetric Toeplitz hash function",
.call = parse_vc_action_rss_func,
},
[ACTION_RSS_LEVEL] = {
.name = "level",
.help = "encapsulation level for \"types\"",
.next = NEXT(action_rss, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_ARB
(offsetof(struct action_rss_data, conf) +
offsetof(struct rte_flow_action_rss, level),
sizeof(((struct rte_flow_action_rss *)0)->
level))),
},
[ACTION_RSS_TYPES] = {
.name = "types",
.help = "specific RSS hash types",
.next = NEXT(action_rss, NEXT_ENTRY(ACTION_RSS_TYPE)),
},
[ACTION_RSS_TYPE] = {
.name = "{type}",
.help = "RSS hash type",
.call = parse_vc_action_rss_type,
.comp = comp_vc_action_rss_type,
},
[ACTION_RSS_KEY] = {
.name = "key",
.help = "RSS hash key",
.next = NEXT(action_rss, NEXT_ENTRY(COMMON_HEX)),
.args = ARGS(ARGS_ENTRY_ARB
(offsetof(struct action_rss_data, conf) +
offsetof(struct rte_flow_action_rss, key),
sizeof(((struct rte_flow_action_rss *)0)->key)),
ARGS_ENTRY_ARB
(offsetof(struct action_rss_data, conf) +
offsetof(struct rte_flow_action_rss, key_len),
sizeof(((struct rte_flow_action_rss *)0)->
key_len)),
ARGS_ENTRY(struct action_rss_data, key)),
},
[ACTION_RSS_KEY_LEN] = {
.name = "key_len",
.help = "RSS hash key length in bytes",
.next = NEXT(action_rss, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_ARB_BOUNDED
(offsetof(struct action_rss_data, conf) +
offsetof(struct rte_flow_action_rss, key_len),
sizeof(((struct rte_flow_action_rss *)0)->
key_len),
0,
RSS_HASH_KEY_LENGTH)),
},
[ACTION_RSS_QUEUES] = {
.name = "queues",
.help = "queue indices to use",
.next = NEXT(action_rss, NEXT_ENTRY(ACTION_RSS_QUEUE)),
.call = parse_vc_conf,
},
[ACTION_RSS_QUEUE] = {
.name = "{queue}",
.help = "queue index",
.call = parse_vc_action_rss_queue,
.comp = comp_vc_action_rss_queue,
},
[ACTION_PF] = {
.name = "pf",
.help = "direct traffic to physical function",
.priv = PRIV_ACTION(PF, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_VF] = {
.name = "vf",
.help = "direct traffic to a virtual function ID",
.priv = PRIV_ACTION(VF, sizeof(struct rte_flow_action_vf)),
.next = NEXT(action_vf),
.call = parse_vc,
},
[ACTION_VF_ORIGINAL] = {
.name = "original",
.help = "use original VF ID if possible",
.next = NEXT(action_vf, NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_vf,
original, 1)),
.call = parse_vc_conf,
},
[ACTION_VF_ID] = {
.name = "id",
.help = "VF ID",
.next = NEXT(action_vf, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_vf, id)),
.call = parse_vc_conf,
},
[ACTION_PHY_PORT] = {
.name = "phy_port",
.help = "direct packets to physical port index",
.priv = PRIV_ACTION(PHY_PORT,
sizeof(struct rte_flow_action_phy_port)),
.next = NEXT(action_phy_port),
.call = parse_vc,
},
[ACTION_PHY_PORT_ORIGINAL] = {
.name = "original",
.help = "use original port index if possible",
.next = NEXT(action_phy_port, NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_phy_port,
original, 1)),
.call = parse_vc_conf,
},
[ACTION_PHY_PORT_INDEX] = {
.name = "index",
.help = "physical port index",
.next = NEXT(action_phy_port, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_phy_port,
index)),
.call = parse_vc_conf,
},
[ACTION_PORT_ID] = {
.name = "port_id",
.help = "direct matching traffic to a given DPDK port ID",
.priv = PRIV_ACTION(PORT_ID,
sizeof(struct rte_flow_action_port_id)),
.next = NEXT(action_port_id),
.call = parse_vc,
},
[ACTION_PORT_ID_ORIGINAL] = {
.name = "original",
.help = "use original DPDK port ID if possible",
.next = NEXT(action_port_id, NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_port_id,
original, 1)),
.call = parse_vc_conf,
},
[ACTION_PORT_ID_ID] = {
.name = "id",
.help = "DPDK port ID",
.next = NEXT(action_port_id, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_port_id, id)),
.call = parse_vc_conf,
},
[ACTION_METER] = {
.name = "meter",
.help = "meter the directed packets at given id",
.priv = PRIV_ACTION(METER,
sizeof(struct rte_flow_action_meter)),
.next = NEXT(action_meter),
.call = parse_vc,
},
[ACTION_METER_COLOR] = {
.name = "color",
.help = "meter color for the packets",
.priv = PRIV_ACTION(METER_COLOR,
sizeof(struct rte_flow_action_meter_color)),
.next = NEXT(action_meter_color),
.call = parse_vc,
},
[ACTION_METER_COLOR_TYPE] = {
.name = "type",
.help = "specific meter color",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT),
NEXT_ENTRY(ACTION_METER_COLOR_GREEN,
ACTION_METER_COLOR_YELLOW,
ACTION_METER_COLOR_RED)),
},
[ACTION_METER_COLOR_GREEN] = {
.name = "green",
.help = "meter color green",
.call = parse_vc_action_meter_color_type,
},
[ACTION_METER_COLOR_YELLOW] = {
.name = "yellow",
.help = "meter color yellow",
.call = parse_vc_action_meter_color_type,
},
[ACTION_METER_COLOR_RED] = {
.name = "red",
.help = "meter color red",
.call = parse_vc_action_meter_color_type,
},
[ACTION_METER_ID] = {
.name = "mtr_id",
.help = "meter id to use",
.next = NEXT(action_meter, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_meter, mtr_id)),
.call = parse_vc_conf,
},
[ACTION_OF_SET_MPLS_TTL] = {
.name = "of_set_mpls_ttl",
.help = "OpenFlow's OFPAT_SET_MPLS_TTL",
.priv = PRIV_ACTION
(OF_SET_MPLS_TTL,
sizeof(struct rte_flow_action_of_set_mpls_ttl)),
.next = NEXT(action_of_set_mpls_ttl),
.call = parse_vc,
},
[ACTION_OF_SET_MPLS_TTL_MPLS_TTL] = {
.name = "mpls_ttl",
.help = "MPLS TTL",
.next = NEXT(action_of_set_mpls_ttl,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_of_set_mpls_ttl,
mpls_ttl)),
.call = parse_vc_conf,
},
[ACTION_OF_DEC_MPLS_TTL] = {
.name = "of_dec_mpls_ttl",
.help = "OpenFlow's OFPAT_DEC_MPLS_TTL",
.priv = PRIV_ACTION(OF_DEC_MPLS_TTL, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_OF_SET_NW_TTL] = {
.name = "of_set_nw_ttl",
.help = "OpenFlow's OFPAT_SET_NW_TTL",
.priv = PRIV_ACTION
(OF_SET_NW_TTL,
sizeof(struct rte_flow_action_of_set_nw_ttl)),
.next = NEXT(action_of_set_nw_ttl),
.call = parse_vc,
},
[ACTION_OF_SET_NW_TTL_NW_TTL] = {
.name = "nw_ttl",
.help = "IP TTL",
.next = NEXT(action_of_set_nw_ttl, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_of_set_nw_ttl,
nw_ttl)),
.call = parse_vc_conf,
},
[ACTION_OF_DEC_NW_TTL] = {
.name = "of_dec_nw_ttl",
.help = "OpenFlow's OFPAT_DEC_NW_TTL",
.priv = PRIV_ACTION(OF_DEC_NW_TTL, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_OF_COPY_TTL_OUT] = {
.name = "of_copy_ttl_out",
.help = "OpenFlow's OFPAT_COPY_TTL_OUT",
.priv = PRIV_ACTION(OF_COPY_TTL_OUT, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_OF_COPY_TTL_IN] = {
.name = "of_copy_ttl_in",
.help = "OpenFlow's OFPAT_COPY_TTL_IN",
.priv = PRIV_ACTION(OF_COPY_TTL_IN, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_OF_POP_VLAN] = {
.name = "of_pop_vlan",
.help = "OpenFlow's OFPAT_POP_VLAN",
.priv = PRIV_ACTION(OF_POP_VLAN, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_OF_PUSH_VLAN] = {
.name = "of_push_vlan",
.help = "OpenFlow's OFPAT_PUSH_VLAN",
.priv = PRIV_ACTION
(OF_PUSH_VLAN,
sizeof(struct rte_flow_action_of_push_vlan)),
.next = NEXT(action_of_push_vlan),
.call = parse_vc,
},
[ACTION_OF_PUSH_VLAN_ETHERTYPE] = {
.name = "ethertype",
.help = "EtherType",
.next = NEXT(action_of_push_vlan, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_push_vlan,
ethertype)),
.call = parse_vc_conf,
},
[ACTION_OF_SET_VLAN_VID] = {
.name = "of_set_vlan_vid",
.help = "OpenFlow's OFPAT_SET_VLAN_VID",
.priv = PRIV_ACTION
(OF_SET_VLAN_VID,
sizeof(struct rte_flow_action_of_set_vlan_vid)),
.next = NEXT(action_of_set_vlan_vid),
.call = parse_vc,
},
[ACTION_OF_SET_VLAN_VID_VLAN_VID] = {
.name = "vlan_vid",
.help = "VLAN id",
.next = NEXT(action_of_set_vlan_vid,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_set_vlan_vid,
vlan_vid)),
.call = parse_vc_conf,
},
[ACTION_OF_SET_VLAN_PCP] = {
.name = "of_set_vlan_pcp",
.help = "OpenFlow's OFPAT_SET_VLAN_PCP",
.priv = PRIV_ACTION
(OF_SET_VLAN_PCP,
sizeof(struct rte_flow_action_of_set_vlan_pcp)),
.next = NEXT(action_of_set_vlan_pcp),
.call = parse_vc,
},
[ACTION_OF_SET_VLAN_PCP_VLAN_PCP] = {
.name = "vlan_pcp",
.help = "VLAN priority",
.next = NEXT(action_of_set_vlan_pcp,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_set_vlan_pcp,
vlan_pcp)),
.call = parse_vc_conf,
},
[ACTION_OF_POP_MPLS] = {
.name = "of_pop_mpls",
.help = "OpenFlow's OFPAT_POP_MPLS",
.priv = PRIV_ACTION(OF_POP_MPLS,
sizeof(struct rte_flow_action_of_pop_mpls)),
.next = NEXT(action_of_pop_mpls),
.call = parse_vc,
},
[ACTION_OF_POP_MPLS_ETHERTYPE] = {
.name = "ethertype",
.help = "EtherType",
.next = NEXT(action_of_pop_mpls, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_pop_mpls,
ethertype)),
.call = parse_vc_conf,
},
[ACTION_OF_PUSH_MPLS] = {
.name = "of_push_mpls",
.help = "OpenFlow's OFPAT_PUSH_MPLS",
.priv = PRIV_ACTION
(OF_PUSH_MPLS,
sizeof(struct rte_flow_action_of_push_mpls)),
.next = NEXT(action_of_push_mpls),
.call = parse_vc,
},
[ACTION_OF_PUSH_MPLS_ETHERTYPE] = {
.name = "ethertype",
.help = "EtherType",
.next = NEXT(action_of_push_mpls, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_push_mpls,
ethertype)),
.call = parse_vc_conf,
},
[ACTION_VXLAN_ENCAP] = {
.name = "vxlan_encap",
.help = "VXLAN encapsulation, uses configuration set by \"set"
" vxlan\"",
.priv = PRIV_ACTION(VXLAN_ENCAP,
sizeof(struct action_vxlan_encap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_vxlan_encap,
},
[ACTION_VXLAN_DECAP] = {
.name = "vxlan_decap",
.help = "Performs a decapsulation action by stripping all"
" headers of the VXLAN tunnel network overlay from the"
" matched flow.",
.priv = PRIV_ACTION(VXLAN_DECAP, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_NVGRE_ENCAP] = {
.name = "nvgre_encap",
.help = "NVGRE encapsulation, uses configuration set by \"set"
" nvgre\"",
.priv = PRIV_ACTION(NVGRE_ENCAP,
sizeof(struct action_nvgre_encap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_nvgre_encap,
},
[ACTION_NVGRE_DECAP] = {
.name = "nvgre_decap",
.help = "Performs a decapsulation action by stripping all"
" headers of the NVGRE tunnel network overlay from the"
" matched flow.",
.priv = PRIV_ACTION(NVGRE_DECAP, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_L2_ENCAP] = {
.name = "l2_encap",
.help = "l2 encap, uses configuration set by"
" \"set l2_encap\"",
.priv = PRIV_ACTION(RAW_ENCAP,
sizeof(struct action_raw_encap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_l2_encap,
},
[ACTION_L2_DECAP] = {
.name = "l2_decap",
.help = "l2 decap, uses configuration set by"
" \"set l2_decap\"",
.priv = PRIV_ACTION(RAW_DECAP,
sizeof(struct action_raw_decap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_l2_decap,
},
[ACTION_MPLSOGRE_ENCAP] = {
.name = "mplsogre_encap",
.help = "mplsogre encapsulation, uses configuration set by"
" \"set mplsogre_encap\"",
.priv = PRIV_ACTION(RAW_ENCAP,
sizeof(struct action_raw_encap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_mplsogre_encap,
},
[ACTION_MPLSOGRE_DECAP] = {
.name = "mplsogre_decap",
.help = "mplsogre decapsulation, uses configuration set by"
" \"set mplsogre_decap\"",
.priv = PRIV_ACTION(RAW_DECAP,
sizeof(struct action_raw_decap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_mplsogre_decap,
},
[ACTION_MPLSOUDP_ENCAP] = {
.name = "mplsoudp_encap",
.help = "mplsoudp encapsulation, uses configuration set by"
" \"set mplsoudp_encap\"",
.priv = PRIV_ACTION(RAW_ENCAP,
sizeof(struct action_raw_encap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_mplsoudp_encap,
},
[ACTION_MPLSOUDP_DECAP] = {
.name = "mplsoudp_decap",
.help = "mplsoudp decapsulation, uses configuration set by"
" \"set mplsoudp_decap\"",
.priv = PRIV_ACTION(RAW_DECAP,
sizeof(struct action_raw_decap_data)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_mplsoudp_decap,
},
[ACTION_SET_IPV4_SRC] = {
.name = "set_ipv4_src",
.help = "Set a new IPv4 source address in the outermost"
" IPv4 header",
.priv = PRIV_ACTION(SET_IPV4_SRC,
sizeof(struct rte_flow_action_set_ipv4)),
.next = NEXT(action_set_ipv4_src),
.call = parse_vc,
},
[ACTION_SET_IPV4_SRC_IPV4_SRC] = {
.name = "ipv4_addr",
.help = "new IPv4 source address to set",
.next = NEXT(action_set_ipv4_src, NEXT_ENTRY(COMMON_IPV4_ADDR)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_ipv4, ipv4_addr)),
.call = parse_vc_conf,
},
[ACTION_SET_IPV4_DST] = {
.name = "set_ipv4_dst",
.help = "Set a new IPv4 destination address in the outermost"
" IPv4 header",
.priv = PRIV_ACTION(SET_IPV4_DST,
sizeof(struct rte_flow_action_set_ipv4)),
.next = NEXT(action_set_ipv4_dst),
.call = parse_vc,
},
[ACTION_SET_IPV4_DST_IPV4_DST] = {
.name = "ipv4_addr",
.help = "new IPv4 destination address to set",
.next = NEXT(action_set_ipv4_dst, NEXT_ENTRY(COMMON_IPV4_ADDR)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_ipv4, ipv4_addr)),
.call = parse_vc_conf,
},
[ACTION_SET_IPV6_SRC] = {
.name = "set_ipv6_src",
.help = "Set a new IPv6 source address in the outermost"
" IPv6 header",
.priv = PRIV_ACTION(SET_IPV6_SRC,
sizeof(struct rte_flow_action_set_ipv6)),
.next = NEXT(action_set_ipv6_src),
.call = parse_vc,
},
[ACTION_SET_IPV6_SRC_IPV6_SRC] = {
.name = "ipv6_addr",
.help = "new IPv6 source address to set",
.next = NEXT(action_set_ipv6_src, NEXT_ENTRY(COMMON_IPV6_ADDR)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_ipv6, ipv6_addr)),
.call = parse_vc_conf,
},
[ACTION_SET_IPV6_DST] = {
.name = "set_ipv6_dst",
.help = "Set a new IPv6 destination address in the outermost"
" IPv6 header",
.priv = PRIV_ACTION(SET_IPV6_DST,
sizeof(struct rte_flow_action_set_ipv6)),
.next = NEXT(action_set_ipv6_dst),
.call = parse_vc,
},
[ACTION_SET_IPV6_DST_IPV6_DST] = {
.name = "ipv6_addr",
.help = "new IPv6 destination address to set",
.next = NEXT(action_set_ipv6_dst, NEXT_ENTRY(COMMON_IPV6_ADDR)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_ipv6, ipv6_addr)),
.call = parse_vc_conf,
},
[ACTION_SET_TP_SRC] = {
.name = "set_tp_src",
.help = "set a new source port number in the outermost"
" TCP/UDP header",
.priv = PRIV_ACTION(SET_TP_SRC,
sizeof(struct rte_flow_action_set_tp)),
.next = NEXT(action_set_tp_src),
.call = parse_vc,
},
[ACTION_SET_TP_SRC_TP_SRC] = {
.name = "port",
.help = "new source port number to set",
.next = NEXT(action_set_tp_src, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_tp, port)),
.call = parse_vc_conf,
},
[ACTION_SET_TP_DST] = {
.name = "set_tp_dst",
.help = "set a new destination port number in the outermost"
" TCP/UDP header",
.priv = PRIV_ACTION(SET_TP_DST,
sizeof(struct rte_flow_action_set_tp)),
.next = NEXT(action_set_tp_dst),
.call = parse_vc,
},
[ACTION_SET_TP_DST_TP_DST] = {
.name = "port",
.help = "new destination port number to set",
.next = NEXT(action_set_tp_dst, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_tp, port)),
.call = parse_vc_conf,
},
[ACTION_MAC_SWAP] = {
.name = "mac_swap",
.help = "Swap the source and destination MAC addresses"
" in the outermost Ethernet header",
.priv = PRIV_ACTION(MAC_SWAP, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_DEC_TTL] = {
.name = "dec_ttl",
.help = "decrease network TTL if available",
.priv = PRIV_ACTION(DEC_TTL, 0),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc,
},
[ACTION_SET_TTL] = {
.name = "set_ttl",
.help = "set ttl value",
.priv = PRIV_ACTION(SET_TTL,
sizeof(struct rte_flow_action_set_ttl)),
.next = NEXT(action_set_ttl),
.call = parse_vc,
},
[ACTION_SET_TTL_TTL] = {
.name = "ttl_value",
.help = "new ttl value to set",
.next = NEXT(action_set_ttl, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_ttl, ttl_value)),
.call = parse_vc_conf,
},
[ACTION_SET_MAC_SRC] = {
.name = "set_mac_src",
.help = "set source mac address",
.priv = PRIV_ACTION(SET_MAC_SRC,
sizeof(struct rte_flow_action_set_mac)),
.next = NEXT(action_set_mac_src),
.call = parse_vc,
},
[ACTION_SET_MAC_SRC_MAC_SRC] = {
.name = "mac_addr",
.help = "new source mac address",
.next = NEXT(action_set_mac_src, NEXT_ENTRY(COMMON_MAC_ADDR)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_mac, mac_addr)),
.call = parse_vc_conf,
},
[ACTION_SET_MAC_DST] = {
.name = "set_mac_dst",
.help = "set destination mac address",
.priv = PRIV_ACTION(SET_MAC_DST,
sizeof(struct rte_flow_action_set_mac)),
.next = NEXT(action_set_mac_dst),
.call = parse_vc,
},
[ACTION_SET_MAC_DST_MAC_DST] = {
.name = "mac_addr",
.help = "new destination mac address to set",
.next = NEXT(action_set_mac_dst, NEXT_ENTRY(COMMON_MAC_ADDR)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_set_mac, mac_addr)),
.call = parse_vc_conf,
},
[ACTION_INC_TCP_SEQ] = {
.name = "inc_tcp_seq",
.help = "increase TCP sequence number",
.priv = PRIV_ACTION(INC_TCP_SEQ, sizeof(rte_be32_t)),
.next = NEXT(action_inc_tcp_seq),
.call = parse_vc,
},
[ACTION_INC_TCP_SEQ_VALUE] = {
.name = "value",
.help = "the value to increase TCP sequence number by",
.next = NEXT(action_inc_tcp_seq, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
.call = parse_vc_conf,
},
[ACTION_DEC_TCP_SEQ] = {
.name = "dec_tcp_seq",
.help = "decrease TCP sequence number",
.priv = PRIV_ACTION(DEC_TCP_SEQ, sizeof(rte_be32_t)),
.next = NEXT(action_dec_tcp_seq),
.call = parse_vc,
},
[ACTION_DEC_TCP_SEQ_VALUE] = {
.name = "value",
.help = "the value to decrease TCP sequence number by",
.next = NEXT(action_dec_tcp_seq, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
.call = parse_vc_conf,
},
[ACTION_INC_TCP_ACK] = {
.name = "inc_tcp_ack",
.help = "increase TCP acknowledgment number",
.priv = PRIV_ACTION(INC_TCP_ACK, sizeof(rte_be32_t)),
.next = NEXT(action_inc_tcp_ack),
.call = parse_vc,
},
[ACTION_INC_TCP_ACK_VALUE] = {
.name = "value",
.help = "the value to increase TCP acknowledgment number by",
.next = NEXT(action_inc_tcp_ack, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
.call = parse_vc_conf,
},
[ACTION_DEC_TCP_ACK] = {
.name = "dec_tcp_ack",
.help = "decrease TCP acknowledgment number",
.priv = PRIV_ACTION(DEC_TCP_ACK, sizeof(rte_be32_t)),
.next = NEXT(action_dec_tcp_ack),
.call = parse_vc,
},
[ACTION_DEC_TCP_ACK_VALUE] = {
.name = "value",
.help = "the value to decrease TCP acknowledgment number by",
.next = NEXT(action_dec_tcp_ack, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
.call = parse_vc_conf,
},
[ACTION_RAW_ENCAP] = {
.name = "raw_encap",
.help = "encapsulation data, defined by set raw_encap",
.priv = PRIV_ACTION(RAW_ENCAP,
sizeof(struct action_raw_encap_data)),
.next = NEXT(action_raw_encap),
.call = parse_vc_action_raw_encap,
},
[ACTION_RAW_ENCAP_INDEX] = {
.name = "index",
.help = "the index of raw_encap_confs",
.next = NEXT(NEXT_ENTRY(ACTION_RAW_ENCAP_INDEX_VALUE)),
},
[ACTION_RAW_ENCAP_INDEX_VALUE] = {
.name = "{index}",
.type = "UNSIGNED",
.help = "unsigned integer value",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_raw_encap_index,
.comp = comp_set_raw_index,
},
[ACTION_RAW_DECAP] = {
.name = "raw_decap",
.help = "decapsulation data, defined by set raw_encap",
.priv = PRIV_ACTION(RAW_DECAP,
sizeof(struct action_raw_decap_data)),
.next = NEXT(action_raw_decap),
.call = parse_vc_action_raw_decap,
},
[ACTION_RAW_DECAP_INDEX] = {
.name = "index",
.help = "the index of raw_encap_confs",
.next = NEXT(NEXT_ENTRY(ACTION_RAW_DECAP_INDEX_VALUE)),
},
[ACTION_RAW_DECAP_INDEX_VALUE] = {
.name = "{index}",
.type = "UNSIGNED",
.help = "unsigned integer value",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_raw_decap_index,
.comp = comp_set_raw_index,
},
[ACTION_MODIFY_FIELD] = {
.name = "modify_field",
.help = "modify destination field with data from source field",
.priv = PRIV_ACTION(MODIFY_FIELD, ACTION_MODIFY_SIZE),
.next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_OP)),
.call = parse_vc,
},
[ACTION_MODIFY_FIELD_OP] = {
.name = "op",
.help = "operation type",
.next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_DST_TYPE),
NEXT_ENTRY(ACTION_MODIFY_FIELD_OP_VALUE)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_OP_VALUE] = {
.name = "{operation}",
.help = "operation type value",
.call = parse_vc_modify_field_op,
.comp = comp_set_modify_field_op,
},
[ACTION_MODIFY_FIELD_DST_TYPE] = {
.name = "dst_type",
.help = "destination field type",
.next = NEXT(action_modify_field_dst,
NEXT_ENTRY(ACTION_MODIFY_FIELD_DST_TYPE_VALUE)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_DST_TYPE_VALUE] = {
.name = "{dst_type}",
.help = "destination field type value",
.call = parse_vc_modify_field_id,
.comp = comp_set_modify_field_id,
},
[ACTION_MODIFY_FIELD_DST_LEVEL] = {
.name = "dst_level",
.help = "destination field level",
.next = NEXT(action_modify_field_dst,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field,
dst.level)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_DST_OFFSET] = {
.name = "dst_offset",
.help = "destination field bit offset",
.next = NEXT(action_modify_field_dst,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field,
dst.offset)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_SRC_TYPE] = {
.name = "src_type",
.help = "source field type",
.next = NEXT(action_modify_field_src,
NEXT_ENTRY(ACTION_MODIFY_FIELD_SRC_TYPE_VALUE)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_SRC_TYPE_VALUE] = {
.name = "{src_type}",
.help = "source field type value",
.call = parse_vc_modify_field_id,
.comp = comp_set_modify_field_id,
},
[ACTION_MODIFY_FIELD_SRC_LEVEL] = {
.name = "src_level",
.help = "source field level",
.next = NEXT(action_modify_field_src,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field,
src.level)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_SRC_OFFSET] = {
.name = "src_offset",
.help = "source field bit offset",
.next = NEXT(action_modify_field_src,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field,
src.offset)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_SRC_VALUE] = {
.name = "src_value",
.help = "source immediate value",
.next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_WIDTH),
NEXT_ENTRY(COMMON_HEX)),
.args = ARGS(ARGS_ENTRY_ARB(0, 0),
ARGS_ENTRY_ARB(0, 0),
ARGS_ENTRY(struct rte_flow_action_modify_field,
src.value)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_SRC_POINTER] = {
.name = "src_ptr",
.help = "pointer to source immediate value",
.next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_WIDTH),
NEXT_ENTRY(COMMON_HEX)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field,
src.pvalue),
ARGS_ENTRY_ARB(0, 0),
ARGS_ENTRY_ARB
(sizeof(struct rte_flow_action_modify_field),
ACTION_MODIFY_PATTERN_SIZE)),
.call = parse_vc_conf,
},
[ACTION_MODIFY_FIELD_WIDTH] = {
.name = "width",
.help = "number of bits to copy",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT),
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field,
width)),
.call = parse_vc_conf,
},
/* Top level command. */
[SET] = {
.name = "set",
.help = "set raw encap/decap/sample data",
.type = "set raw_encap|raw_decap <index> <pattern>"
" or set sample_actions <index> <action>",
.next = NEXT(NEXT_ENTRY
(SET_RAW_ENCAP,
SET_RAW_DECAP,
SET_SAMPLE_ACTIONS)),
.call = parse_set_init,
},
/* Sub-level commands. */
[SET_RAW_ENCAP] = {
.name = "raw_encap",
.help = "set raw encap data",
.next = NEXT(next_set_raw),
.args = ARGS(ARGS_ENTRY_ARB_BOUNDED
(offsetof(struct buffer, port),
sizeof(((struct buffer *)0)->port),
0, RAW_ENCAP_CONFS_MAX_NUM - 1)),
.call = parse_set_raw_encap_decap,
},
[SET_RAW_DECAP] = {
.name = "raw_decap",
.help = "set raw decap data",
.next = NEXT(next_set_raw),
.args = ARGS(ARGS_ENTRY_ARB_BOUNDED
(offsetof(struct buffer, port),
sizeof(((struct buffer *)0)->port),
0, RAW_ENCAP_CONFS_MAX_NUM - 1)),
.call = parse_set_raw_encap_decap,
},
[SET_RAW_INDEX] = {
.name = "{index}",
.type = "COMMON_UNSIGNED",
.help = "index of raw_encap/raw_decap data",
.next = NEXT(next_item),
.call = parse_port,
},
[SET_SAMPLE_INDEX] = {
.name = "{index}",
.type = "UNSIGNED",
.help = "index of sample actions",
.next = NEXT(next_action_sample),
.call = parse_port,
},
[SET_SAMPLE_ACTIONS] = {
.name = "sample_actions",
.help = "set sample actions list",
.next = NEXT(NEXT_ENTRY(SET_SAMPLE_INDEX)),
.args = ARGS(ARGS_ENTRY_ARB_BOUNDED
(offsetof(struct buffer, port),
sizeof(((struct buffer *)0)->port),
0, RAW_SAMPLE_CONFS_MAX_NUM - 1)),
.call = parse_set_sample_action,
},
[ACTION_SET_TAG] = {
.name = "set_tag",
.help = "set tag",
.priv = PRIV_ACTION(SET_TAG,
sizeof(struct rte_flow_action_set_tag)),
.next = NEXT(action_set_tag),
.call = parse_vc,
},
[ACTION_SET_TAG_INDEX] = {
.name = "index",
.help = "index of tag array",
.next = NEXT(action_set_tag, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_set_tag, index)),
.call = parse_vc_conf,
},
[ACTION_SET_TAG_DATA] = {
.name = "data",
.help = "tag value",
.next = NEXT(action_set_tag, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY
(struct rte_flow_action_set_tag, data)),
.call = parse_vc_conf,
},
[ACTION_SET_TAG_MASK] = {
.name = "mask",
.help = "mask for tag value",
.next = NEXT(action_set_tag, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY
(struct rte_flow_action_set_tag, mask)),
.call = parse_vc_conf,
},
[ACTION_SET_META] = {
.name = "set_meta",
.help = "set metadata",
.priv = PRIV_ACTION(SET_META,
sizeof(struct rte_flow_action_set_meta)),
.next = NEXT(action_set_meta),
.call = parse_vc_action_set_meta,
},
[ACTION_SET_META_DATA] = {
.name = "data",
.help = "metadata value",
.next = NEXT(action_set_meta, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY
(struct rte_flow_action_set_meta, data)),
.call = parse_vc_conf,
},
[ACTION_SET_META_MASK] = {
.name = "mask",
.help = "mask for metadata value",
.next = NEXT(action_set_meta, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY
(struct rte_flow_action_set_meta, mask)),
.call = parse_vc_conf,
},
[ACTION_SET_IPV4_DSCP] = {
.name = "set_ipv4_dscp",
.help = "set DSCP value",
.priv = PRIV_ACTION(SET_IPV4_DSCP,
sizeof(struct rte_flow_action_set_dscp)),
.next = NEXT(action_set_ipv4_dscp),
.call = parse_vc,
},
[ACTION_SET_IPV4_DSCP_VALUE] = {
.name = "dscp_value",
.help = "new IPv4 DSCP value to set",
.next = NEXT(action_set_ipv4_dscp, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY
(struct rte_flow_action_set_dscp, dscp)),
.call = parse_vc_conf,
},
[ACTION_SET_IPV6_DSCP] = {
.name = "set_ipv6_dscp",
.help = "set DSCP value",
.priv = PRIV_ACTION(SET_IPV6_DSCP,
sizeof(struct rte_flow_action_set_dscp)),
.next = NEXT(action_set_ipv6_dscp),
.call = parse_vc,
},
[ACTION_SET_IPV6_DSCP_VALUE] = {
.name = "dscp_value",
.help = "new IPv6 DSCP value to set",
.next = NEXT(action_set_ipv6_dscp, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY
(struct rte_flow_action_set_dscp, dscp)),
.call = parse_vc_conf,
},
[ACTION_AGE] = {
.name = "age",
.help = "set a specific metadata header",
.next = NEXT(action_age),
.priv = PRIV_ACTION(AGE,
sizeof(struct rte_flow_action_age)),
.call = parse_vc,
},
[ACTION_AGE_TIMEOUT] = {
.name = "timeout",
.help = "flow age timeout value",
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_age,
timeout, 24)),
.next = NEXT(action_age, NEXT_ENTRY(COMMON_UNSIGNED)),
.call = parse_vc_conf,
},
[ACTION_SAMPLE] = {
.name = "sample",
.help = "set a sample action",
.next = NEXT(action_sample),
.priv = PRIV_ACTION(SAMPLE,
sizeof(struct action_sample_data)),
.call = parse_vc_action_sample,
},
[ACTION_SAMPLE_RATIO] = {
.name = "ratio",
.help = "flow sample ratio value",
.next = NEXT(action_sample, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_ARB
(offsetof(struct action_sample_data, conf) +
offsetof(struct rte_flow_action_sample, ratio),
sizeof(((struct rte_flow_action_sample *)0)->
ratio))),
},
[ACTION_SAMPLE_INDEX] = {
.name = "index",
.help = "the index of sample actions list",
.next = NEXT(NEXT_ENTRY(ACTION_SAMPLE_INDEX_VALUE)),
},
[ACTION_SAMPLE_INDEX_VALUE] = {
.name = "{index}",
.type = "COMMON_UNSIGNED",
.help = "unsigned integer value",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_sample_index,
.comp = comp_set_sample_index,
},
[ACTION_CONNTRACK] = {
.name = "conntrack",
.help = "create a conntrack object",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.priv = PRIV_ACTION(CONNTRACK,
sizeof(struct rte_flow_action_conntrack)),
.call = parse_vc,
},
[ACTION_CONNTRACK_UPDATE] = {
.name = "conntrack_update",
.help = "update a conntrack object",
.next = NEXT(action_update_conntrack),
.priv = PRIV_ACTION(CONNTRACK,
sizeof(struct rte_flow_modify_conntrack)),
.call = parse_vc,
},
[ACTION_CONNTRACK_UPDATE_DIR] = {
.name = "dir",
.help = "update a conntrack object direction",
.next = NEXT(action_update_conntrack),
.call = parse_vc_action_conntrack_update,
},
[ACTION_CONNTRACK_UPDATE_CTX] = {
.name = "ctx",
.help = "update a conntrack object context",
.next = NEXT(action_update_conntrack),
.call = parse_vc_action_conntrack_update,
},
[ACTION_PORT_REPRESENTOR] = {
.name = "port_representor",
.help = "at embedded switch level, send matching traffic to the given ethdev",
.priv = PRIV_ACTION(PORT_REPRESENTOR,
sizeof(struct rte_flow_action_ethdev)),
.next = NEXT(action_port_representor),
.call = parse_vc,
},
[ACTION_PORT_REPRESENTOR_PORT_ID] = {
.name = "port_id",
.help = "ethdev port ID",
.next = NEXT(action_port_representor,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev,
port_id)),
.call = parse_vc_conf,
},
[ACTION_REPRESENTED_PORT] = {
.name = "represented_port",
.help = "at embedded switch level, send matching traffic to the entity represented by the given ethdev",
.priv = PRIV_ACTION(REPRESENTED_PORT,
sizeof(struct rte_flow_action_ethdev)),
.next = NEXT(action_represented_port),
.call = parse_vc,
},
[ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID] = {
.name = "ethdev_port_id",
.help = "ethdev port ID",
.next = NEXT(action_represented_port,
NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev,
port_id)),
.call = parse_vc_conf,
},
/* Indirect action destroy arguments. */
[INDIRECT_ACTION_DESTROY_ID] = {
.name = "action_id",
.help = "specify a indirect action id to destroy",
.next = NEXT(next_ia_destroy_attr,
NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer,
args.ia_destroy.action_id)),
.call = parse_ia_destroy,
},
/* Indirect action create arguments. */
[INDIRECT_ACTION_CREATE_ID] = {
.name = "action_id",
.help = "specify a indirect action id to create",
.next = NEXT(next_ia_create_attr,
NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)),
},
[ACTION_INDIRECT] = {
.name = "indirect",
.help = "apply indirect action by id",
.priv = PRIV_ACTION(INDIRECT, 0),
.next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_ID2PTR)),
.args = ARGS(ARGS_ENTRY_ARB(0, sizeof(uint32_t))),
.call = parse_vc,
},
[INDIRECT_ACTION_ID2PTR] = {
.name = "{action_id}",
.type = "INDIRECT_ACTION_ID",
.help = "indirect action id",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_ia_id2ptr,
.comp = comp_none,
},
[INDIRECT_ACTION_INGRESS] = {
.name = "ingress",
.help = "affect rule to ingress",
.next = NEXT(next_ia_create_attr),
.call = parse_ia,
},
[INDIRECT_ACTION_EGRESS] = {
.name = "egress",
.help = "affect rule to egress",
.next = NEXT(next_ia_create_attr),
.call = parse_ia,
},
[INDIRECT_ACTION_TRANSFER] = {
.name = "transfer",
.help = "affect rule to transfer",
.next = NEXT(next_ia_create_attr),
.call = parse_ia,
},
[INDIRECT_ACTION_SPEC] = {
.name = "action",
.help = "specify action to create indirect handle",
.next = NEXT(next_action),
},
[ACTION_POL_G] = {
.name = "g_actions",
.help = "submit a list of associated actions for green",
.next = NEXT(next_action),
.call = parse_mp,
},
[ACTION_POL_Y] = {
.name = "y_actions",
.help = "submit a list of associated actions for yellow",
.next = NEXT(next_action),
},
[ACTION_POL_R] = {
.name = "r_actions",
.help = "submit a list of associated actions for red",
.next = NEXT(next_action),
},
/* Top-level command. */
[ADD] = {
.name = "add",
.type = "port meter policy {port_id} {arg}",
.help = "add port meter policy",
.next = NEXT(NEXT_ENTRY(ITEM_POL_PORT)),
.call = parse_init,
},
/* Sub-level commands. */
[ITEM_POL_PORT] = {
.name = "port",
.help = "add port meter policy",
.next = NEXT(NEXT_ENTRY(ITEM_POL_METER)),
},
[ITEM_POL_METER] = {
.name = "meter",
.help = "add port meter policy",
.next = NEXT(NEXT_ENTRY(ITEM_POL_POLICY)),
},
[ITEM_POL_POLICY] = {
.name = "policy",
.help = "add port meter policy",
.next = NEXT(NEXT_ENTRY(ACTION_POL_R),
NEXT_ENTRY(ACTION_POL_Y),
NEXT_ENTRY(ACTION_POL_G),
NEXT_ENTRY(COMMON_POLICY_ID),
NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.policy.policy_id),
ARGS_ENTRY(struct buffer, port)),
.call = parse_mp,
},
};
/** Remove and return last entry from argument stack. */
static const struct arg *
pop_args(struct context *ctx)
{
return ctx->args_num ? ctx->args[--ctx->args_num] : NULL;
}
/** Add entry on top of the argument stack. */
static int
push_args(struct context *ctx, const struct arg *arg)
{
if (ctx->args_num == CTX_STACK_SIZE)
return -1;
ctx->args[ctx->args_num++] = arg;
return 0;
}
/** Spread value into buffer according to bit-mask. */
static size_t
arg_entry_bf_fill(void *dst, uintmax_t val, const struct arg *arg)
{
uint32_t i = arg->size;
uint32_t end = 0;
int sub = 1;
int add = 0;
size_t len = 0;
if (!arg->mask)
return 0;
#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
if (!arg->hton) {
i = 0;
end = arg->size;
sub = 0;
add = 1;
}
#endif
while (i != end) {
unsigned int shift = 0;
uint8_t *buf = (uint8_t *)dst + arg->offset + (i -= sub);
for (shift = 0; arg->mask[i] >> shift; ++shift) {
if (!(arg->mask[i] & (1 << shift)))
continue;
++len;
if (!dst)
continue;
*buf &= ~(1 << shift);
*buf |= (val & 1) << shift;
val >>= 1;
}
i += add;
}
return len;
}
/** Compare a string with a partial one of a given length. */
static int
strcmp_partial(const char *full, const char *partial, size_t partial_len)
{
int r = strncmp(full, partial, partial_len);
if (r)
return r;
if (strlen(full) <= partial_len)
return 0;
return full[partial_len];
}
/**
* Parse a prefix length and generate a bit-mask.
*
* Last argument (ctx->args) is retrieved to determine mask size, storage
* location and whether the result must use network byte ordering.
*/
static int
parse_prefix(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg = pop_args(ctx);
static const uint8_t conv[] = "\x00\x80\xc0\xe0\xf0\xf8\xfc\xfe\xff";
char *end;
uintmax_t u;
unsigned int bytes;
unsigned int extra;
(void)token;
/* Argument is expected. */
if (!arg)
return -1;
errno = 0;
u = strtoumax(str, &end, 0);
if (errno || (size_t)(end - str) != len)
goto error;
if (arg->mask) {
uintmax_t v = 0;
extra = arg_entry_bf_fill(NULL, 0, arg);
if (u > extra)
goto error;
if (!ctx->object)
return len;
extra -= u;
while (u--)
(v <<= 1, v |= 1);
v <<= extra;
if (!arg_entry_bf_fill(ctx->object, v, arg) ||
!arg_entry_bf_fill(ctx->objmask, -1, arg))
goto error;
return len;
}
bytes = u / 8;
extra = u % 8;
size = arg->size;
if (bytes > size || bytes + !!extra > size)
goto error;
if (!ctx->object)
return len;
buf = (uint8_t *)ctx->object + arg->offset;
#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
if (!arg->hton) {
memset((uint8_t *)buf + size - bytes, 0xff, bytes);
memset(buf, 0x00, size - bytes);
if (extra)
((uint8_t *)buf)[size - bytes - 1] = conv[extra];
} else
#endif
{
memset(buf, 0xff, bytes);
memset((uint8_t *)buf + bytes, 0x00, size - bytes);
if (extra)
((uint8_t *)buf)[bytes] = conv[extra];
}
if (ctx->objmask)
memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
return len;
error:
push_args(ctx, arg);
return -1;
}
/** Default parsing function for token name matching. */
static int
parse_default(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
(void)ctx;
(void)buf;
(void)size;
if (strcmp_partial(token->name, str, len))
return -1;
return len;
}
/** Parse flow command, initialize output buffer for subsequent tokens. */
static int
parse_init(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
/* Make sure buffer is large enough. */
if (size < sizeof(*out))
return -1;
/* Initialize buffer. */
memset(out, 0x00, sizeof(*out));
memset((uint8_t *)out + sizeof(*out), 0x22, size - sizeof(*out));
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
}
/** Parse tokens for indirect action commands. */
static int
parse_ia(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != INDIRECT_ACTION)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.vc.data = (uint8_t *)out + size;
return len;
}
switch (ctx->curr) {
case INDIRECT_ACTION_CREATE:
case INDIRECT_ACTION_UPDATE:
out->args.vc.actions =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
out->args.vc.attr.group = UINT32_MAX;
/* fallthrough */
case INDIRECT_ACTION_QUERY:
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
case INDIRECT_ACTION_EGRESS:
out->args.vc.attr.egress = 1;
return len;
case INDIRECT_ACTION_INGRESS:
out->args.vc.attr.ingress = 1;
return len;
case INDIRECT_ACTION_TRANSFER:
out->args.vc.attr.transfer = 1;
return len;
default:
return -1;
}
}
/** Parse tokens for indirect action destroy command. */
static int
parse_ia_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
uint32_t *action_id;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command || out->command == INDIRECT_ACTION) {
if (ctx->curr != INDIRECT_ACTION_DESTROY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.ia_destroy.action_id =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
action_id = out->args.ia_destroy.action_id
+ out->args.ia_destroy.action_id_n++;
if ((uint8_t *)action_id > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = action_id;
ctx->objmask = NULL;
return len;
}
/** Parse tokens for indirect action commands. */
static int
parse_qia(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != QUEUE)
return -1;
if (sizeof(*out) > size)
return -1;
out->args.vc.data = (uint8_t *)out + size;
return len;
}
switch (ctx->curr) {
case QUEUE_INDIRECT_ACTION:
return len;
case QUEUE_INDIRECT_ACTION_CREATE:
case QUEUE_INDIRECT_ACTION_UPDATE:
out->args.vc.actions =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
out->args.vc.attr.group = UINT32_MAX;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
case QUEUE_INDIRECT_ACTION_EGRESS:
out->args.vc.attr.egress = 1;
return len;
case QUEUE_INDIRECT_ACTION_INGRESS:
out->args.vc.attr.ingress = 1;
return len;
case QUEUE_INDIRECT_ACTION_TRANSFER:
out->args.vc.attr.transfer = 1;
return len;
case QUEUE_INDIRECT_ACTION_CREATE_POSTPONE:
return len;
default:
return -1;
}
}
/** Parse tokens for indirect action destroy command. */
static int
parse_qia_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
uint32_t *action_id;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command || out->command == QUEUE) {
if (ctx->curr != QUEUE_INDIRECT_ACTION_DESTROY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.ia_destroy.action_id =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
switch (ctx->curr) {
case QUEUE_INDIRECT_ACTION:
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
case QUEUE_INDIRECT_ACTION_DESTROY_ID:
action_id = out->args.ia_destroy.action_id
+ out->args.ia_destroy.action_id_n++;
if ((uint8_t *)action_id > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = action_id;
ctx->objmask = NULL;
return len;
case QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE:
return len;
default:
return -1;
}
}
/** Parse tokens for meter policy action commands. */
static int
parse_mp(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != ITEM_POL_POLICY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.vc.data = (uint8_t *)out + size;
return len;
}
switch (ctx->curr) {
case ACTION_POL_G:
out->args.vc.actions =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
default:
return -1;
}
}
/** Parse tokens for validate/create commands. */
static int
parse_vc(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
uint8_t *data;
uint32_t data_size;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != VALIDATE && ctx->curr != CREATE &&
ctx->curr != PATTERN_TEMPLATE_CREATE &&
ctx->curr != ACTIONS_TEMPLATE_CREATE)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.vc.data = (uint8_t *)out + size;
return len;
}
ctx->objdata = 0;
switch (ctx->curr) {
default:
ctx->object = &out->args.vc.attr;
break;
case VC_TUNNEL_SET:
case VC_TUNNEL_MATCH:
ctx->object = &out->args.vc.tunnel_ops;
break;
}
ctx->objmask = NULL;
switch (ctx->curr) {
case VC_GROUP:
case VC_PRIORITY:
return len;
case VC_TUNNEL_SET:
out->args.vc.tunnel_ops.enabled = 1;
out->args.vc.tunnel_ops.actions = 1;
return len;
case VC_TUNNEL_MATCH:
out->args.vc.tunnel_ops.enabled = 1;
out->args.vc.tunnel_ops.items = 1;
return len;
case VC_INGRESS:
out->args.vc.attr.ingress = 1;
return len;
case VC_EGRESS:
out->args.vc.attr.egress = 1;
return len;
case VC_TRANSFER:
out->args.vc.attr.transfer = 1;
return len;
case ITEM_PATTERN:
out->args.vc.pattern =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
ctx->object = out->args.vc.pattern;
ctx->objmask = NULL;
return len;
case ITEM_END:
if ((out->command == VALIDATE || out->command == CREATE) &&
ctx->last)
return -1;
if (out->command == PATTERN_TEMPLATE_CREATE &&
!ctx->last)
return -1;
break;
case ACTIONS:
out->args.vc.actions =
(void *)RTE_ALIGN_CEIL((uintptr_t)
(out->args.vc.pattern +
out->args.vc.pattern_n),
sizeof(double));
ctx->object = out->args.vc.actions;
ctx->objmask = NULL;
return len;
default:
if (!token->priv)
return -1;
break;
}
if (!out->args.vc.actions) {
const struct parse_item_priv *priv = token->priv;
struct rte_flow_item *item =
out->args.vc.pattern + out->args.vc.pattern_n;
data_size = priv->size * 3; /* spec, last, mask */
data = (void *)RTE_ALIGN_FLOOR((uintptr_t)
(out->args.vc.data - data_size),
sizeof(double));
if ((uint8_t *)item + sizeof(*item) > data)
return -1;
*item = (struct rte_flow_item){
.type = priv->type,
};
++out->args.vc.pattern_n;
ctx->object = item;
ctx->objmask = NULL;
} else {
const struct parse_action_priv *priv = token->priv;
struct rte_flow_action *action =
out->args.vc.actions + out->args.vc.actions_n;
data_size = priv->size; /* configuration */
data = (void *)RTE_ALIGN_FLOOR((uintptr_t)
(out->args.vc.data - data_size),
sizeof(double));
if ((uint8_t *)action + sizeof(*action) > data)
return -1;
*action = (struct rte_flow_action){
.type = priv->type,
.conf = data_size ? data : NULL,
};
++out->args.vc.actions_n;
ctx->object = action;
ctx->objmask = NULL;
}
memset(data, 0, data_size);
out->args.vc.data = data;
ctx->objdata = data_size;
return len;
}
/** Parse pattern item parameter type. */
static int
parse_vc_spec(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_item *item;
uint32_t data_size;
int index;
int objmask = 0;
(void)size;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Parse parameter types. */
switch (ctx->curr) {
static const enum index prefix[] = NEXT_ENTRY(COMMON_PREFIX);
case ITEM_PARAM_IS:
index = 0;
objmask = 1;
break;
case ITEM_PARAM_SPEC:
index = 0;
break;
case ITEM_PARAM_LAST:
index = 1;
break;
case ITEM_PARAM_PREFIX:
/* Modify next token to expect a prefix. */
if (ctx->next_num < 2)
return -1;
ctx->next[ctx->next_num - 2] = prefix;
/* Fall through. */
case ITEM_PARAM_MASK:
index = 2;
break;
default:
return -1;
}
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->args.vc.pattern_n)
return -1;
item = &out->args.vc.pattern[out->args.vc.pattern_n - 1];
data_size = ctx->objdata / 3; /* spec, last, mask */
/* Point to selected object. */
ctx->object = out->args.vc.data + (data_size * index);
if (objmask) {
ctx->objmask = out->args.vc.data + (data_size * 2); /* mask */
item->mask = ctx->objmask;
} else
ctx->objmask = NULL;
/* Update relevant item pointer. */
*((const void **[]){ &item->spec, &item->last, &item->mask })[index] =
ctx->object;
return len;
}
/** Parse action configuration field. */
static int
parse_vc_conf(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
(void)size;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
return len;
}
/** Parse eCPRI common header type field. */
static int
parse_vc_item_ecpri_type(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct rte_flow_item_ecpri *ecpri;
struct rte_flow_item_ecpri *ecpri_mask;
struct rte_flow_item *item;
uint32_t data_size;
uint8_t msg_type;
struct buffer *out = buf;
const struct arg *arg;
(void)size;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
switch (ctx->curr) {
case ITEM_ECPRI_COMMON_TYPE_IQ_DATA:
msg_type = RTE_ECPRI_MSG_TYPE_IQ_DATA;
break;
case ITEM_ECPRI_COMMON_TYPE_RTC_CTRL:
msg_type = RTE_ECPRI_MSG_TYPE_RTC_CTRL;
break;
case ITEM_ECPRI_COMMON_TYPE_DLY_MSR:
msg_type = RTE_ECPRI_MSG_TYPE_DLY_MSR;
break;
default:
return -1;
}
if (!ctx->object)
return len;
arg = pop_args(ctx);
if (!arg)
return -1;
ecpri = (struct rte_flow_item_ecpri *)out->args.vc.data;
ecpri->hdr.common.type = msg_type;
data_size = ctx->objdata / 3; /* spec, last, mask */
ecpri_mask = (struct rte_flow_item_ecpri *)(out->args.vc.data +
(data_size * 2));
ecpri_mask->hdr.common.type = 0xFF;
if (arg->hton) {
ecpri->hdr.common.u32 = rte_cpu_to_be_32(ecpri->hdr.common.u32);
ecpri_mask->hdr.common.u32 =
rte_cpu_to_be_32(ecpri_mask->hdr.common.u32);
}
item = &out->args.vc.pattern[out->args.vc.pattern_n - 1];
item->spec = ecpri;
item->mask = ecpri_mask;
return len;
}
/** Parse L2TPv2 common header type field. */
static int
parse_vc_item_l2tpv2_type(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct rte_flow_item_l2tpv2 *l2tpv2;
struct rte_flow_item_l2tpv2 *l2tpv2_mask;
struct rte_flow_item *item;
uint32_t data_size;
uint16_t msg_type = 0;
struct buffer *out = buf;
const struct arg *arg;
(void)size;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
switch (ctx->curr) {
case ITEM_L2TPV2_TYPE_DATA:
msg_type |= RTE_L2TPV2_MSG_TYPE_DATA;
break;
case ITEM_L2TPV2_TYPE_DATA_L:
msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_L;
break;
case ITEM_L2TPV2_TYPE_DATA_S:
msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_S;
break;
case ITEM_L2TPV2_TYPE_DATA_O:
msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_O;
break;
case ITEM_L2TPV2_TYPE_DATA_L_S:
msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_L_S;
break;
case ITEM_L2TPV2_TYPE_CTRL:
msg_type |= RTE_L2TPV2_MSG_TYPE_CONTROL;
break;
default:
return -1;
}
if (!ctx->object)
return len;
arg = pop_args(ctx);
if (!arg)
return -1;
l2tpv2 = (struct rte_flow_item_l2tpv2 *)out->args.vc.data;
l2tpv2->hdr.common.flags_version |= msg_type;
data_size = ctx->objdata / 3; /* spec, last, mask */
l2tpv2_mask = (struct rte_flow_item_l2tpv2 *)(out->args.vc.data +
(data_size * 2));
l2tpv2_mask->hdr.common.flags_version = 0xFFFF;
if (arg->hton) {
l2tpv2->hdr.common.flags_version =
rte_cpu_to_be_16(l2tpv2->hdr.common.flags_version);
l2tpv2_mask->hdr.common.flags_version =
rte_cpu_to_be_16(l2tpv2_mask->hdr.common.flags_version);
}
item = &out->args.vc.pattern[out->args.vc.pattern_n - 1];
item->spec = l2tpv2;
item->mask = l2tpv2_mask;
return len;
}
/** Parse meter color action type. */
static int
parse_vc_action_meter_color_type(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct rte_flow_action *action_data;
struct rte_flow_action_meter_color *conf;
enum rte_color color;
(void)buf;
(void)size;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
switch (ctx->curr) {
case ACTION_METER_COLOR_GREEN:
color = RTE_COLOR_GREEN;
break;
case ACTION_METER_COLOR_YELLOW:
color = RTE_COLOR_YELLOW;
break;
case ACTION_METER_COLOR_RED:
color = RTE_COLOR_RED;
break;
default:
return -1;
}
if (!ctx->object)
return len;
action_data = ctx->object;
conf = (struct rte_flow_action_meter_color *)
(uintptr_t)(action_data->conf);
conf->color = color;
return len;
}
/** Parse RSS action. */
static int
parse_vc_action_rss(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_rss_data *action_rss_data;
unsigned int i;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Set up default configuration. */
action_rss_data = ctx->object;
*action_rss_data = (struct action_rss_data){
.conf = (struct rte_flow_action_rss){
.func = RTE_ETH_HASH_FUNCTION_DEFAULT,
.level = 0,
.types = rss_hf,
.key_len = 0,
.queue_num = RTE_MIN(nb_rxq, ACTION_RSS_QUEUE_NUM),
.key = NULL,
.queue = action_rss_data->queue,
},
.queue = { 0 },
};
for (i = 0; i < action_rss_data->conf.queue_num; ++i)
action_rss_data->queue[i] = i;
action->conf = &action_rss_data->conf;
return ret;
}
/**
* Parse func field for RSS action.
*
* The RTE_ETH_HASH_FUNCTION_* value to assign is derived from the
* ACTION_RSS_FUNC_* index that called this function.
*/
static int
parse_vc_action_rss_func(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct action_rss_data *action_rss_data;
enum rte_eth_hash_function func;
(void)buf;
(void)size;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
switch (ctx->curr) {
case ACTION_RSS_FUNC_DEFAULT:
func = RTE_ETH_HASH_FUNCTION_DEFAULT;
break;
case ACTION_RSS_FUNC_TOEPLITZ:
func = RTE_ETH_HASH_FUNCTION_TOEPLITZ;
break;
case ACTION_RSS_FUNC_SIMPLE_XOR:
func = RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
break;
case ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ:
func = RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
break;
default:
return -1;
}
if (!ctx->object)
return len;
action_rss_data = ctx->object;
action_rss_data->conf.func = func;
return len;
}
/**
* Parse type field for RSS action.
*
* Valid tokens are type field names and the "end" token.
*/
static int
parse_vc_action_rss_type(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
static const enum index next[] = NEXT_ENTRY(ACTION_RSS_TYPE);
struct action_rss_data *action_rss_data;
unsigned int i;
(void)token;
(void)buf;
(void)size;
if (ctx->curr != ACTION_RSS_TYPE)
return -1;
if (!(ctx->objdata >> 16) && ctx->object) {
action_rss_data = ctx->object;
action_rss_data->conf.types = 0;
}
if (!strcmp_partial("end", str, len)) {
ctx->objdata &= 0xffff;
return len;
}
for (i = 0; rss_type_table[i].str; ++i)
if (!strcmp_partial(rss_type_table[i].str, str, len))
break;
if (!rss_type_table[i].str)
return -1;
ctx->objdata = 1 << 16 | (ctx->objdata & 0xffff);
/* Repeat token. */
if (ctx->next_num == RTE_DIM(ctx->next))
return -1;
ctx->next[ctx->next_num++] = next;
if (!ctx->object)
return len;
action_rss_data = ctx->object;
action_rss_data->conf.types |= rss_type_table[i].rss_type;
return len;
}
/**
* Parse queue field for RSS action.
*
* Valid tokens are queue indices and the "end" token.
*/
static int
parse_vc_action_rss_queue(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
static const enum index next[] = NEXT_ENTRY(ACTION_RSS_QUEUE);
struct action_rss_data *action_rss_data;
const struct arg *arg;
int ret;
int i;
(void)token;
(void)buf;
(void)size;
if (ctx->curr != ACTION_RSS_QUEUE)
return -1;
i = ctx->objdata >> 16;
if (!strcmp_partial("end", str, len)) {
ctx->objdata &= 0xffff;
goto end;
}
if (i >= ACTION_RSS_QUEUE_NUM)
return -1;
arg = ARGS_ENTRY_ARB(offsetof(struct action_rss_data, queue) +
i * sizeof(action_rss_data->queue[i]),
sizeof(action_rss_data->queue[i]));
if (push_args(ctx, arg))
return -1;
ret = parse_int(ctx, token, str, len, NULL, 0);
if (ret < 0) {
pop_args(ctx);
return -1;
}
++i;
ctx->objdata = i << 16 | (ctx->objdata & 0xffff);
/* Repeat token. */
if (ctx->next_num == RTE_DIM(ctx->next))
return -1;
ctx->next[ctx->next_num++] = next;
end:
if (!ctx->object)
return len;
action_rss_data = ctx->object;
action_rss_data->conf.queue_num = i;
action_rss_data->conf.queue = i ? action_rss_data->queue : NULL;
return len;
}
/** Setup VXLAN encap configuration. */
static int
parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_data)
{
/* Set up default configuration. */
*action_vxlan_encap_data = (struct action_vxlan_encap_data){
.conf = (struct rte_flow_action_vxlan_encap){
.definition = action_vxlan_encap_data->items,
},
.items = {
{
.type = RTE_FLOW_ITEM_TYPE_ETH,
.spec = &action_vxlan_encap_data->item_eth,
.mask = &rte_flow_item_eth_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_VLAN,
.spec = &action_vxlan_encap_data->item_vlan,
.mask = &rte_flow_item_vlan_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_IPV4,
.spec = &action_vxlan_encap_data->item_ipv4,
.mask = &rte_flow_item_ipv4_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_UDP,
.spec = &action_vxlan_encap_data->item_udp,
.mask = &rte_flow_item_udp_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_VXLAN,
.spec = &action_vxlan_encap_data->item_vxlan,
.mask = &rte_flow_item_vxlan_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_END,
},
},
.item_eth.type = 0,
.item_vlan = {
.tci = vxlan_encap_conf.vlan_tci,
.inner_type = 0,
},
.item_ipv4.hdr = {
.src_addr = vxlan_encap_conf.ipv4_src,
.dst_addr = vxlan_encap_conf.ipv4_dst,
},
.item_udp.hdr = {
.src_port = vxlan_encap_conf.udp_src,
.dst_port = vxlan_encap_conf.udp_dst,
},
.item_vxlan.flags = 0,
};
memcpy(action_vxlan_encap_data->item_eth.dst.addr_bytes,
vxlan_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN);
memcpy(action_vxlan_encap_data->item_eth.src.addr_bytes,
vxlan_encap_conf.eth_src, RTE_ETHER_ADDR_LEN);
if (!vxlan_encap_conf.select_ipv4) {
memcpy(&action_vxlan_encap_data->item_ipv6.hdr.src_addr,
&vxlan_encap_conf.ipv6_src,
sizeof(vxlan_encap_conf.ipv6_src));
memcpy(&action_vxlan_encap_data->item_ipv6.hdr.dst_addr,
&vxlan_encap_conf.ipv6_dst,
sizeof(vxlan_encap_conf.ipv6_dst));
action_vxlan_encap_data->items[2] = (struct rte_flow_item){
.type = RTE_FLOW_ITEM_TYPE_IPV6,
.spec = &action_vxlan_encap_data->item_ipv6,
.mask = &rte_flow_item_ipv6_mask,
};
}
if (!vxlan_encap_conf.select_vlan)
action_vxlan_encap_data->items[1].type =
RTE_FLOW_ITEM_TYPE_VOID;
if (vxlan_encap_conf.select_tos_ttl) {
if (vxlan_encap_conf.select_ipv4) {
static struct rte_flow_item_ipv4 ipv4_mask_tos;
memcpy(&ipv4_mask_tos, &rte_flow_item_ipv4_mask,
sizeof(ipv4_mask_tos));
ipv4_mask_tos.hdr.type_of_service = 0xff;
ipv4_mask_tos.hdr.time_to_live = 0xff;
action_vxlan_encap_data->item_ipv4.hdr.type_of_service =
vxlan_encap_conf.ip_tos;
action_vxlan_encap_data->item_ipv4.hdr.time_to_live =
vxlan_encap_conf.ip_ttl;
action_vxlan_encap_data->items[2].mask =
&ipv4_mask_tos;
} else {
static struct rte_flow_item_ipv6 ipv6_mask_tos;
memcpy(&ipv6_mask_tos, &rte_flow_item_ipv6_mask,
sizeof(ipv6_mask_tos));
ipv6_mask_tos.hdr.vtc_flow |=
RTE_BE32(0xfful << RTE_IPV6_HDR_TC_SHIFT);
ipv6_mask_tos.hdr.hop_limits = 0xff;
action_vxlan_encap_data->item_ipv6.hdr.vtc_flow |=
rte_cpu_to_be_32
((uint32_t)vxlan_encap_conf.ip_tos <<
RTE_IPV6_HDR_TC_SHIFT);
action_vxlan_encap_data->item_ipv6.hdr.hop_limits =
vxlan_encap_conf.ip_ttl;
action_vxlan_encap_data->items[2].mask =
&ipv6_mask_tos;
}
}
memcpy(action_vxlan_encap_data->item_vxlan.vni, vxlan_encap_conf.vni,
RTE_DIM(vxlan_encap_conf.vni));
return 0;
}
/** Parse VXLAN encap action. */
static int
parse_vc_action_vxlan_encap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_vxlan_encap_data *action_vxlan_encap_data;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
action_vxlan_encap_data = ctx->object;
parse_setup_vxlan_encap_data(action_vxlan_encap_data);
action->conf = &action_vxlan_encap_data->conf;
return ret;
}
/** Setup NVGRE encap configuration. */
static int
parse_setup_nvgre_encap_data(struct action_nvgre_encap_data *action_nvgre_encap_data)
{
/* Set up default configuration. */
*action_nvgre_encap_data = (struct action_nvgre_encap_data){
.conf = (struct rte_flow_action_nvgre_encap){
.definition = action_nvgre_encap_data->items,
},
.items = {
{
.type = RTE_FLOW_ITEM_TYPE_ETH,
.spec = &action_nvgre_encap_data->item_eth,
.mask = &rte_flow_item_eth_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_VLAN,
.spec = &action_nvgre_encap_data->item_vlan,
.mask = &rte_flow_item_vlan_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_IPV4,
.spec = &action_nvgre_encap_data->item_ipv4,
.mask = &rte_flow_item_ipv4_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_NVGRE,
.spec = &action_nvgre_encap_data->item_nvgre,
.mask = &rte_flow_item_nvgre_mask,
},
{
.type = RTE_FLOW_ITEM_TYPE_END,
},
},
.item_eth.type = 0,
.item_vlan = {
.tci = nvgre_encap_conf.vlan_tci,
.inner_type = 0,
},
.item_ipv4.hdr = {
.src_addr = nvgre_encap_conf.ipv4_src,
.dst_addr = nvgre_encap_conf.ipv4_dst,
},
.item_nvgre.c_k_s_rsvd0_ver = RTE_BE16(0x2000),
.item_nvgre.protocol = RTE_BE16(RTE_ETHER_TYPE_TEB),
.item_nvgre.flow_id = 0,
};
memcpy(action_nvgre_encap_data->item_eth.dst.addr_bytes,
nvgre_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN);
memcpy(action_nvgre_encap_data->item_eth.src.addr_bytes,
nvgre_encap_conf.eth_src, RTE_ETHER_ADDR_LEN);
if (!nvgre_encap_conf.select_ipv4) {
memcpy(&action_nvgre_encap_data->item_ipv6.hdr.src_addr,
&nvgre_encap_conf.ipv6_src,
sizeof(nvgre_encap_conf.ipv6_src));
memcpy(&action_nvgre_encap_data->item_ipv6.hdr.dst_addr,
&nvgre_encap_conf.ipv6_dst,
sizeof(nvgre_encap_conf.ipv6_dst));
action_nvgre_encap_data->items[2] = (struct rte_flow_item){
.type = RTE_FLOW_ITEM_TYPE_IPV6,
.spec = &action_nvgre_encap_data->item_ipv6,
.mask = &rte_flow_item_ipv6_mask,
};
}
if (!nvgre_encap_conf.select_vlan)
action_nvgre_encap_data->items[1].type =
RTE_FLOW_ITEM_TYPE_VOID;
memcpy(action_nvgre_encap_data->item_nvgre.tni, nvgre_encap_conf.tni,
RTE_DIM(nvgre_encap_conf.tni));
return 0;
}
/** Parse NVGRE encap action. */
static int
parse_vc_action_nvgre_encap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_nvgre_encap_data *action_nvgre_encap_data;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
action_nvgre_encap_data = ctx->object;
parse_setup_nvgre_encap_data(action_nvgre_encap_data);
action->conf = &action_nvgre_encap_data->conf;
return ret;
}
/** Parse l2 encap action. */
static int
parse_vc_action_l2_encap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_encap_data *action_encap_data;
struct rte_flow_item_eth eth = { .type = 0, };
struct rte_flow_item_vlan vlan = {
.tci = mplsoudp_encap_conf.vlan_tci,
.inner_type = 0,
};
uint8_t *header;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_encap_data = ctx->object;
*action_encap_data = (struct action_raw_encap_data) {
.conf = (struct rte_flow_action_raw_encap){
.data = action_encap_data->data,
},
.data = {},
};
header = action_encap_data->data;
if (l2_encap_conf.select_vlan)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
else if (l2_encap_conf.select_ipv4)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(eth.dst.addr_bytes,
l2_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN);
memcpy(eth.src.addr_bytes,
l2_encap_conf.eth_src, RTE_ETHER_ADDR_LEN);
memcpy(header, &eth, sizeof(eth));
header += sizeof(eth);
if (l2_encap_conf.select_vlan) {
if (l2_encap_conf.select_ipv4)
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(header, &vlan, sizeof(vlan));
header += sizeof(vlan);
}
action_encap_data->conf.size = header -
action_encap_data->data;
action->conf = &action_encap_data->conf;
return ret;
}
/** Parse l2 decap action. */
static int
parse_vc_action_l2_decap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_decap_data *action_decap_data;
struct rte_flow_item_eth eth = { .type = 0, };
struct rte_flow_item_vlan vlan = {
.tci = mplsoudp_encap_conf.vlan_tci,
.inner_type = 0,
};
uint8_t *header;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_decap_data = ctx->object;
*action_decap_data = (struct action_raw_decap_data) {
.conf = (struct rte_flow_action_raw_decap){
.data = action_decap_data->data,
},
.data = {},
};
header = action_decap_data->data;
if (l2_decap_conf.select_vlan)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
memcpy(header, &eth, sizeof(eth));
header += sizeof(eth);
if (l2_decap_conf.select_vlan) {
memcpy(header, &vlan, sizeof(vlan));
header += sizeof(vlan);
}
action_decap_data->conf.size = header -
action_decap_data->data;
action->conf = &action_decap_data->conf;
return ret;
}
#define ETHER_TYPE_MPLS_UNICAST 0x8847
/** Parse MPLSOGRE encap action. */
static int
parse_vc_action_mplsogre_encap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_encap_data *action_encap_data;
struct rte_flow_item_eth eth = { .type = 0, };
struct rte_flow_item_vlan vlan = {
.tci = mplsogre_encap_conf.vlan_tci,
.inner_type = 0,
};
struct rte_flow_item_ipv4 ipv4 = {
.hdr = {
.src_addr = mplsogre_encap_conf.ipv4_src,
.dst_addr = mplsogre_encap_conf.ipv4_dst,
.next_proto_id = IPPROTO_GRE,
.version_ihl = RTE_IPV4_VHL_DEF,
.time_to_live = IPDEFTTL,
},
};
struct rte_flow_item_ipv6 ipv6 = {
.hdr = {
.proto = IPPROTO_GRE,
.hop_limits = IPDEFTTL,
},
};
struct rte_flow_item_gre gre = {
.protocol = rte_cpu_to_be_16(ETHER_TYPE_MPLS_UNICAST),
};
struct rte_flow_item_mpls mpls = {
.ttl = 0,
};
uint8_t *header;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_encap_data = ctx->object;
*action_encap_data = (struct action_raw_encap_data) {
.conf = (struct rte_flow_action_raw_encap){
.data = action_encap_data->data,
},
.data = {},
.preserve = {},
};
header = action_encap_data->data;
if (mplsogre_encap_conf.select_vlan)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
else if (mplsogre_encap_conf.select_ipv4)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(eth.dst.addr_bytes,
mplsogre_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN);
memcpy(eth.src.addr_bytes,
mplsogre_encap_conf.eth_src, RTE_ETHER_ADDR_LEN);
memcpy(header, &eth, sizeof(eth));
header += sizeof(eth);
if (mplsogre_encap_conf.select_vlan) {
if (mplsogre_encap_conf.select_ipv4)
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(header, &vlan, sizeof(vlan));
header += sizeof(vlan);
}
if (mplsogre_encap_conf.select_ipv4) {
memcpy(header, &ipv4, sizeof(ipv4));
header += sizeof(ipv4);
} else {
memcpy(&ipv6.hdr.src_addr,
&mplsogre_encap_conf.ipv6_src,
sizeof(mplsogre_encap_conf.ipv6_src));
memcpy(&ipv6.hdr.dst_addr,
&mplsogre_encap_conf.ipv6_dst,
sizeof(mplsogre_encap_conf.ipv6_dst));
memcpy(header, &ipv6, sizeof(ipv6));
header += sizeof(ipv6);
}
memcpy(header, &gre, sizeof(gre));
header += sizeof(gre);
memcpy(mpls.label_tc_s, mplsogre_encap_conf.label,
RTE_DIM(mplsogre_encap_conf.label));
mpls.label_tc_s[2] |= 0x1;
memcpy(header, &mpls, sizeof(mpls));
header += sizeof(mpls);
action_encap_data->conf.size = header -
action_encap_data->data;
action->conf = &action_encap_data->conf;
return ret;
}
/** Parse MPLSOGRE decap action. */
static int
parse_vc_action_mplsogre_decap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_decap_data *action_decap_data;
struct rte_flow_item_eth eth = { .type = 0, };
struct rte_flow_item_vlan vlan = {.tci = 0};
struct rte_flow_item_ipv4 ipv4 = {
.hdr = {
.next_proto_id = IPPROTO_GRE,
},
};
struct rte_flow_item_ipv6 ipv6 = {
.hdr = {
.proto = IPPROTO_GRE,
},
};
struct rte_flow_item_gre gre = {
.protocol = rte_cpu_to_be_16(ETHER_TYPE_MPLS_UNICAST),
};
struct rte_flow_item_mpls mpls;
uint8_t *header;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_decap_data = ctx->object;
*action_decap_data = (struct action_raw_decap_data) {
.conf = (struct rte_flow_action_raw_decap){
.data = action_decap_data->data,
},
.data = {},
};
header = action_decap_data->data;
if (mplsogre_decap_conf.select_vlan)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
else if (mplsogre_encap_conf.select_ipv4)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(eth.dst.addr_bytes,
mplsogre_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN);
memcpy(eth.src.addr_bytes,
mplsogre_encap_conf.eth_src, RTE_ETHER_ADDR_LEN);
memcpy(header, &eth, sizeof(eth));
header += sizeof(eth);
if (mplsogre_encap_conf.select_vlan) {
if (mplsogre_encap_conf.select_ipv4)
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(header, &vlan, sizeof(vlan));
header += sizeof(vlan);
}
if (mplsogre_encap_conf.select_ipv4) {
memcpy(header, &ipv4, sizeof(ipv4));
header += sizeof(ipv4);
} else {
memcpy(header, &ipv6, sizeof(ipv6));
header += sizeof(ipv6);
}
memcpy(header, &gre, sizeof(gre));
header += sizeof(gre);
memset(&mpls, 0, sizeof(mpls));
memcpy(header, &mpls, sizeof(mpls));
header += sizeof(mpls);
action_decap_data->conf.size = header -
action_decap_data->data;
action->conf = &action_decap_data->conf;
return ret;
}
/** Parse MPLSOUDP encap action. */
static int
parse_vc_action_mplsoudp_encap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_encap_data *action_encap_data;
struct rte_flow_item_eth eth = { .type = 0, };
struct rte_flow_item_vlan vlan = {
.tci = mplsoudp_encap_conf.vlan_tci,
.inner_type = 0,
};
struct rte_flow_item_ipv4 ipv4 = {
.hdr = {
.src_addr = mplsoudp_encap_conf.ipv4_src,
.dst_addr = mplsoudp_encap_conf.ipv4_dst,
.next_proto_id = IPPROTO_UDP,
.version_ihl = RTE_IPV4_VHL_DEF,
.time_to_live = IPDEFTTL,
},
};
struct rte_flow_item_ipv6 ipv6 = {
.hdr = {
.proto = IPPROTO_UDP,
.hop_limits = IPDEFTTL,
},
};
struct rte_flow_item_udp udp = {
.hdr = {
.src_port = mplsoudp_encap_conf.udp_src,
.dst_port = mplsoudp_encap_conf.udp_dst,
},
};
struct rte_flow_item_mpls mpls;
uint8_t *header;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_encap_data = ctx->object;
*action_encap_data = (struct action_raw_encap_data) {
.conf = (struct rte_flow_action_raw_encap){
.data = action_encap_data->data,
},
.data = {},
.preserve = {},
};
header = action_encap_data->data;
if (mplsoudp_encap_conf.select_vlan)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
else if (mplsoudp_encap_conf.select_ipv4)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(eth.dst.addr_bytes,
mplsoudp_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN);
memcpy(eth.src.addr_bytes,
mplsoudp_encap_conf.eth_src, RTE_ETHER_ADDR_LEN);
memcpy(header, &eth, sizeof(eth));
header += sizeof(eth);
if (mplsoudp_encap_conf.select_vlan) {
if (mplsoudp_encap_conf.select_ipv4)
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(header, &vlan, sizeof(vlan));
header += sizeof(vlan);
}
if (mplsoudp_encap_conf.select_ipv4) {
memcpy(header, &ipv4, sizeof(ipv4));
header += sizeof(ipv4);
} else {
memcpy(&ipv6.hdr.src_addr,
&mplsoudp_encap_conf.ipv6_src,
sizeof(mplsoudp_encap_conf.ipv6_src));
memcpy(&ipv6.hdr.dst_addr,
&mplsoudp_encap_conf.ipv6_dst,
sizeof(mplsoudp_encap_conf.ipv6_dst));
memcpy(header, &ipv6, sizeof(ipv6));
header += sizeof(ipv6);
}
memcpy(header, &udp, sizeof(udp));
header += sizeof(udp);
memcpy(mpls.label_tc_s, mplsoudp_encap_conf.label,
RTE_DIM(mplsoudp_encap_conf.label));
mpls.label_tc_s[2] |= 0x1;
memcpy(header, &mpls, sizeof(mpls));
header += sizeof(mpls);
action_encap_data->conf.size = header -
action_encap_data->data;
action->conf = &action_encap_data->conf;
return ret;
}
/** Parse MPLSOUDP decap action. */
static int
parse_vc_action_mplsoudp_decap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_decap_data *action_decap_data;
struct rte_flow_item_eth eth = { .type = 0, };
struct rte_flow_item_vlan vlan = {.tci = 0};
struct rte_flow_item_ipv4 ipv4 = {
.hdr = {
.next_proto_id = IPPROTO_UDP,
},
};
struct rte_flow_item_ipv6 ipv6 = {
.hdr = {
.proto = IPPROTO_UDP,
},
};
struct rte_flow_item_udp udp = {
.hdr = {
.dst_port = rte_cpu_to_be_16(6635),
},
};
struct rte_flow_item_mpls mpls;
uint8_t *header;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_decap_data = ctx->object;
*action_decap_data = (struct action_raw_decap_data) {
.conf = (struct rte_flow_action_raw_decap){
.data = action_decap_data->data,
},
.data = {},
};
header = action_decap_data->data;
if (mplsoudp_decap_conf.select_vlan)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
else if (mplsoudp_encap_conf.select_ipv4)
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
eth.type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(eth.dst.addr_bytes,
mplsoudp_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN);
memcpy(eth.src.addr_bytes,
mplsoudp_encap_conf.eth_src, RTE_ETHER_ADDR_LEN);
memcpy(header, &eth, sizeof(eth));
header += sizeof(eth);
if (mplsoudp_encap_conf.select_vlan) {
if (mplsoudp_encap_conf.select_ipv4)
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
vlan.inner_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
memcpy(header, &vlan, sizeof(vlan));
header += sizeof(vlan);
}
if (mplsoudp_encap_conf.select_ipv4) {
memcpy(header, &ipv4, sizeof(ipv4));
header += sizeof(ipv4);
} else {
memcpy(header, &ipv6, sizeof(ipv6));
header += sizeof(ipv6);
}
memcpy(header, &udp, sizeof(udp));
header += sizeof(udp);
memset(&mpls, 0, sizeof(mpls));
memcpy(header, &mpls, sizeof(mpls));
header += sizeof(mpls);
action_decap_data->conf.size = header -
action_decap_data->data;
action->conf = &action_decap_data->conf;
return ret;
}
static int
parse_vc_action_raw_decap_index(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct action_raw_decap_data *action_raw_decap_data;
struct rte_flow_action *action;
const struct arg *arg;
struct buffer *out = buf;
int ret;
uint16_t idx;
RTE_SET_USED(token);
RTE_SET_USED(buf);
RTE_SET_USED(size);
arg = ARGS_ENTRY_ARB_BOUNDED
(offsetof(struct action_raw_decap_data, idx),
sizeof(((struct action_raw_decap_data *)0)->idx),
0, RAW_ENCAP_CONFS_MAX_NUM - 1);
if (push_args(ctx, arg))
return -1;
ret = parse_int(ctx, token, str, len, NULL, 0);
if (ret < 0) {
pop_args(ctx);
return -1;
}
if (!ctx->object)
return len;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
action_raw_decap_data = ctx->object;
idx = action_raw_decap_data->idx;
action_raw_decap_data->conf.data = raw_decap_confs[idx].data;
action_raw_decap_data->conf.size = raw_decap_confs[idx].size;
action->conf = &action_raw_decap_data->conf;
return len;
}
static int
parse_vc_action_raw_encap_index(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct action_raw_encap_data *action_raw_encap_data;
struct rte_flow_action *action;
const struct arg *arg;
struct buffer *out = buf;
int ret;
uint16_t idx;
RTE_SET_USED(token);
RTE_SET_USED(buf);
RTE_SET_USED(size);
if (ctx->curr != ACTION_RAW_ENCAP_INDEX_VALUE)
return -1;
arg = ARGS_ENTRY_ARB_BOUNDED
(offsetof(struct action_raw_encap_data, idx),
sizeof(((struct action_raw_encap_data *)0)->idx),
0, RAW_ENCAP_CONFS_MAX_NUM - 1);
if (push_args(ctx, arg))
return -1;
ret = parse_int(ctx, token, str, len, NULL, 0);
if (ret < 0) {
pop_args(ctx);
return -1;
}
if (!ctx->object)
return len;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
action_raw_encap_data = ctx->object;
idx = action_raw_encap_data->idx;
action_raw_encap_data->conf.data = raw_encap_confs[idx].data;
action_raw_encap_data->conf.size = raw_encap_confs[idx].size;
action_raw_encap_data->conf.preserve = NULL;
action->conf = &action_raw_encap_data->conf;
return len;
}
static int
parse_vc_action_raw_encap(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_encap_data *action_raw_encap_data = NULL;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_raw_encap_data = ctx->object;
action_raw_encap_data->conf.data = raw_encap_confs[0].data;
action_raw_encap_data->conf.preserve = NULL;
action_raw_encap_data->conf.size = raw_encap_confs[0].size;
action->conf = &action_raw_encap_data->conf;
return ret;
}
static int
parse_vc_action_raw_decap(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_raw_decap_data *action_raw_decap_data = NULL;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_raw_decap_data = ctx->object;
action_raw_decap_data->conf.data = raw_decap_confs[0].data;
action_raw_decap_data->conf.size = raw_decap_confs[0].size;
action->conf = &action_raw_decap_data->conf;
return ret;
}
static int
parse_vc_action_set_meta(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
ret = rte_flow_dynf_metadata_register();
if (ret < 0)
return -1;
return len;
}
static int
parse_vc_action_sample(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_action *action;
struct action_sample_data *action_sample_data = NULL;
static struct rte_flow_action end_action = {
RTE_FLOW_ACTION_TYPE_END, 0
};
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
if (ret < 0)
return ret;
/* Nothing else to do if there is no buffer. */
if (!out)
return ret;
if (!out->args.vc.actions_n)
return -1;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
/* Point to selected object. */
ctx->object = out->args.vc.data;
ctx->objmask = NULL;
/* Copy the headers to the buffer. */
action_sample_data = ctx->object;
action_sample_data->conf.actions = &end_action;
action->conf = &action_sample_data->conf;
return ret;
}
static int
parse_vc_action_sample_index(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct action_sample_data *action_sample_data;
struct rte_flow_action *action;
const struct arg *arg;
struct buffer *out = buf;
int ret;
uint16_t idx;
RTE_SET_USED(token);
RTE_SET_USED(buf);
RTE_SET_USED(size);
if (ctx->curr != ACTION_SAMPLE_INDEX_VALUE)
return -1;
arg = ARGS_ENTRY_ARB_BOUNDED
(offsetof(struct action_sample_data, idx),
sizeof(((struct action_sample_data *)0)->idx),
0, RAW_SAMPLE_CONFS_MAX_NUM - 1);
if (push_args(ctx, arg))
return -1;
ret = parse_int(ctx, token, str, len, NULL, 0);
if (ret < 0) {
pop_args(ctx);
return -1;
}
if (!ctx->object)
return len;
action = &out->args.vc.actions[out->args.vc.actions_n - 1];
action_sample_data = ctx->object;
idx = action_sample_data->idx;
action_sample_data->conf.actions = raw_sample_confs[idx].data;
action->conf = &action_sample_data->conf;
return len;
}
/** Parse operation for modify_field command. */
static int
parse_vc_modify_field_op(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct rte_flow_action_modify_field *action_modify_field;
unsigned int i;
(void)token;
(void)buf;
(void)size;
if (ctx->curr != ACTION_MODIFY_FIELD_OP_VALUE)
return -1;
for (i = 0; modify_field_ops[i]; ++i)
if (!strcmp_partial(modify_field_ops[i], str, len))
break;
if (!modify_field_ops[i])
return -1;
if (!ctx->object)
return len;
action_modify_field = ctx->object;
action_modify_field->operation = (enum rte_flow_modify_op)i;
return len;
}
/** Parse id for modify_field command. */
static int
parse_vc_modify_field_id(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct rte_flow_action_modify_field *action_modify_field;
unsigned int i;
(void)token;
(void)buf;
(void)size;
if (ctx->curr != ACTION_MODIFY_FIELD_DST_TYPE_VALUE &&
ctx->curr != ACTION_MODIFY_FIELD_SRC_TYPE_VALUE)
return -1;
for (i = 0; modify_field_ids[i]; ++i)
if (!strcmp_partial(modify_field_ids[i], str, len))
break;
if (!modify_field_ids[i])
return -1;
if (!ctx->object)
return len;
action_modify_field = ctx->object;
if (ctx->curr == ACTION_MODIFY_FIELD_DST_TYPE_VALUE)
action_modify_field->dst.field = (enum rte_flow_field_id)i;
else
action_modify_field->src.field = (enum rte_flow_field_id)i;
return len;
}
/** Parse the conntrack update, not a rte_flow_action. */
static int
parse_vc_action_conntrack_update(struct context *ctx, const struct token *token,
const char *str, unsigned int len, void *buf,
unsigned int size)
{
struct buffer *out = buf;
struct rte_flow_modify_conntrack *ct_modify = NULL;
(void)size;
if (ctx->curr != ACTION_CONNTRACK_UPDATE_CTX &&
ctx->curr != ACTION_CONNTRACK_UPDATE_DIR)
return -1;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
ct_modify = (struct rte_flow_modify_conntrack *)out->args.vc.data;
if (ctx->curr == ACTION_CONNTRACK_UPDATE_DIR) {
ct_modify->new_ct.is_original_dir =
conntrack_context.is_original_dir;
ct_modify->direction = 1;
} else {
uint32_t old_dir;
old_dir = ct_modify->new_ct.is_original_dir;
memcpy(&ct_modify->new_ct, &conntrack_context,
sizeof(conntrack_context));
ct_modify->new_ct.is_original_dir = old_dir;
ct_modify->state = 1;
}
return len;
}
/** Parse tokens for destroy command. */
static int
parse_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != DESTROY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.destroy.rule =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
if (((uint8_t *)(out->args.destroy.rule + out->args.destroy.rule_n) +
sizeof(*out->args.destroy.rule)) > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = out->args.destroy.rule + out->args.destroy.rule_n++;
ctx->objmask = NULL;
return len;
}
/** Parse tokens for flush command. */
static int
parse_flush(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != FLUSH)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
}
return len;
}
/** Parse tokens for dump command. */
static int
parse_dump(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != DUMP)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
}
switch (ctx->curr) {
case DUMP_ALL:
case DUMP_ONE:
out->args.dump.mode = (ctx->curr == DUMP_ALL) ? true : false;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
default:
return -1;
}
}
/** Parse tokens for query command. */
static int
parse_query(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != QUERY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
}
return len;
}
/** Parse action names. */
static int
parse_action(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
const struct arg *arg = pop_args(ctx);
unsigned int i;
(void)size;
/* Argument is expected. */
if (!arg)
return -1;
/* Parse action name. */
for (i = 0; next_action[i]; ++i) {
const struct parse_action_priv *priv;
token = &token_list[next_action[i]];
if (strcmp_partial(token->name, str, len))
continue;
priv = token->priv;
if (!priv)
goto error;
if (out)
memcpy((uint8_t *)ctx->object + arg->offset,
&priv->type,
arg->size);
return len;
}
error:
push_args(ctx, arg);
return -1;
}
/** Parse tokens for list command. */
static int
parse_list(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != LIST)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.list.group =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
if (((uint8_t *)(out->args.list.group + out->args.list.group_n) +
sizeof(*out->args.list.group)) > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = out->args.list.group + out->args.list.group_n++;
ctx->objmask = NULL;
return len;
}
/** Parse tokens for list all aged flows command. */
static int
parse_aged(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != AGED)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
}
if (ctx->curr == AGED_DESTROY)
out->args.aged.destroy = 1;
return len;
}
/** Parse tokens for isolate command. */
static int
parse_isolate(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != ISOLATE)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
}
return len;
}
/** Parse tokens for info/configure command. */
static int
parse_configure(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != INFO && ctx->curr != CONFIGURE)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
}
return len;
}
/** Parse tokens for template create command. */
static int
parse_template(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != PATTERN_TEMPLATE &&
ctx->curr != ACTIONS_TEMPLATE)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.vc.data = (uint8_t *)out + size;
return len;
}
switch (ctx->curr) {
case PATTERN_TEMPLATE_CREATE:
out->args.vc.pattern =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
out->args.vc.pat_templ_id = UINT32_MAX;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
case PATTERN_TEMPLATE_EGRESS:
out->args.vc.attr.egress = 1;
return len;
case PATTERN_TEMPLATE_INGRESS:
out->args.vc.attr.ingress = 1;
return len;
case PATTERN_TEMPLATE_TRANSFER:
out->args.vc.attr.transfer = 1;
return len;
case ACTIONS_TEMPLATE_CREATE:
out->args.vc.act_templ_id = UINT32_MAX;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
case ACTIONS_TEMPLATE_SPEC:
out->args.vc.actions =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
ctx->object = out->args.vc.actions;
ctx->objmask = NULL;
return len;
case ACTIONS_TEMPLATE_MASK:
out->args.vc.masks =
(void *)RTE_ALIGN_CEIL((uintptr_t)
(out->args.vc.actions +
out->args.vc.actions_n),
sizeof(double));
ctx->object = out->args.vc.masks;
ctx->objmask = NULL;
return len;
case ACTIONS_TEMPLATE_EGRESS:
out->args.vc.attr.egress = 1;
return len;
case ACTIONS_TEMPLATE_INGRESS:
out->args.vc.attr.ingress = 1;
return len;
case ACTIONS_TEMPLATE_TRANSFER:
out->args.vc.attr.transfer = 1;
return len;
default:
return -1;
}
}
/** Parse tokens for template destroy command. */
static int
parse_template_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
uint32_t *template_id;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command ||
out->command == PATTERN_TEMPLATE ||
out->command == ACTIONS_TEMPLATE) {
if (ctx->curr != PATTERN_TEMPLATE_DESTROY &&
ctx->curr != ACTIONS_TEMPLATE_DESTROY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.templ_destroy.template_id =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
template_id = out->args.templ_destroy.template_id
+ out->args.templ_destroy.template_id_n++;
if ((uint8_t *)template_id > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = template_id;
ctx->objmask = NULL;
return len;
}
/** Parse tokens for table create command. */
static int
parse_table(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
uint32_t *template_id;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != TABLE)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
}
switch (ctx->curr) {
case TABLE_CREATE:
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.table.id = UINT32_MAX;
return len;
case TABLE_PATTERN_TEMPLATE:
out->args.table.pat_templ_id =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
template_id = out->args.table.pat_templ_id
+ out->args.table.pat_templ_id_n++;
if ((uint8_t *)template_id > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = template_id;
ctx->objmask = NULL;
return len;
case TABLE_ACTIONS_TEMPLATE:
out->args.table.act_templ_id =
(void *)RTE_ALIGN_CEIL((uintptr_t)
(out->args.table.pat_templ_id +
out->args.table.pat_templ_id_n),
sizeof(double));
template_id = out->args.table.act_templ_id
+ out->args.table.act_templ_id_n++;
if ((uint8_t *)template_id > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = template_id;
ctx->objmask = NULL;
return len;
case TABLE_INGRESS:
out->args.table.attr.flow_attr.ingress = 1;
return len;
case TABLE_EGRESS:
out->args.table.attr.flow_attr.egress = 1;
return len;
case TABLE_TRANSFER:
out->args.table.attr.flow_attr.transfer = 1;
return len;
default:
return -1;
}
}
/** Parse tokens for table destroy command. */
static int
parse_table_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
uint32_t *table_id;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command || out->command == TABLE) {
if (ctx->curr != TABLE_DESTROY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.table_destroy.table_id =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
table_id = out->args.table_destroy.table_id
+ out->args.table_destroy.table_id_n++;
if ((uint8_t *)table_id > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = table_id;
ctx->objmask = NULL;
return len;
}
/** Parse tokens for queue create commands. */
static int
parse_qo(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != QUEUE)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.vc.data = (uint8_t *)out + size;
return len;
}
switch (ctx->curr) {
case QUEUE_CREATE:
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
case QUEUE_TEMPLATE_TABLE:
case QUEUE_PATTERN_TEMPLATE:
case QUEUE_ACTIONS_TEMPLATE:
case QUEUE_CREATE_POSTPONE:
return len;
case ITEM_PATTERN:
out->args.vc.pattern =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
ctx->object = out->args.vc.pattern;
ctx->objmask = NULL;
return len;
case ACTIONS:
out->args.vc.actions =
(void *)RTE_ALIGN_CEIL((uintptr_t)
(out->args.vc.pattern +
out->args.vc.pattern_n),
sizeof(double));
ctx->object = out->args.vc.actions;
ctx->objmask = NULL;
return len;
default:
return -1;
}
}
/** Parse tokens for queue destroy command. */
static int
parse_qo_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
uint32_t *flow_id;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command || out->command == QUEUE) {
if (ctx->curr != QUEUE_DESTROY)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.destroy.rule =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
switch (ctx->curr) {
case QUEUE_DESTROY_ID:
flow_id = out->args.destroy.rule
+ out->args.destroy.rule_n++;
if ((uint8_t *)flow_id > (uint8_t *)out + size)
return -1;
ctx->objdata = 0;
ctx->object = flow_id;
ctx->objmask = NULL;
return len;
case QUEUE_DESTROY_POSTPONE:
return len;
default:
return -1;
}
}
/** Parse tokens for push queue command. */
static int
parse_push(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != PUSH)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.vc.data = (uint8_t *)out + size;
}
return len;
}
/** Parse tokens for pull command. */
static int
parse_pull(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != PULL)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
out->args.vc.data = (uint8_t *)out + size;
}
return len;
}
static int
parse_flex(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (out->command == ZERO) {
if (ctx->curr != FLEX)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
} else {
switch (ctx->curr) {
default:
break;
case FLEX_ITEM_INIT:
case FLEX_ITEM_CREATE:
case FLEX_ITEM_DESTROY:
out->command = ctx->curr;
break;
}
}
return len;
}
static int
parse_tunnel(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
if (!out->command) {
if (ctx->curr != TUNNEL)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
} else {
switch (ctx->curr) {
default:
break;
case TUNNEL_CREATE:
case TUNNEL_DESTROY:
case TUNNEL_LIST:
out->command = ctx->curr;
break;
case TUNNEL_CREATE_TYPE:
case TUNNEL_DESTROY_ID:
ctx->object = &out->args.vc.tunnel_ops;
break;
}
}
return len;
}
/**
* Parse signed/unsigned integers 8 to 64-bit long.
*
* Last argument (ctx->args) is retrieved to determine integer type and
* storage location.
*/
static int
parse_int(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg = pop_args(ctx);
uintmax_t u;
char *end;
(void)token;
/* Argument is expected. */
if (!arg)
return -1;
errno = 0;
u = arg->sign ?
(uintmax_t)strtoimax(str, &end, 0) :
strtoumax(str, &end, 0);
if (errno || (size_t)(end - str) != len)
goto error;
if (arg->bounded &&
((arg->sign && ((intmax_t)u < (intmax_t)arg->min ||
(intmax_t)u > (intmax_t)arg->max)) ||
(!arg->sign && (u < arg->min || u > arg->max))))
goto error;
if (!ctx->object)
return len;
if (arg->mask) {
if (!arg_entry_bf_fill(ctx->object, u, arg) ||
!arg_entry_bf_fill(ctx->objmask, -1, arg))
goto error;
return len;
}
buf = (uint8_t *)ctx->object + arg->offset;
size = arg->size;
if (u > RTE_LEN2MASK(size * CHAR_BIT, uint64_t))
return -1;
objmask:
switch (size) {
case sizeof(uint8_t):
*(uint8_t *)buf = u;
break;
case sizeof(uint16_t):
*(uint16_t *)buf = arg->hton ? rte_cpu_to_be_16(u) : u;
break;
case sizeof(uint8_t [3]):
#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
if (!arg->hton) {
((uint8_t *)buf)[0] = u;
((uint8_t *)buf)[1] = u >> 8;
((uint8_t *)buf)[2] = u >> 16;
break;
}
#endif
((uint8_t *)buf)[0] = u >> 16;
((uint8_t *)buf)[1] = u >> 8;
((uint8_t *)buf)[2] = u;
break;
case sizeof(uint32_t):
*(uint32_t *)buf = arg->hton ? rte_cpu_to_be_32(u) : u;
break;
case sizeof(uint64_t):
*(uint64_t *)buf = arg->hton ? rte_cpu_to_be_64(u) : u;
break;
default:
goto error;
}
if (ctx->objmask && buf != (uint8_t *)ctx->objmask + arg->offset) {
u = -1;
buf = (uint8_t *)ctx->objmask + arg->offset;
goto objmask;
}
return len;
error:
push_args(ctx, arg);
return -1;
}
/**
* Parse a string.
*
* Three arguments (ctx->args) are retrieved from the stack to store data,
* its actual length and address (in that order).
*/
static int
parse_string(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg_data = pop_args(ctx);
const struct arg *arg_len = pop_args(ctx);
const struct arg *arg_addr = pop_args(ctx);
char tmp[16]; /* Ought to be enough. */
int ret;
/* Arguments are expected. */
if (!arg_data)
return -1;
if (!arg_len) {
push_args(ctx, arg_data);
return -1;
}
if (!arg_addr) {
push_args(ctx, arg_len);
push_args(ctx, arg_data);
return -1;
}
size = arg_data->size;
/* Bit-mask fill is not supported. */
if (arg_data->mask || size < len)
goto error;
if (!ctx->object)
return len;
/* Let parse_int() fill length information first. */
ret = snprintf(tmp, sizeof(tmp), "%u", len);
if (ret < 0)
goto error;
push_args(ctx, arg_len);
ret = parse_int(ctx, token, tmp, ret, NULL, 0);
if (ret < 0) {
pop_args(ctx);
goto error;
}
buf = (uint8_t *)ctx->object + arg_data->offset;
/* Output buffer is not necessarily NUL-terminated. */
memcpy(buf, str, len);
memset((uint8_t *)buf + len, 0x00, size - len);
if (ctx->objmask)
memset((uint8_t *)ctx->objmask + arg_data->offset, 0xff, len);
/* Save address if requested. */
if (arg_addr->size) {
memcpy((uint8_t *)ctx->object + arg_addr->offset,
(void *[]){
(uint8_t *)ctx->object + arg_data->offset
},
arg_addr->size);
if (ctx->objmask)
memcpy((uint8_t *)ctx->objmask + arg_addr->offset,
(void *[]){
(uint8_t *)ctx->objmask + arg_data->offset
},
arg_addr->size);
}
return len;
error:
push_args(ctx, arg_addr);
push_args(ctx, arg_len);
push_args(ctx, arg_data);
return -1;
}
static int
parse_hex_string(const char *src, uint8_t *dst, uint32_t *size)
{
const uint8_t *head = dst;
uint32_t left;
if (*size == 0)
return -1;
left = *size;
/* Convert chars to bytes */
while (left) {
char tmp[3], *end = tmp;
uint32_t read_lim = left & 1 ? 1 : 2;
snprintf(tmp, read_lim + 1, "%s", src);
*dst = strtoul(tmp, &end, 16);
if (*end) {
*dst = 0;
*size = (uint32_t)(dst - head);
return -1;
}
left -= read_lim;
src += read_lim;
dst++;
}
*dst = 0;
*size = (uint32_t)(dst - head);
return 0;
}
static int
parse_hex(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg_data = pop_args(ctx);
const struct arg *arg_len = pop_args(ctx);
const struct arg *arg_addr = pop_args(ctx);
char tmp[16]; /* Ought to be enough. */
int ret;
unsigned int hexlen = len;
unsigned int length = 256;
uint8_t hex_tmp[length];
/* Arguments are expected. */
if (!arg_data)
return -1;
if (!arg_len) {
push_args(ctx, arg_data);
return -1;
}
if (!arg_addr) {
push_args(ctx, arg_len);
push_args(ctx, arg_data);
return -1;
}
size = arg_data->size;
/* Bit-mask fill is not supported. */
if (arg_data->mask)
goto error;
if (!ctx->object)
return len;
/* translate bytes string to array. */
if (str[0] == '0' && ((str[1] == 'x') ||
(str[1] == 'X'))) {
str += 2;
hexlen -= 2;
}
if (hexlen > length)
goto error;
ret = parse_hex_string(str, hex_tmp, &hexlen);
if (ret < 0)
goto error;
/* Check the converted binary fits into data buffer. */
if (hexlen > size)
goto error;
/* Let parse_int() fill length information first. */
ret = snprintf(tmp, sizeof(tmp), "%u", hexlen);
if (ret < 0)
goto error;
/* Save length if requested. */
if (arg_len->size) {
push_args(ctx, arg_len);
ret = parse_int(ctx, token, tmp, ret, NULL, 0);
if (ret < 0) {
pop_args(ctx);
goto error;
}
}
buf = (uint8_t *)ctx->object + arg_data->offset;
/* Output buffer is not necessarily NUL-terminated. */
memcpy(buf, hex_tmp, hexlen);
memset((uint8_t *)buf + hexlen, 0x00, size - hexlen);
if (ctx->objmask)
memset((uint8_t *)ctx->objmask + arg_data->offset,
0xff, hexlen);
/* Save address if requested. */
if (arg_addr->size) {
memcpy((uint8_t *)ctx->object + arg_addr->offset,
(void *[]){
(uint8_t *)ctx->object + arg_data->offset
},
arg_addr->size);
if (ctx->objmask)
memcpy((uint8_t *)ctx->objmask + arg_addr->offset,
(void *[]){
(uint8_t *)ctx->objmask + arg_data->offset
},
arg_addr->size);
}
return len;
error:
push_args(ctx, arg_addr);
push_args(ctx, arg_len);
push_args(ctx, arg_data);
return -1;
}
/**
* Parse a zero-ended string.
*/
static int
parse_string0(struct context *ctx, const struct token *token __rte_unused,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg_data = pop_args(ctx);
/* Arguments are expected. */
if (!arg_data)
return -1;
size = arg_data->size;
/* Bit-mask fill is not supported. */
if (arg_data->mask || size < len + 1)
goto error;
if (!ctx->object)
return len;
buf = (uint8_t *)ctx->object + arg_data->offset;
strncpy(buf, str, len);
if (ctx->objmask)
memset((uint8_t *)ctx->objmask + arg_data->offset, 0xff, len);
return len;
error:
push_args(ctx, arg_data);
return -1;
}
/**
* Parse a MAC address.
*
* Last argument (ctx->args) is retrieved to determine storage size and
* location.
*/
static int
parse_mac_addr(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg = pop_args(ctx);
struct rte_ether_addr tmp;
int ret;
(void)token;
/* Argument is expected. */
if (!arg)
return -1;
size = arg->size;
/* Bit-mask fill is not supported. */
if (arg->mask || size != sizeof(tmp))
goto error;
/* Only network endian is supported. */
if (!arg->hton)
goto error;
ret = cmdline_parse_etheraddr(NULL, str, &tmp, size);
if (ret < 0 || (unsigned int)ret != len)
goto error;
if (!ctx->object)
return len;
buf = (uint8_t *)ctx->object + arg->offset;
memcpy(buf, &tmp, size);
if (ctx->objmask)
memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
return len;
error:
push_args(ctx, arg);
return -1;
}
/**
* Parse an IPv4 address.
*
* Last argument (ctx->args) is retrieved to determine storage size and
* location.
*/
static int
parse_ipv4_addr(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg = pop_args(ctx);
char str2[len + 1];
struct in_addr tmp;
int ret;
/* Argument is expected. */
if (!arg)
return -1;
size = arg->size;
/* Bit-mask fill is not supported. */
if (arg->mask || size != sizeof(tmp))
goto error;
/* Only network endian is supported. */
if (!arg->hton)
goto error;
memcpy(str2, str, len);
str2[len] = '\0';
ret = inet_pton(AF_INET, str2, &tmp);
if (ret != 1) {
/* Attempt integer parsing. */
push_args(ctx, arg);
return parse_int(ctx, token, str, len, buf, size);
}
if (!ctx->object)
return len;
buf = (uint8_t *)ctx->object + arg->offset;
memcpy(buf, &tmp, size);
if (ctx->objmask)
memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
return len;
error:
push_args(ctx, arg);
return -1;
}
/**
* Parse an IPv6 address.
*
* Last argument (ctx->args) is retrieved to determine storage size and
* location.
*/
static int
parse_ipv6_addr(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg = pop_args(ctx);
char str2[len + 1];
struct in6_addr tmp;
int ret;
(void)token;
/* Argument is expected. */
if (!arg)
return -1;
size = arg->size;
/* Bit-mask fill is not supported. */
if (arg->mask || size != sizeof(tmp))
goto error;
/* Only network endian is supported. */
if (!arg->hton)
goto error;
memcpy(str2, str, len);
str2[len] = '\0';
ret = inet_pton(AF_INET6, str2, &tmp);
if (ret != 1)
goto error;
if (!ctx->object)
return len;
buf = (uint8_t *)ctx->object + arg->offset;
memcpy(buf, &tmp, size);
if (ctx->objmask)
memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
return len;
error:
push_args(ctx, arg);
return -1;
}
/** Boolean values (even indices stand for false). */
static const char *const boolean_name[] = {
"0", "1",
"false", "true",
"no", "yes",
"N", "Y",
"off", "on",
NULL,
};
/**
* Parse a boolean value.
*
* Last argument (ctx->args) is retrieved to determine storage size and
* location.
*/
static int
parse_boolean(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
const struct arg *arg = pop_args(ctx);
unsigned int i;
int ret;
/* Argument is expected. */
if (!arg)
return -1;
for (i = 0; boolean_name[i]; ++i)
if (!strcmp_partial(boolean_name[i], str, len))
break;
/* Process token as integer. */
if (boolean_name[i])
str = i & 1 ? "1" : "0";
push_args(ctx, arg);
ret = parse_int(ctx, token, str, strlen(str), buf, size);
return ret > 0 ? (int)len : ret;
}
/** Parse port and update context. */
static int
parse_port(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = &(struct buffer){ .port = 0 };
int ret;
if (buf)
out = buf;
else {
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
size = sizeof(*out);
}
ret = parse_int(ctx, token, str, len, out, size);
if (ret >= 0)
ctx->port = out->port;
if (!buf)
ctx->object = NULL;
return ret;
}
static int
parse_ia_id2ptr(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct rte_flow_action *action = ctx->object;
uint32_t id;
int ret;
(void)buf;
(void)size;
ctx->objdata = 0;
ctx->object = &id;
ctx->objmask = NULL;
ret = parse_int(ctx, token, str, len, ctx->object, sizeof(id));
ctx->object = action;
if (ret != (int)len)
return ret;
/* set indirect action */
if (action) {
action->conf = port_action_handle_get_by_id(ctx->port, id);
ret = (action->conf) ? ret : -1;
}
return ret;
}
/** Parse set command, initialize output buffer for subsequent tokens. */
static int
parse_set_raw_encap_decap(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
/* Make sure buffer is large enough. */
if (size < sizeof(*out))
return -1;
ctx->objdata = 0;
ctx->objmask = NULL;
ctx->object = out;
if (!out->command)
return -1;
out->command = ctx->curr;
/* For encap/decap we need is pattern */
out->args.vc.pattern = (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
/** Parse set command, initialize output buffer for subsequent tokens. */
static int
parse_set_sample_action(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
/* Make sure buffer is large enough. */
if (size < sizeof(*out))
return -1;
ctx->objdata = 0;
ctx->objmask = NULL;
ctx->object = out;
if (!out->command)
return -1;
out->command = ctx->curr;
/* For sampler we need is actions */
out->args.vc.actions = (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
/**
* Parse set raw_encap/raw_decap command,
* initialize output buffer for subsequent tokens.
*/
static int
parse_set_init(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct buffer *out = buf;
/* Token name must match. */
if (parse_default(ctx, token, str, len, NULL, 0) < 0)
return -1;
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
/* Make sure buffer is large enough. */
if (size < sizeof(*out))
return -1;
/* Initialize buffer. */
memset(out, 0x00, sizeof(*out));
memset((uint8_t *)out + sizeof(*out), 0x22, size - sizeof(*out));
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
if (!out->command) {
if (ctx->curr != SET)
return -1;
if (sizeof(*out) > size)
return -1;
out->command = ctx->curr;
out->args.vc.data = (uint8_t *)out + size;
ctx->object = (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
}
return len;
}
/*
* Replace testpmd handles in a flex flow item with real values.
*/
static int
parse_flex_handle(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
struct rte_flow_item_flex *spec, *mask;
const struct rte_flow_item_flex *src_spec, *src_mask;
const struct arg *arg = pop_args(ctx);
uint32_t offset;
uint16_t handle;
int ret;
if (!arg) {
printf("Bad environment\n");
return -1;
}
offset = arg->offset;
push_args(ctx, arg);
ret = parse_int(ctx, token, str, len, buf, size);
if (ret <= 0 || !ctx->object)
return ret;
if (ctx->port >= RTE_MAX_ETHPORTS) {
printf("Bad port\n");
return -1;
}
if (offset == offsetof(struct rte_flow_item_flex, handle)) {
const struct flex_item *fp;
struct rte_flow_item_flex *item_flex = ctx->object;
handle = (uint16_t)(uintptr_t)item_flex->handle;
if (handle >= FLEX_MAX_PARSERS_NUM) {
printf("Bad flex item handle\n");
return -1;
}
fp = flex_items[ctx->port][handle];
if (!fp) {
printf("Bad flex item handle\n");
return -1;
}
item_flex->handle = fp->flex_handle;
} else if (offset == offsetof(struct rte_flow_item_flex, pattern)) {
handle = (uint16_t)(uintptr_t)
((struct rte_flow_item_flex *)ctx->object)->pattern;
if (handle >= FLEX_MAX_PATTERNS_NUM) {
printf("Bad pattern handle\n");
return -1;
}
src_spec = &flex_patterns[handle].spec;
src_mask = &flex_patterns[handle].mask;
spec = ctx->object;
mask = spec + 2; /* spec, last, mask */
/* fill flow rule spec and mask parameters */
spec->length = src_spec->length;
spec->pattern = src_spec->pattern;
mask->length = src_mask->length;
mask->pattern = src_mask->pattern;
} else {
printf("Bad arguments - unknown flex item offset\n");
return -1;
}
return ret;
}
/** No completion. */
static int
comp_none(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
(void)ctx;
(void)token;
(void)ent;
(void)buf;
(void)size;
return 0;
}
/** Complete boolean values. */
static int
comp_boolean(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i;
(void)ctx;
(void)token;
for (i = 0; boolean_name[i]; ++i)
if (buf && i == ent)
return strlcpy(buf, boolean_name[i], size);
if (buf)
return -1;
return i;
}
/** Complete action names. */
static int
comp_action(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i;
(void)ctx;
(void)token;
for (i = 0; next_action[i]; ++i)
if (buf && i == ent)
return strlcpy(buf, token_list[next_action[i]].name,
size);
if (buf)
return -1;
return i;
}
/** Complete available ports. */
static int
comp_port(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i = 0;
portid_t p;
(void)ctx;
(void)token;
RTE_ETH_FOREACH_DEV(p) {
if (buf && i == ent)
return snprintf(buf, size, "%u", p);
++i;
}
if (buf)
return -1;
return i;
}
/** Complete available rule IDs. */
static int
comp_rule_id(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i = 0;
struct rte_port *port;
struct port_flow *pf;
(void)token;
if (port_id_is_invalid(ctx->port, DISABLED_WARN) ||
ctx->port == (portid_t)RTE_PORT_ALL)
return -1;
port = &ports[ctx->port];
for (pf = port->flow_list; pf != NULL; pf = pf->next) {
if (buf && i == ent)
return snprintf(buf, size, "%u", pf->id);
++i;
}
if (buf)
return -1;
return i;
}
/** Complete type field for RSS action. */
static int
comp_vc_action_rss_type(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i;
(void)ctx;
(void)token;
for (i = 0; rss_type_table[i].str; ++i)
;
if (!buf)
return i + 1;
if (ent < i)
return strlcpy(buf, rss_type_table[ent].str, size);
if (ent == i)
return snprintf(buf, size, "end");
return -1;
}
/** Complete queue field for RSS action. */
static int
comp_vc_action_rss_queue(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
(void)ctx;
(void)token;
if (!buf)
return nb_rxq + 1;
if (ent < nb_rxq)
return snprintf(buf, size, "%u", ent);
if (ent == nb_rxq)
return snprintf(buf, size, "end");
return -1;
}
/** Complete index number for set raw_encap/raw_decap commands. */
static int
comp_set_raw_index(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
uint16_t idx = 0;
uint16_t nb = 0;
RTE_SET_USED(ctx);
RTE_SET_USED(token);
for (idx = 0; idx < RAW_ENCAP_CONFS_MAX_NUM; ++idx) {
if (buf && idx == ent)
return snprintf(buf, size, "%u", idx);
++nb;
}
return nb;
}
/** Complete index number for set raw_encap/raw_decap commands. */
static int
comp_set_sample_index(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
uint16_t idx = 0;
uint16_t nb = 0;
RTE_SET_USED(ctx);
RTE_SET_USED(token);
for (idx = 0; idx < RAW_SAMPLE_CONFS_MAX_NUM; ++idx) {
if (buf && idx == ent)
return snprintf(buf, size, "%u", idx);
++nb;
}
return nb;
}
/** Complete operation for modify_field command. */
static int
comp_set_modify_field_op(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
RTE_SET_USED(ctx);
RTE_SET_USED(token);
if (!buf)
return RTE_DIM(modify_field_ops);
if (ent < RTE_DIM(modify_field_ops) - 1)
return strlcpy(buf, modify_field_ops[ent], size);
return -1;
}
/** Complete field id for modify_field command. */
static int
comp_set_modify_field_id(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
const char *name;
RTE_SET_USED(token);
if (!buf)
return RTE_DIM(modify_field_ids);
if (ent >= RTE_DIM(modify_field_ids) - 1)
return -1;
name = modify_field_ids[ent];
if (ctx->curr == ACTION_MODIFY_FIELD_SRC_TYPE ||
(strcmp(name, "pointer") && strcmp(name, "value")))
return strlcpy(buf, name, size);
return -1;
}
/** Complete available pattern template IDs. */
static int
comp_pattern_template_id(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i = 0;
struct rte_port *port;
struct port_template *pt;
(void)token;
if (port_id_is_invalid(ctx->port, DISABLED_WARN) ||
ctx->port == (portid_t)RTE_PORT_ALL)
return -1;
port = &ports[ctx->port];
for (pt = port->pattern_templ_list; pt != NULL; pt = pt->next) {
if (buf && i == ent)
return snprintf(buf, size, "%u", pt->id);
++i;
}
if (buf)
return -1;
return i;
}
/** Complete available actions template IDs. */
static int
comp_actions_template_id(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i = 0;
struct rte_port *port;
struct port_template *pt;
(void)token;
if (port_id_is_invalid(ctx->port, DISABLED_WARN) ||
ctx->port == (portid_t)RTE_PORT_ALL)
return -1;
port = &ports[ctx->port];
for (pt = port->actions_templ_list; pt != NULL; pt = pt->next) {
if (buf && i == ent)
return snprintf(buf, size, "%u", pt->id);
++i;
}
if (buf)
return -1;
return i;
}
/** Complete available table IDs. */
static int
comp_table_id(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i = 0;
struct rte_port *port;
struct port_table *pt;
(void)token;
if (port_id_is_invalid(ctx->port, DISABLED_WARN) ||
ctx->port == (portid_t)RTE_PORT_ALL)
return -1;
port = &ports[ctx->port];
for (pt = port->table_list; pt != NULL; pt = pt->next) {
if (buf && i == ent)
return snprintf(buf, size, "%u", pt->id);
++i;
}
if (buf)
return -1;
return i;
}
/** Complete available queue IDs. */
static int
comp_queue_id(struct context *ctx, const struct token *token,
unsigned int ent, char *buf, unsigned int size)
{
unsigned int i = 0;
struct rte_port *port;
(void)token;
if (port_id_is_invalid(ctx->port, DISABLED_WARN) ||
ctx->port == (portid_t)RTE_PORT_ALL)
return -1;
port = &ports[ctx->port];
for (i = 0; i < port->queue_nb; i++) {
if (buf && i == ent)
return snprintf(buf, size, "%u", i);
}
if (buf)
return -1;
return i;
}
/** Internal context. */
static struct context cmd_flow_context;
/** Global parser instance (cmdline API). */
cmdline_parse_inst_t cmd_flow;
cmdline_parse_inst_t cmd_set_raw;
/** Initialize context. */
static void
cmd_flow_context_init(struct context *ctx)
{
/* A full memset() is not necessary. */
ctx->curr = ZERO;
ctx->prev = ZERO;
ctx->next_num = 0;
ctx->args_num = 0;
ctx->eol = 0;
ctx->last = 0;
ctx->port = 0;
ctx->objdata = 0;
ctx->object = NULL;
ctx->objmask = NULL;
}
/** Parse a token (cmdline API). */
static int
cmd_flow_parse(cmdline_parse_token_hdr_t *hdr, const char *src, void *result,
unsigned int size)
{
struct context *ctx = &cmd_flow_context;
const struct token *token;
const enum index *list;
int len;
int i;
(void)hdr;
token = &token_list[ctx->curr];
/* Check argument length. */
ctx->eol = 0;
ctx->last = 1;
for (len = 0; src[len]; ++len)
if (src[len] == '#' || isspace(src[len]))
break;
if (!len)
return -1;
/* Last argument and EOL detection. */
for (i = len; src[i]; ++i)
if (src[i] == '#' || src[i] == '\r' || src[i] == '\n')
break;
else if (!isspace(src[i])) {
ctx->last = 0;
break;
}
for (; src[i]; ++i)
if (src[i] == '\r' || src[i] == '\n') {
ctx->eol = 1;
break;
}
/* Initialize context if necessary. */
if (!ctx->next_num) {
if (!token->next)
return 0;
ctx->next[ctx->next_num++] = token->next[0];
}
/* Process argument through candidates. */
ctx->prev = ctx->curr;
list = ctx->next[ctx->next_num - 1];
for (i = 0; list[i]; ++i) {
const struct token *next = &token_list[list[i]];
int tmp;
ctx->curr = list[i];
if (next->call)
tmp = next->call(ctx, next, src, len, result, size);
else
tmp = parse_default(ctx, next, src, len, result, size);
if (tmp == -1 || tmp != len)
continue;
token = next;
break;
}
if (!list[i])
return -1;
--ctx->next_num;
/* Push subsequent tokens if any. */
if (token->next)
for (i = 0; token->next[i]; ++i) {
if (ctx->next_num == RTE_DIM(ctx->next))
return -1;
ctx->next[ctx->next_num++] = token->next[i];
}
/* Push arguments if any. */
if (token->args)
for (i = 0; token->args[i]; ++i) {
if (ctx->args_num == RTE_DIM(ctx->args))
return -1;
ctx->args[ctx->args_num++] = token->args[i];
}
return len;
}
int
flow_parse(const char *src, void *result, unsigned int size,
struct rte_flow_attr **attr,
struct rte_flow_item **pattern, struct rte_flow_action **actions)
{
int ret;
struct context saved_flow_ctx = cmd_flow_context;
cmd_flow_context_init(&cmd_flow_context);
do {
ret = cmd_flow_parse(NULL, src, result, size);
if (ret > 0) {
src += ret;
while (isspace(*src))
src++;
}
} while (ret > 0 && strlen(src));
cmd_flow_context = saved_flow_ctx;
*attr = &((struct buffer *)result)->args.vc.attr;
*pattern = ((struct buffer *)result)->args.vc.pattern;
*actions = ((struct buffer *)result)->args.vc.actions;
return (ret >= 0 && !strlen(src)) ? 0 : -1;
}
/** Return number of completion entries (cmdline API). */
static int
cmd_flow_complete_get_nb(cmdline_parse_token_hdr_t *hdr)
{
struct context *ctx = &cmd_flow_context;
const struct token *token = &token_list[ctx->curr];
const enum index *list;
int i;
(void)hdr;
/* Count number of tokens in current list. */
if (ctx->next_num)
list = ctx->next[ctx->next_num - 1];
else
list = token->next[0];
for (i = 0; list[i]; ++i)
;
if (!i)
return 0;
/*
* If there is a single token, use its completion callback, otherwise
* return the number of entries.
*/
token = &token_list[list[0]];
if (i == 1 && token->comp) {
/* Save index for cmd_flow_get_help(). */
ctx->prev = list[0];
return token->comp(ctx, token, 0, NULL, 0);
}
return i;
}
/** Return a completion entry (cmdline API). */
static int
cmd_flow_complete_get_elt(cmdline_parse_token_hdr_t *hdr, int index,
char *dst, unsigned int size)
{
struct context *ctx = &cmd_flow_context;
const struct token *token = &token_list[ctx->curr];
const enum index *list;
int i;
(void)hdr;
/* Count number of tokens in current list. */
if (ctx->next_num)
list = ctx->next[ctx->next_num - 1];
else
list = token->next[0];
for (i = 0; list[i]; ++i)
;
if (!i)
return -1;
/* If there is a single token, use its completion callback. */
token = &token_list[list[0]];
if (i == 1 && token->comp) {
/* Save index for cmd_flow_get_help(). */
ctx->prev = list[0];
return token->comp(ctx, token, index, dst, size) < 0 ? -1 : 0;
}
/* Otherwise make sure the index is valid and use defaults. */
if (index >= i)
return -1;
token = &token_list[list[index]];
strlcpy(dst, token->name, size);
/* Save index for cmd_flow_get_help(). */
ctx->prev = list[index];
return 0;
}
/** Populate help strings for current token (cmdline API). */
static int
cmd_flow_get_help(cmdline_parse_token_hdr_t *hdr, char *dst, unsigned int size)
{
struct context *ctx = &cmd_flow_context;
const struct token *token = &token_list[ctx->prev];
(void)hdr;
if (!size)
return -1;
/* Set token type and update global help with details. */
strlcpy(dst, (token->type ? token->type : "TOKEN"), size);
if (token->help)
cmd_flow.help_str = token->help;
else
cmd_flow.help_str = token->name;
return 0;
}
/** Token definition template (cmdline API). */
static struct cmdline_token_hdr cmd_flow_token_hdr = {
.ops = &(struct cmdline_token_ops){
.parse = cmd_flow_parse,
.complete_get_nb = cmd_flow_complete_get_nb,
.complete_get_elt = cmd_flow_complete_get_elt,
.get_help = cmd_flow_get_help,
},
.offset = 0,
};
/** Populate the next dynamic token. */
static void
cmd_flow_tok(cmdline_parse_token_hdr_t **hdr,
cmdline_parse_token_hdr_t **hdr_inst)
{
struct context *ctx = &cmd_flow_context;
/* Always reinitialize context before requesting the first token. */
if (!(hdr_inst - cmd_flow.tokens))
cmd_flow_context_init(ctx);
/* Return NULL when no more tokens are expected. */
if (!ctx->next_num && ctx->curr) {
*hdr = NULL;
return;
}
/* Determine if command should end here. */
if (ctx->eol && ctx->last && ctx->next_num) {
const enum index *list = ctx->next[ctx->next_num - 1];
int i;
for (i = 0; list[i]; ++i) {
if (list[i] != END)
continue;
*hdr = NULL;
return;
}
}
*hdr = &cmd_flow_token_hdr;
}
/** Dispatch parsed buffer to function calls. */
static void
cmd_flow_parsed(const struct buffer *in)
{
switch (in->command) {
case INFO:
port_flow_get_info(in->port);
break;
case CONFIGURE:
port_flow_configure(in->port,
&in->args.configure.port_attr,
in->args.configure.nb_queue,
&in->args.configure.queue_attr);
break;
case PATTERN_TEMPLATE_CREATE:
port_flow_pattern_template_create(in->port,
in->args.vc.pat_templ_id,
&((const struct rte_flow_pattern_template_attr) {
.relaxed_matching = in->args.vc.attr.reserved,
.ingress = in->args.vc.attr.ingress,
.egress = in->args.vc.attr.egress,
.transfer = in->args.vc.attr.transfer,
}),
in->args.vc.pattern);
break;
case PATTERN_TEMPLATE_DESTROY:
port_flow_pattern_template_destroy(in->port,
in->args.templ_destroy.template_id_n,
in->args.templ_destroy.template_id);
break;
case ACTIONS_TEMPLATE_CREATE:
port_flow_actions_template_create(in->port,
in->args.vc.act_templ_id,
&((const struct rte_flow_actions_template_attr) {
.ingress = in->args.vc.attr.ingress,
.egress = in->args.vc.attr.egress,
.transfer = in->args.vc.attr.transfer,
}),
in->args.vc.actions,
in->args.vc.masks);
break;
case ACTIONS_TEMPLATE_DESTROY:
port_flow_actions_template_destroy(in->port,
in->args.templ_destroy.template_id_n,
in->args.templ_destroy.template_id);
break;
case TABLE_CREATE:
port_flow_template_table_create(in->port, in->args.table.id,
&in->args.table.attr, in->args.table.pat_templ_id_n,
in->args.table.pat_templ_id, in->args.table.act_templ_id_n,
in->args.table.act_templ_id);
break;
case TABLE_DESTROY:
port_flow_template_table_destroy(in->port,
in->args.table_destroy.table_id_n,
in->args.table_destroy.table_id);
break;
case QUEUE_CREATE:
port_queue_flow_create(in->port, in->queue, in->postpone,
in->args.vc.table_id, in->args.vc.pat_templ_id,
in->args.vc.act_templ_id, in->args.vc.pattern,
in->args.vc.actions);
break;
case QUEUE_DESTROY:
port_queue_flow_destroy(in->port, in->queue, in->postpone,
in->args.destroy.rule_n,
in->args.destroy.rule);
break;
case PUSH:
port_queue_flow_push(in->port, in->queue);
break;
case PULL:
port_queue_flow_pull(in->port, in->queue);
break;
case QUEUE_INDIRECT_ACTION_CREATE:
port_queue_action_handle_create(
in->port, in->queue, in->postpone,
in->args.vc.attr.group,
&((const struct rte_flow_indir_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;
case QUEUE_INDIRECT_ACTION_DESTROY:
port_queue_action_handle_destroy(in->port,
in->queue, in->postpone,
in->args.ia_destroy.action_id_n,
in->args.ia_destroy.action_id);
break;
case QUEUE_INDIRECT_ACTION_UPDATE:
port_queue_action_handle_update(in->port,
in->queue, in->postpone,
in->args.vc.attr.group,
in->args.vc.actions);
break;
case INDIRECT_ACTION_CREATE:
port_action_handle_create(
in->port, in->args.vc.attr.group,
&((const struct rte_flow_indir_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;
case INDIRECT_ACTION_DESTROY:
port_action_handle_destroy(in->port,
in->args.ia_destroy.action_id_n,
in->args.ia_destroy.action_id);
break;
case INDIRECT_ACTION_UPDATE:
port_action_handle_update(in->port, in->args.vc.attr.group,
in->args.vc.actions);
break;
case INDIRECT_ACTION_QUERY:
port_action_handle_query(in->port, in->args.ia.action_id);
break;
case VALIDATE:
port_flow_validate(in->port, &in->args.vc.attr,
in->args.vc.pattern, in->args.vc.actions,
&in->args.vc.tunnel_ops);
break;
case CREATE:
port_flow_create(in->port, &in->args.vc.attr,
in->args.vc.pattern, in->args.vc.actions,
&in->args.vc.tunnel_ops);
break;
case DESTROY:
port_flow_destroy(in->port, in->args.destroy.rule_n,
in->args.destroy.rule);
break;
case FLUSH:
port_flow_flush(in->port);
break;
case DUMP_ONE:
case DUMP_ALL:
port_flow_dump(in->port, in->args.dump.mode,
in->args.dump.rule, in->args.dump.file);
break;
case QUERY:
port_flow_query(in->port, in->args.query.rule,
&in->args.query.action);
break;
case LIST:
port_flow_list(in->port, in->args.list.group_n,
in->args.list.group);
break;
case ISOLATE:
port_flow_isolate(in->port, in->args.isolate.set);
break;
case AGED:
port_flow_aged(in->port, in->args.aged.destroy);
break;
case TUNNEL_CREATE:
port_flow_tunnel_create(in->port, &in->args.vc.tunnel_ops);
break;
case TUNNEL_DESTROY:
port_flow_tunnel_destroy(in->port, in->args.vc.tunnel_ops.id);
break;
case TUNNEL_LIST:
port_flow_tunnel_list(in->port);
break;
case ACTION_POL_G:
port_meter_policy_add(in->port, in->args.policy.policy_id,
in->args.vc.actions);
break;
case FLEX_ITEM_CREATE:
flex_item_create(in->port, in->args.flex.token,
in->args.flex.filename);
break;
case FLEX_ITEM_DESTROY:
flex_item_destroy(in->port, in->args.flex.token);
break;
default:
break;
}
}
/** Token generator and output processing callback (cmdline API). */
static void
cmd_flow_cb(void *arg0, struct cmdline *cl, void *arg2)
{
if (cl == NULL)
cmd_flow_tok(arg0, arg2);
else
cmd_flow_parsed(arg0);
}
/** Global parser instance (cmdline API). */
cmdline_parse_inst_t cmd_flow = {
.f = cmd_flow_cb,
.data = NULL, /**< Unused. */
.help_str = NULL, /**< Updated by cmd_flow_get_help(). */
.tokens = {
NULL,
}, /**< Tokens are returned by cmd_flow_tok(). */
};
/** set cmd facility. Reuse cmd flow's infrastructure as much as possible. */
static void
update_fields(uint8_t *buf, struct rte_flow_item *item, uint16_t next_proto)
{
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_ether_hdr *)buf;
if (next_proto)
eth->ether_type = rte_cpu_to_be_16(next_proto);
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
ipv4 = (struct rte_ipv4_hdr *)buf;
if (!ipv4->version_ihl)
ipv4->version_ihl = RTE_IPV4_VHL_DEF;
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_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->vtc_flow = rte_cpu_to_be_32(ipv6_vtc_flow);
break;
case RTE_FLOW_ITEM_TYPE_VXLAN:
vxlan = (struct rte_vxlan_hdr *)buf;
vxlan->vx_flags = 0x08;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
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;
nvgre->protocol = rte_cpu_to_be_16(0x6558);
nvgre->c_k_s_rsvd0_ver = rte_cpu_to_be_16(0x2000);
break;
default:
break;
}
}
/** Helper of get item's default mask. */
static const void *
flow_item_default_mask(const struct rte_flow_item *item)
{
const void *mask = NULL;
static rte_be32_t gre_key_default_mask = RTE_BE32(UINT32_MAX);
switch (item->type) {
case RTE_FLOW_ITEM_TYPE_ANY:
mask = &rte_flow_item_any_mask;
break;
case RTE_FLOW_ITEM_TYPE_VF:
mask = &rte_flow_item_vf_mask;
break;
case RTE_FLOW_ITEM_TYPE_PORT_ID:
mask = &rte_flow_item_port_id_mask;
break;
case RTE_FLOW_ITEM_TYPE_RAW:
mask = &rte_flow_item_raw_mask;
break;
case RTE_FLOW_ITEM_TYPE_ETH:
mask = &rte_flow_item_eth_mask;
break;
case RTE_FLOW_ITEM_TYPE_VLAN:
mask = &rte_flow_item_vlan_mask;
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
mask = &rte_flow_item_ipv4_mask;
break;
case RTE_FLOW_ITEM_TYPE_IPV6:
mask = &rte_flow_item_ipv6_mask;
break;
case RTE_FLOW_ITEM_TYPE_ICMP:
mask = &rte_flow_item_icmp_mask;
break;
case RTE_FLOW_ITEM_TYPE_UDP:
mask = &rte_flow_item_udp_mask;
break;
case RTE_FLOW_ITEM_TYPE_TCP:
mask = &rte_flow_item_tcp_mask;
break;
case RTE_FLOW_ITEM_TYPE_SCTP:
mask = &rte_flow_item_sctp_mask;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN:
mask = &rte_flow_item_vxlan_mask;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
mask = &rte_flow_item_vxlan_gpe_mask;
break;
case RTE_FLOW_ITEM_TYPE_E_TAG:
mask = &rte_flow_item_e_tag_mask;
break;
case RTE_FLOW_ITEM_TYPE_NVGRE:
mask = &rte_flow_item_nvgre_mask;
break;
case RTE_FLOW_ITEM_TYPE_MPLS:
mask = &rte_flow_item_mpls_mask;
break;
case RTE_FLOW_ITEM_TYPE_GRE:
mask = &rte_flow_item_gre_mask;
break;
case RTE_FLOW_ITEM_TYPE_GRE_KEY:
mask = &gre_key_default_mask;
break;
case RTE_FLOW_ITEM_TYPE_META:
mask = &rte_flow_item_meta_mask;
break;
case RTE_FLOW_ITEM_TYPE_FUZZY:
mask = &rte_flow_item_fuzzy_mask;
break;
case RTE_FLOW_ITEM_TYPE_GTP:
mask = &rte_flow_item_gtp_mask;
break;
case RTE_FLOW_ITEM_TYPE_GTP_PSC:
mask = &rte_flow_item_gtp_psc_mask;
break;
case RTE_FLOW_ITEM_TYPE_GENEVE:
mask = &rte_flow_item_geneve_mask;
break;
case RTE_FLOW_ITEM_TYPE_GENEVE_OPT:
mask = &rte_flow_item_geneve_opt_mask;
break;
case RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID:
mask = &rte_flow_item_pppoe_proto_id_mask;
break;
case RTE_FLOW_ITEM_TYPE_L2TPV3OIP:
mask = &rte_flow_item_l2tpv3oip_mask;
break;
case RTE_FLOW_ITEM_TYPE_ESP:
mask = &rte_flow_item_esp_mask;
break;
case RTE_FLOW_ITEM_TYPE_AH:
mask = &rte_flow_item_ah_mask;
break;
case RTE_FLOW_ITEM_TYPE_PFCP:
mask = &rte_flow_item_pfcp_mask;
break;
case RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR:
case RTE_FLOW_ITEM_TYPE_REPRESENTED_PORT:
mask = &rte_flow_item_ethdev_mask;
break;
case RTE_FLOW_ITEM_TYPE_L2TPV2:
mask = &rte_flow_item_l2tpv2_mask;
break;
case RTE_FLOW_ITEM_TYPE_PPP:
mask = &rte_flow_item_ppp_mask;
break;
default:
break;
}
return mask;
}
/** Dispatch parsed buffer to function calls. */
static void
cmd_set_raw_parsed_sample(const struct buffer *in)
{
uint32_t n = in->args.vc.actions_n;
uint32_t i = 0;
struct rte_flow_action *action = NULL;
struct rte_flow_action *data = NULL;
const struct rte_flow_action_rss *rss = NULL;
size_t size = 0;
uint16_t idx = in->port; /* We borrow port field as index */
uint32_t max_size = sizeof(struct rte_flow_action) *
ACTION_SAMPLE_ACTIONS_NUM;
RTE_ASSERT(in->command == SET_SAMPLE_ACTIONS);
data = (struct rte_flow_action *)&raw_sample_confs[idx].data;
memset(data, 0x00, max_size);
for (; i <= n - 1; i++) {
action = in->args.vc.actions + i;
if (action->type == RTE_FLOW_ACTION_TYPE_END)
break;
switch (action->type) {
case RTE_FLOW_ACTION_TYPE_MARK:
size = sizeof(struct rte_flow_action_mark);
rte_memcpy(&sample_mark[idx],
(const void *)action->conf, size);
action->conf = &sample_mark[idx];
break;
case RTE_FLOW_ACTION_TYPE_COUNT:
size = sizeof(struct rte_flow_action_count);
rte_memcpy(&sample_count[idx],
(const void *)action->conf, size);
action->conf = &sample_count[idx];
break;
case RTE_FLOW_ACTION_TYPE_QUEUE:
size = sizeof(struct rte_flow_action_queue);
rte_memcpy(&sample_queue[idx],
(const void *)action->conf, size);
action->conf = &sample_queue[idx];
break;
case RTE_FLOW_ACTION_TYPE_RSS:
size = sizeof(struct rte_flow_action_rss);
rss = action->conf;
rte_memcpy(&sample_rss_data[idx].conf,
(const void *)rss, size);
if (rss->key_len && rss->key) {
sample_rss_data[idx].conf.key =
sample_rss_data[idx].key;
rte_memcpy((void *)((uintptr_t)
sample_rss_data[idx].conf.key),
(const void *)rss->key,
sizeof(uint8_t) * rss->key_len);
}
if (rss->queue_num && rss->queue) {
sample_rss_data[idx].conf.queue =
sample_rss_data[idx].queue;
rte_memcpy((void *)((uintptr_t)
sample_rss_data[idx].conf.queue),
(const void *)rss->queue,
sizeof(uint16_t) * rss->queue_num);
}
action->conf = &sample_rss_data[idx].conf;
break;
case RTE_FLOW_ACTION_TYPE_RAW_ENCAP:
size = sizeof(struct rte_flow_action_raw_encap);
rte_memcpy(&sample_encap[idx],
(const void *)action->conf, size);
action->conf = &sample_encap[idx];
break;
case RTE_FLOW_ACTION_TYPE_PORT_ID:
size = sizeof(struct rte_flow_action_port_id);
rte_memcpy(&sample_port_id[idx],
(const void *)action->conf, size);
action->conf = &sample_port_id[idx];
break;
case RTE_FLOW_ACTION_TYPE_PF:
break;
case RTE_FLOW_ACTION_TYPE_VF:
size = sizeof(struct rte_flow_action_vf);
rte_memcpy(&sample_vf[idx],
(const void *)action->conf, size);
action->conf = &sample_vf[idx];
break;
case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP:
size = sizeof(struct rte_flow_action_vxlan_encap);
parse_setup_vxlan_encap_data(&sample_vxlan_encap[idx]);
action->conf = &sample_vxlan_encap[idx].conf;
break;
case RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP:
size = sizeof(struct rte_flow_action_nvgre_encap);
parse_setup_nvgre_encap_data(&sample_nvgre_encap[idx]);
action->conf = &sample_nvgre_encap[idx];
break;
default:
fprintf(stderr, "Error - Not supported action\n");
return;
}
rte_memcpy(data, action, sizeof(struct rte_flow_action));
data++;
}
}
/** Dispatch parsed buffer to function calls. */
static void
cmd_set_raw_parsed(const struct buffer *in)
{
uint32_t n = in->args.vc.pattern_n;
int i = 0;
struct rte_flow_item *item = NULL;
size_t size = 0;
uint8_t *data = NULL;
uint8_t *data_tail = NULL;
size_t *total_size = NULL;
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);
RTE_ASSERT(in->command == SET_RAW_ENCAP ||
in->command == SET_RAW_DECAP);
if (in->command == SET_RAW_ENCAP) {
total_size = &raw_encap_confs[idx].size;
data = (uint8_t *)&raw_encap_confs[idx].data;
} else {
total_size = &raw_decap_confs[idx].size;
data = (uint8_t *)&raw_decap_confs[idx].data;
}
*total_size = 0;
memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA);
/* 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;
const struct rte_flow_item_geneve_opt *opt;
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_ether_hdr);
break;
case RTE_FLOW_ITEM_TYPE_VLAN:
size = sizeof(struct rte_vlan_hdr);
proto = RTE_ETHER_TYPE_VLAN;
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
size = sizeof(struct rte_ipv4_hdr);
proto = RTE_ETHER_TYPE_IPV4;
break;
case RTE_FLOW_ITEM_TYPE_IPV6:
size = sizeof(struct rte_ipv6_hdr);
proto = RTE_ETHER_TYPE_IPV6;
break;
case RTE_FLOW_ITEM_TYPE_UDP:
size = sizeof(struct rte_udp_hdr);
proto = 0x11;
break;
case RTE_FLOW_ITEM_TYPE_TCP:
size = sizeof(struct rte_tcp_hdr);
proto = 0x06;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN:
size = sizeof(struct rte_vxlan_hdr);
break;
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
size = sizeof(struct rte_vxlan_gpe_hdr);
break;
case RTE_FLOW_ITEM_TYPE_GRE:
size = sizeof(struct rte_gre_hdr);
proto = 0x2F;
break;
case RTE_FLOW_ITEM_TYPE_GRE_KEY:
size = sizeof(rte_be32_t);
proto = 0x0;
break;
case RTE_FLOW_ITEM_TYPE_MPLS:
size = sizeof(struct rte_mpls_hdr);
proto = 0x0;
break;
case RTE_FLOW_ITEM_TYPE_NVGRE:
size = sizeof(struct rte_flow_item_nvgre);
proto = 0x2F;
break;
case RTE_FLOW_ITEM_TYPE_GENEVE:
size = sizeof(struct rte_geneve_hdr);
break;
case RTE_FLOW_ITEM_TYPE_GENEVE_OPT:
opt = (const struct rte_flow_item_geneve_opt *)
item->spec;
size = offsetof(struct rte_flow_item_geneve_opt,
option_len) + sizeof(uint8_t);
if (opt->option_len && opt->data) {
*total_size += opt->option_len *
sizeof(uint32_t);
rte_memcpy(data_tail - (*total_size),
opt->data,
opt->option_len * sizeof(uint32_t));
}
break;
case RTE_FLOW_ITEM_TYPE_L2TPV3OIP:
size = sizeof(rte_be32_t);
proto = 0x73;
break;
case RTE_FLOW_ITEM_TYPE_ESP:
size = sizeof(struct rte_esp_hdr);
proto = 0x32;
break;
case RTE_FLOW_ITEM_TYPE_AH:
size = sizeof(struct rte_flow_item_ah);
proto = 0x33;
break;
case RTE_FLOW_ITEM_TYPE_GTP:
if (gtp_psc < 0) {
size = sizeof(struct rte_gtp_hdr);
break;
}
if (gtp_psc != i + 1) {
fprintf(stderr,
"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. */
fprintf(stderr,
"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) {
fprintf(stderr,
"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:4;
uint8_t qfi:6;
uint8_t next;
} psc;
psc.len = sizeof(psc) / 4;
psc.pdu_type = opt->hdr.type;
psc.qfi = opt->hdr.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;
case RTE_FLOW_ITEM_TYPE_FLEX:
size = item->spec ?
((const struct rte_flow_item_flex *)
item->spec)->length : 0;
break;
case RTE_FLOW_ITEM_TYPE_GRE_OPTION:
size = 0;
if (item->spec) {
const struct rte_flow_item_gre_opt
*opt = item->spec;
if (opt->checksum_rsvd.checksum) {
*total_size +=
sizeof(opt->checksum_rsvd);
rte_memcpy(data_tail - (*total_size),
&opt->checksum_rsvd,
sizeof(opt->checksum_rsvd));
}
if (opt->key.key) {
*total_size += sizeof(opt->key.key);
rte_memcpy(data_tail - (*total_size),
&opt->key.key,
sizeof(opt->key.key));
}
if (opt->sequence.sequence) {
*total_size += sizeof(opt->sequence.sequence);
rte_memcpy(data_tail - (*total_size),
&opt->sequence.sequence,
sizeof(opt->sequence.sequence));
}
}
proto = 0x2F;
break;
default:
fprintf(stderr, "Error - Not supported item\n");
goto error;
}
*total_size += size;
rte_memcpy(data_tail - (*total_size), item->spec, size);
/* update some fields which cannot be set by cmdline */
update_fields((data_tail - (*total_size)), item,
upper_layer);
upper_layer = proto;
}
if (verbose_level & 0x1)
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). */
static int
cmd_set_raw_get_help(cmdline_parse_token_hdr_t *hdr, char *dst,
unsigned int size)
{
struct context *ctx = &cmd_flow_context;
const struct token *token = &token_list[ctx->prev];
(void)hdr;
if (!size)
return -1;
/* Set token type and update global help with details. */
snprintf(dst, size, "%s", (token->type ? token->type : "TOKEN"));
if (token->help)
cmd_set_raw.help_str = token->help;
else
cmd_set_raw.help_str = token->name;
return 0;
}
/** Token definition template (cmdline API). */
static struct cmdline_token_hdr cmd_set_raw_token_hdr = {
.ops = &(struct cmdline_token_ops){
.parse = cmd_flow_parse,
.complete_get_nb = cmd_flow_complete_get_nb,
.complete_get_elt = cmd_flow_complete_get_elt,
.get_help = cmd_set_raw_get_help,
},
.offset = 0,
};
/** Populate the next dynamic token. */
static void
cmd_set_raw_tok(cmdline_parse_token_hdr_t **hdr,
cmdline_parse_token_hdr_t **hdr_inst)
{
struct context *ctx = &cmd_flow_context;
/* Always reinitialize context before requesting the first token. */
if (!(hdr_inst - cmd_set_raw.tokens)) {
cmd_flow_context_init(ctx);
ctx->curr = START_SET;
}
/* Return NULL when no more tokens are expected. */
if (!ctx->next_num && (ctx->curr != START_SET)) {
*hdr = NULL;
return;
}
/* Determine if command should end here. */
if (ctx->eol && ctx->last && ctx->next_num) {
const enum index *list = ctx->next[ctx->next_num - 1];
int i;
for (i = 0; list[i]; ++i) {
if (list[i] != END)
continue;
*hdr = NULL;
return;
}
}
*hdr = &cmd_set_raw_token_hdr;
}
/** Token generator and output processing callback (cmdline API). */
static void
cmd_set_raw_cb(void *arg0, struct cmdline *cl, void *arg2)
{
if (cl == NULL)
cmd_set_raw_tok(arg0, arg2);
else
cmd_set_raw_parsed(arg0);
}
/** Global parser instance (cmdline API). */
cmdline_parse_inst_t cmd_set_raw = {
.f = cmd_set_raw_cb,
.data = NULL, /**< Unused. */
.help_str = NULL, /**< Updated by cmd_flow_get_help(). */
.tokens = {
NULL,
}, /**< Tokens are returned by cmd_flow_tok(). */
};
/* *** display raw_encap/raw_decap buf */
struct cmd_show_set_raw_result {
cmdline_fixed_string_t cmd_show;
cmdline_fixed_string_t cmd_what;
cmdline_fixed_string_t cmd_all;
uint16_t cmd_index;
};
static void
cmd_show_set_raw_parsed(void *parsed_result, struct cmdline *cl, void *data)
{
struct cmd_show_set_raw_result *res = parsed_result;
uint16_t index = res->cmd_index;
uint8_t all = 0;
uint8_t *raw_data = NULL;
size_t raw_size = 0;
char title[16] = {0};
RTE_SET_USED(cl);
RTE_SET_USED(data);
if (!strcmp(res->cmd_all, "all")) {
all = 1;
index = 0;
} else if (index >= RAW_ENCAP_CONFS_MAX_NUM) {
fprintf(stderr, "index should be 0-%u\n",
RAW_ENCAP_CONFS_MAX_NUM - 1);
return;
}
do {
if (!strcmp(res->cmd_what, "raw_encap")) {
raw_data = (uint8_t *)&raw_encap_confs[index].data;
raw_size = raw_encap_confs[index].size;
snprintf(title, 16, "\nindex: %u", index);
rte_hexdump(stdout, title, raw_data, raw_size);
} else {
raw_data = (uint8_t *)&raw_decap_confs[index].data;
raw_size = raw_decap_confs[index].size;
snprintf(title, 16, "\nindex: %u", index);
rte_hexdump(stdout, title, raw_data, raw_size);
}
} while (all && ++index < RAW_ENCAP_CONFS_MAX_NUM);
}
static cmdline_parse_token_string_t cmd_show_set_raw_cmd_show =
TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result,
cmd_show, "show");
static cmdline_parse_token_string_t cmd_show_set_raw_cmd_what =
TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result,
cmd_what, "raw_encap#raw_decap");
static cmdline_parse_token_num_t cmd_show_set_raw_cmd_index =
TOKEN_NUM_INITIALIZER(struct cmd_show_set_raw_result,
cmd_index, RTE_UINT16);
static cmdline_parse_token_string_t cmd_show_set_raw_cmd_all =
TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result,
cmd_all, "all");
cmdline_parse_inst_t cmd_show_set_raw = {
.f = cmd_show_set_raw_parsed,
.data = NULL,
.help_str = "show <raw_encap|raw_decap> <index>",
.tokens = {
(void *)&cmd_show_set_raw_cmd_show,
(void *)&cmd_show_set_raw_cmd_what,
(void *)&cmd_show_set_raw_cmd_index,
NULL,
},
};
cmdline_parse_inst_t cmd_show_set_raw_all = {
.f = cmd_show_set_raw_parsed,
.data = NULL,
.help_str = "show <raw_encap|raw_decap> all",
.tokens = {
(void *)&cmd_show_set_raw_cmd_show,
(void *)&cmd_show_set_raw_cmd_what,
(void *)&cmd_show_set_raw_cmd_all,
NULL,
},
};
Reference in New Issue View Git Blame Copy Permalink