/* 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 <arpa/inet.h>
#include <sys/socket.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 <rte_flow.h>
#include "testpmd.h"
/** Parser token indices. */
enum index {
/* Special tokens. */
ZERO = 0,
END,
START_SET,
END_SET,
/* Common tokens. */
INTEGER,
UNSIGNED,
PREFIX,
BOOLEAN,
STRING,
HEX,
MAC_ADDR,
IPV4_ADDR,
IPV6_ADDR,
RULE_ID,
PORT_ID,
GROUP_ID,
PRIORITY_LEVEL,
/* Top-level command. */
SET,
/* Sub-leve commands. */
SET_RAW_ENCAP,
SET_RAW_DECAP,
/* Top-level command. */
FLOW,
/* Sub-level commands. */
VALIDATE,
CREATE,
DESTROY,
FLUSH,
QUERY,
LIST,
ISOLATE,
/* Destroy arguments. */
DESTROY_RULE,
/* Query arguments. */
QUERY_ACTION,
/* List arguments. */
LIST_GROUP,
/* Validate/create arguments. */
GROUP,
PRIORITY,
INGRESS,
EGRESS,
TRANSFER,
/* Validate/create pattern. */
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_ETH,
ITEM_ETH_DST,
ITEM_ETH_SRC,
ITEM_ETH_TYPE,
ITEM_VLAN,
ITEM_VLAN_TCI,
ITEM_VLAN_PCP,
ITEM_VLAN_DEI,
ITEM_VLAN_VID,
ITEM_VLAN_INNER_TYPE,
ITEM_IPV4,
ITEM_IPV4_TOS,
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_ICMP,
ITEM_ICMP_TYPE,
ITEM_ICMP_CODE,
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_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_TEID,
ITEM_GTPC,
ITEM_GTPU,
ITEM_GENEVE,
ITEM_GENEVE_VNI,
ITEM_GENEVE_PROTO,
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_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,
/* 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_SHARED,
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_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_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,
};
/** Maximum size for pattern in struct rte_flow_item_raw. */
#define ITEM_RAW_PATTERN_SIZE 40
/** 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 number of queue indices in struct rte_flow_action_rss. */
#define ACTION_RSS_QUEUE_NUM 32
/** 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 number of items in struct rte_flow_action_vxlan_encap. */
#define ACTION_VXLAN_ENCAP_ITEMS_NUM 6
#define ACTION_RAW_ENCAP_MAX_DATA 128
/** 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_conf = {.size = 0};
/** 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_conf = {.size = 0};
/** 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;
};
/** 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;
};
/** Maximum data size in struct rte_flow_action_raw_encap. */
#define ACTION_RAW_ENCAP_MAX_DATA 128
/** 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];
};
/** 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];
};
/** 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 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. */
union {
struct {
struct rte_flow_attr attr;
struct rte_flow_item *pattern;
struct rte_flow_action *actions;
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 {
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. */
} 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_vc_attr[] = {
GROUP,
PRIORITY,
INGRESS,
EGRESS,
TRANSFER,
PATTERN,
ZERO,
};
static const enum index next_destroy_attr[] = {
DESTROY_RULE,
END,
ZERO,
};
static const enum index next_list_attr[] = {
LIST_GROUP,
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_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,
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_NEXT,
ZERO,
};
static const enum index item_eth[] = {
ITEM_ETH_DST,
ITEM_ETH_SRC,
ITEM_ETH_TYPE,
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_NEXT,
ZERO,
};
static const enum index item_ipv4[] = {
ITEM_IPV4_TOS,
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_NEXT,
ZERO,
};
static const enum index item_icmp[] = {
ITEM_ICMP_TYPE,
ITEM_ICMP_CODE,
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_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_gtp[] = {
ITEM_GTP_TEID,
ITEM_NEXT,
ZERO,
};
static const enum index item_geneve[] = {
ITEM_GENEVE_VNI,
ITEM_GENEVE_PROTO,
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_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 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_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,
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_COUNT_SHARED,
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_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 int parse_set_raw_encap_decap(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_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_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_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_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_isolate(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_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 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);
/** 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)),
},
[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. */
[INTEGER] = {
.name = "{int}",
.type = "INTEGER",
.help = "integer value",
.call = parse_int,
.comp = comp_none,
},
[UNSIGNED] = {
.name = "{unsigned}",
.type = "UNSIGNED",
.help = "unsigned integer value",
.call = parse_int,
.comp = comp_none,
},
[PREFIX] = {
.name = "{prefix}",
.type = "PREFIX",
.help = "prefix length for bit-mask",
.call = parse_prefix,
.comp = comp_none,
},
[BOOLEAN] = {
.name = "{boolean}",
.type = "BOOLEAN",
.help = "any boolean value",
.call = parse_boolean,
.comp = comp_boolean,
},
[STRING] = {
.name = "{string}",
.type = "STRING",
.help = "fixed string",
.call = parse_string,
.comp = comp_none,
},
[HEX] = {
.name = "{hex}",
.type = "HEX",
.help = "fixed string",
.call = parse_hex,
.comp = comp_none,
},
[MAC_ADDR] = {
.name = "{MAC address}",
.type = "MAC-48",
.help = "standard MAC address notation",
.call = parse_mac_addr,
.comp = comp_none,
},
[IPV4_ADDR] = {
.name = "{IPv4 address}",
.type = "IPV4 ADDRESS",
.help = "standard IPv4 address notation",
.call = parse_ipv4_addr,
.comp = comp_none,
},
[IPV6_ADDR] = {
.name = "{IPv6 address}",
.type = "IPV6 ADDRESS",
.help = "standard IPv6 address notation",
.call = parse_ipv6_addr,
.comp = comp_none,
},
[RULE_ID] = {
.name = "{rule id}",
.type = "RULE ID",
.help = "rule identifier",
.call = parse_int,
.comp = comp_rule_id,
},
[PORT_ID] = {
.name = "{port_id}",
.type = "PORT ID",
.help = "port identifier",
.call = parse_port,
.comp = comp_port,
},
[GROUP_ID] = {
.name = "{group_id}",
.type = "GROUP ID",
.help = "group identifier",
.call = parse_int,
.comp = comp_none,
},
[PRIORITY_LEVEL] = {
.name = "{level}",
.type = "PRIORITY",
.help = "priority level",
.call = parse_int,
.comp = comp_none,
},
/* Top-level command. */
[FLOW] = {
.name = "flow",
.type = "{command} {port_id} [{arg} [...]]",
.help = "manage ingress/egress flow rules",
.next = NEXT(NEXT_ENTRY
(VALIDATE,
CREATE,
DESTROY,
FLUSH,
LIST,
QUERY,
ISOLATE)),
.call = parse_init,
},
/* Sub-level commands. */
[VALIDATE] = {
.name = "validate",
.help = "check whether a flow rule can be created",
.next = NEXT(next_vc_attr, NEXT_ENTRY(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(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(PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_destroy,
},
[FLUSH] = {
.name = "flush",
.help = "destroy all flow rules",
.next = NEXT(NEXT_ENTRY(PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_flush,
},
[QUERY] = {
.name = "query",
.help = "query an existing flow rule",
.next = NEXT(NEXT_ENTRY(QUERY_ACTION),
NEXT_ENTRY(RULE_ID),
NEXT_ENTRY(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(PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_list,
},
[ISOLATE] = {
.name = "isolate",
.help = "restrict ingress traffic to the defined flow rules",
.next = NEXT(NEXT_ENTRY(BOOLEAN),
NEXT_ENTRY(PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, args.isolate.set),
ARGS_ENTRY(struct buffer, port)),
.call = parse_isolate,
},
/* Destroy arguments. */
[DESTROY_RULE] = {
.name = "rule",
.help = "specify a rule identifier",
.next = NEXT(next_destroy_attr, NEXT_ENTRY(RULE_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.destroy.rule)),
.call = parse_destroy,
},
/* 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(GROUP_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.list.group)),
.call = parse_list,
},
/* Validate/create attributes. */
[GROUP] = {
.name = "group",
.help = "specify a group",
.next = NEXT(next_vc_attr, NEXT_ENTRY(GROUP_ID)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, group)),
.call = parse_vc,
},
[PRIORITY] = {
.name = "priority",
.help = "specify a priority level",
.next = NEXT(next_vc_attr, NEXT_ENTRY(PRIORITY_LEVEL)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, priority)),
.call = parse_vc,
},
[INGRESS] = {
.name = "ingress",
.help = "affect rule to ingress",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
[EGRESS] = {
.name = "egress",
.help = "affect rule to egress",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
[TRANSFER] = {
.name = "transfer",
.help = "apply rule directly to endpoints found in pattern",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
/* Validate/create pattern. */
[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)),
.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(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(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(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(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(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(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(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(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(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(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_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(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(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(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, type)),
},
[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(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(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(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(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(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan,
inner_type)),
},
[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_TOS] = {
.name = "tos",
.help = "type of service",
.next = NEXT(item_ipv4, NEXT_ENTRY(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
hdr.type_of_service)),
},
[ITEM_IPV4_TTL] = {
.name = "ttl",
.help = "time to live",
.next = NEXT(item_ipv4, NEXT_ENTRY(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(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(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(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(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(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(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(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(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(IPV6_ADDR), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
hdr.dst_addr)),
},
[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(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(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
hdr.icmp_code)),
},
[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(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(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(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(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(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(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(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(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(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(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan, vni)),
},
[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(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(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(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(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(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(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(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(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(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(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(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_TEID] = {
.name = "teid",
.help = "tunnel endpoint identifier",
.next = NEXT(item_gtp, NEXT_ENTRY(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(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(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_geneve,
protocol)),
},
[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(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(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(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(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(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(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6_ext,
next_hdr)),
},
[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(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(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(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(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(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(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(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(UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_MASK_HTON(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(UNSIGNED), item_param),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
},
/* 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(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(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(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(UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_count, id)),
.call = parse_vc_conf,
},
[ACTION_COUNT_SHARED] = {
.name = "shared",
.help = "shared counter",
.next = NEXT(action_count, NEXT_ENTRY(BOOLEAN)),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_count,
shared, 1)),
.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_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_LEVEL] = {
.name = "level",
.help = "encapsulation level for \"types\"",
.next = NEXT(action_rss, NEXT_ENTRY(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(HEX)),
.args = ARGS(ARGS_ENTRY_ARB(0, 0),
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(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(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(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(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(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(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(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_ID] = {
.name = "mtr_id",
.help = "meter id to use",
.next = NEXT(action_meter, NEXT_ENTRY(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 rte_flow_action_raw_encap)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_raw_encap,
},
[ACTION_RAW_DECAP] = {
.name = "raw_decap",
.help = "decapsulation data, defined by set raw_encap",
.priv = PRIV_ACTION(RAW_DECAP,
sizeof(struct rte_flow_action_raw_decap)),
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_raw_decap,
},
/* Top level command. */
[SET] = {
.