#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_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"
END_SET,
/* Common tokens. */
- INTEGER,
- UNSIGNED,
- PREFIX,
- BOOLEAN,
- STRING,
- HEX,
- FILE_PATH,
- MAC_ADDR,
- IPV4_ADDR,
- IPV6_ADDR,
- RULE_ID,
- PORT_ID,
- GROUP_ID,
- PRIORITY_LEVEL,
- SHARED_ACTION_ID,
+ 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,
+
+ /* TOP-level command. */
+ ADD,
/* Top-level command. */
SET,
/* Top-level command. */
FLOW,
/* Sub-level commands. */
- SHARED_ACTION,
+ INDIRECT_ACTION,
VALIDATE,
CREATE,
DESTROY,
LIST,
AGED,
ISOLATE,
+ TUNNEL,
+
+ /* Tunnel arguments. */
+ TUNNEL_CREATE,
+ TUNNEL_CREATE_TYPE,
+ TUNNEL_LIST,
+ TUNNEL_DESTROY,
+ TUNNEL_DESTROY_ID,
/* Destroy arguments. */
DESTROY_RULE,
AGED_DESTROY,
/* Validate/create arguments. */
- GROUP,
- PRIORITY,
- INGRESS,
- EGRESS,
- TRANSFER,
-
- /* Shared action arguments */
- SHARED_ACTION_CREATE,
- SHARED_ACTION_UPDATE,
- SHARED_ACTION_DESTROY,
- SHARED_ACTION_QUERY,
-
- /* Shared action create arguments */
- SHARED_ACTION_CREATE_ID,
- SHARED_ACTION_INGRESS,
- SHARED_ACTION_EGRESS,
- SHARED_ACTION_SPEC,
-
- /* Shared action destroy arguments */
- SHARED_ACTION_DESTROY_ID,
+ VC_GROUP,
+ VC_PRIORITY,
+ VC_INGRESS,
+ VC_EGRESS,
+ VC_TRANSFER,
+ VC_TUNNEL_SET,
+ VC_TUNNEL_MATCH,
+
+ /* Dump arguments */
+ DUMP_ALL,
+ DUMP_ONE,
+
+ /* 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. */
- PATTERN,
+ ITEM_PATTERN,
ITEM_PARAM_IS,
ITEM_PARAM_SPEC,
ITEM_PARAM_LAST,
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_SCTP_CKSUM,
ITEM_VXLAN,
ITEM_VXLAN_VNI,
+ ITEM_VXLAN_LAST_RSVD,
ITEM_E_TAG,
ITEM_E_TAG_GRP_ECID_B,
ITEM_NVGRE,
ITEM_GENEVE,
ITEM_GENEVE_VNI,
ITEM_GENEVE_PROTO,
+ ITEM_GENEVE_OPTLEN,
ITEM_VXLAN_GPE,
ITEM_VXLAN_GPE_VNI,
ITEM_ARP_ETH_IPV4,
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_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,
/* Validate/create actions. */
ACTIONS,
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_SAMPLE_RATIO,
ACTION_SAMPLE_INDEX,
ACTION_SAMPLE_INDEX_VALUE,
- ACTION_SHARED,
- SHARED_ACTION_ID2PTR,
+ 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_WIDTH,
+ ACTION_CONNTRACK,
+ ACTION_CONNTRACK_UPDATE,
+ ACTION_CONNTRACK_UPDATE_DIR,
+ ACTION_CONNTRACK_UPDATE_CTX,
+ ACTION_POL_G,
+ ACTION_POL_Y,
+ ACTION_POL_R,
};
/** Maximum size for pattern in struct rte_flow_item_raw. */
#define ITEM_RAW_PATTERN_SIZE 40
+/** 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 data size in struct rte_flow_action_raw_encap. */
-#define ACTION_RAW_ENCAP_MAX_DATA 128
+#define ACTION_RAW_ENCAP_MAX_DATA 512
#define RAW_ENCAP_CONFS_MAX_NUM 8
/** Storage for struct rte_flow_action_raw_encap. */
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 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", NULL
+};
/** Maximum number of subsequent tokens and arguments on the stack. */
#define CTX_STACK_SIZE 16
.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){ \
struct {
uint32_t *action_id;
uint32_t action_id_n;
- } sa_destroy; /**< Shared action destroy arguments. */
+ } ia_destroy; /**< Indirect action destroy arguments. */
struct {
uint32_t action_id;
- } sa; /* Shared action query arguments */
+ } ia; /* Indirect action query arguments */
struct {
struct rte_flow_attr attr;
+ struct tunnel_ops tunnel_ops;
struct rte_flow_item *pattern;
struct rte_flow_action *actions;
uint32_t pattern_n;
} destroy; /**< Destroy arguments. */
struct {
char file[128];
+ bool mode;
+ uint32_t rule;
} dump; /**< Dump arguments. */
struct {
uint32_t rule;
struct {
int destroy;
} aged; /**< Aged arguments. */
+ struct {
+ uint32_t policy_id;
+ } policy;/**< Policy arguments. */
} args; /**< Command arguments. */
};
.size = s, \
})
-static const enum index next_sa_create_attr[] = {
- SHARED_ACTION_CREATE_ID,
- SHARED_ACTION_INGRESS,
- SHARED_ACTION_EGRESS,
- SHARED_ACTION_SPEC,
+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_sa_subcmd[] = {
- SHARED_ACTION_CREATE,
- SHARED_ACTION_UPDATE,
- SHARED_ACTION_DESTROY,
- SHARED_ACTION_QUERY,
+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[] = {
- GROUP,
- PRIORITY,
- INGRESS,
- EGRESS,
- TRANSFER,
- PATTERN,
+ VC_GROUP,
+ VC_PRIORITY,
+ VC_INGRESS,
+ VC_EGRESS,
+ VC_TRANSFER,
+ VC_TUNNEL_SET,
+ VC_TUNNEL_MATCH,
+ ITEM_PATTERN,
ZERO,
};
};
static const enum index next_dump_attr[] = {
- FILE_PATH,
+ COMMON_FILE_PATH,
END,
ZERO,
};
ZERO,
};
-static const enum index next_sa_destroy_attr[] = {
- SHARED_ACTION_DESTROY_ID,
+static const enum index next_ia_destroy_attr[] = {
+ INDIRECT_ACTION_DESTROY_ID,
END,
ZERO,
};
ITEM_AH,
ITEM_PFCP,
ITEM_ECPRI,
+ ITEM_GENEVE_OPT,
+ ITEM_INTEGRITY,
+ ITEM_CONNTRACK,
END_SET,
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,
static const enum index item_vxlan[] = {
ITEM_VXLAN_VNI,
+ ITEM_VXLAN_LAST_RSVD,
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_ipv6_frag_ext[] = {
ITEM_IPV6_FRAG_EXT_NEXT_HDR,
ITEM_IPV6_FRAG_EXT_FRAG_DATA,
+ ITEM_IPV6_FRAG_EXT_ID,
ITEM_NEXT,
ZERO,
};
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 next_action[] = {
ACTION_END,
ACTION_VOID,
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_SET_IPV6_DSCP,
ACTION_AGE,
ACTION_SAMPLE,
- ACTION_SHARED,
+ ACTION_INDIRECT,
+ ACTION_MODIFY_FIELD,
+ ACTION_CONNTRACK,
+ ACTION_CONNTRACK_UPDATE,
ZERO,
};
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,
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_WIDTH,
+ ZERO,
+};
+
+static const enum index action_update_conntrack[] = {
+ ACTION_CONNTRACK_UPDATE_DIR,
+ ACTION_CONNTRACK_UPDATE_CTX,
ACTION_NEXT,
ZERO,
};
static int parse_vc_item_ecpri_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);
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_isolate(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_int(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_sa(struct context *, const struct token *,
+static int parse_ia(struct context *, const struct token *,
const char *, unsigned int,
void *, unsigned int);
-static int parse_sa_destroy(struct context *ctx, const struct token *token,
+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_sa_id2ptr(struct context *ctx, const struct token *token,
+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_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);
/** Token definitions. */
static const struct token token_list[] = {
[ZERO] = {
.name = "ZERO",
.help = "null entry, abused as the entry point",
- .next = NEXT(NEXT_ENTRY(FLOW)),
+ .next = NEXT(NEXT_ENTRY(FLOW, ADD)),
},
[END] = {
.name = "",
.help = "set command may end here",
},
/* Common tokens. */
- [INTEGER] = {
+ [COMMON_INTEGER] = {
.name = "{int}",
.type = "INTEGER",
.help = "integer value",
.call = parse_int,
.comp = comp_none,
},
- [UNSIGNED] = {
+ [COMMON_UNSIGNED] = {
.name = "{unsigned}",
.type = "UNSIGNED",
.help = "unsigned integer value",
.call = parse_int,
.comp = comp_none,
},
- [PREFIX] = {
+ [COMMON_PREFIX] = {
.name = "{prefix}",
.type = "PREFIX",
.help = "prefix length for bit-mask",
.call = parse_prefix,
.comp = comp_none,
},
- [BOOLEAN] = {
+ [COMMON_BOOLEAN] = {
.name = "{boolean}",
.type = "BOOLEAN",
.help = "any boolean value",
.call = parse_boolean,
.comp = comp_boolean,
},
- [STRING] = {
+ [COMMON_STRING] = {
.name = "{string}",
.type = "STRING",
.help = "fixed string",
.call = parse_string,
.comp = comp_none,
},
- [HEX] = {
+ [COMMON_HEX] = {
.name = "{hex}",
.type = "HEX",
.help = "fixed string",
.call = parse_hex,
},
- [FILE_PATH] = {
+ [COMMON_FILE_PATH] = {
.name = "{file path}",
.type = "STRING",
.help = "file path",
.call = parse_string0,
.comp = comp_none,
},
- [MAC_ADDR] = {
+ [COMMON_MAC_ADDR] = {
.name = "{MAC address}",
.type = "MAC-48",
.help = "standard MAC address notation",
.call = parse_mac_addr,
.comp = comp_none,
},
- [IPV4_ADDR] = {
+ [COMMON_IPV4_ADDR] = {
.name = "{IPv4 address}",
.type = "IPV4 ADDRESS",
.help = "standard IPv4 address notation",
.call = parse_ipv4_addr,
.comp = comp_none,
},
- [IPV6_ADDR] = {
+ [COMMON_IPV6_ADDR] = {
.name = "{IPv6 address}",
.type = "IPV6 ADDRESS",
.help = "standard IPv6 address notation",
.call = parse_ipv6_addr,
.comp = comp_none,
},
- [RULE_ID] = {
+ [COMMON_RULE_ID] = {
.name = "{rule id}",
.type = "RULE ID",
.help = "rule identifier",
.call = parse_int,
.comp = comp_rule_id,
},
- [PORT_ID] = {
+ [COMMON_PORT_ID] = {
.name = "{port_id}",
.type = "PORT ID",
.help = "port identifier",
.call = parse_port,
.comp = comp_port,
},
- [GROUP_ID] = {
+ [COMMON_GROUP_ID] = {
.name = "{group_id}",
.type = "GROUP ID",
.help = "group identifier",
.call = parse_int,
.comp = comp_none,
},
- [PRIORITY_LEVEL] = {
+ [COMMON_PRIORITY_LEVEL] = {
.name = "{level}",
.type = "PRIORITY",
.help = "priority level",
.call = parse_int,
.comp = comp_none,
},
- [SHARED_ACTION_ID] = {
- .name = "{shared_action_id}",
- .type = "SHARED_ACTION_ID",
- .help = "shared action id",
+ [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 = "POLCIY_ID",
+ .help = "policy id",
.call = parse_int,
.comp = comp_none,
},
.type = "{command} {port_id} [{arg} [...]]",
.help = "manage ingress/egress flow rules",
.next = NEXT(NEXT_ENTRY
- (SHARED_ACTION,
+ (INDIRECT_ACTION,
VALIDATE,
CREATE,
DESTROY,
LIST,
AGED,
QUERY,
- ISOLATE)),
+ ISOLATE,
+ TUNNEL)),
.call = parse_init,
},
/* Top-level command. */
- [SHARED_ACTION] = {
- .name = "shared_action",
+ [INDIRECT_ACTION] = {
+ .name = "indirect_action",
.type = "{command} {port_id} [{arg} [...]]",
- .help = "manage shared actions",
- .next = NEXT(next_sa_subcmd, NEXT_ENTRY(PORT_ID)),
+ .help = "manage indirect actions",
+ .next = NEXT(next_ia_subcmd, NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
- .call = parse_sa,
+ .call = parse_ia,
},
/* Sub-level commands. */
- [SHARED_ACTION_CREATE] = {
+ [INDIRECT_ACTION_CREATE] = {
.name = "create",
- .help = "create shared action",
- .next = NEXT(next_sa_create_attr),
- .call = parse_sa,
+ .help = "create indirect action",
+ .next = NEXT(next_ia_create_attr),
+ .call = parse_ia,
},
- [SHARED_ACTION_UPDATE] = {
+ [INDIRECT_ACTION_UPDATE] = {
.name = "update",
- .help = "update shared action",
- .next = NEXT(NEXT_ENTRY(SHARED_ACTION_SPEC),
- NEXT_ENTRY(SHARED_ACTION_ID)),
+ .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_sa,
+ .call = parse_ia,
},
- [SHARED_ACTION_DESTROY] = {
+ [INDIRECT_ACTION_DESTROY] = {
.name = "destroy",
- .help = "destroy shared action",
- .next = NEXT(NEXT_ENTRY(SHARED_ACTION_DESTROY_ID)),
+ .help = "destroy indirect action",
+ .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_DESTROY_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
- .call = parse_sa_destroy,
+ .call = parse_ia_destroy,
},
- [SHARED_ACTION_QUERY] = {
+ [INDIRECT_ACTION_QUERY] = {
.name = "query",
- .help = "query shared action",
- .next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(SHARED_ACTION_ID)),
- .args = ARGS(ARGS_ENTRY(struct buffer, args.sa.action_id)),
- .call = parse_sa,
+ .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(PORT_ID)),
+ .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(PORT_ID)),
+ .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(PORT_ID)),
+ .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(PORT_ID)),
+ .next = NEXT(NEXT_ENTRY(COMMON_PORT_ID)),
.args = ARGS(ARGS_ENTRY(struct buffer, port)),
.call = parse_flush,
},
[DUMP] = {
.name = "dump",
- .help = "dump all flow rules to file",
- .next = NEXT(next_dump_attr, NEXT_ENTRY(PORT_ID)),
- .args = ARGS(ARGS_ENTRY(struct buffer, args.dump.file),
- ARGS_ENTRY(struct buffer, port)),
+ .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(RULE_ID),
- NEXT_ENTRY(PORT_ID)),
+ 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)),
[LIST] = {
.name = "list",
.help = "list existing flow rules",
- .next = NEXT(next_list_attr, NEXT_ENTRY(PORT_ID)),
+ .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(PORT_ID)),
+ .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(BOOLEAN),
- NEXT_ENTRY(PORT_ID)),
+ .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,
},
+ [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 tunel",
+ .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 testroy",
+ .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(RULE_ID)),
+ .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}",
[LIST_GROUP] = {
.name = "group",
.help = "specify a group",
- .next = NEXT(next_list_attr, NEXT_ENTRY(GROUP_ID)),
+ .next = NEXT(next_list_attr, NEXT_ENTRY(COMMON_GROUP_ID)),
.args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.list.group)),
.call = parse_list,
},
.comp = comp_none,
},
/* Validate/create attributes. */
- [GROUP] = {
+ [VC_GROUP] = {
.name = "group",
.help = "specify a group",
- .next = NEXT(next_vc_attr, NEXT_ENTRY(GROUP_ID)),
+ .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_GROUP_ID)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, group)),
.call = parse_vc,
},
- [PRIORITY] = {
+ [VC_PRIORITY] = {
.name = "priority",
.help = "specify a priority level",
- .next = NEXT(next_vc_attr, NEXT_ENTRY(PRIORITY_LEVEL)),
+ .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PRIORITY_LEVEL)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, priority)),
.call = parse_vc,
},
- [INGRESS] = {
+ [VC_INGRESS] = {
.name = "ingress",
.help = "affect rule to ingress",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
- [EGRESS] = {
+ [VC_EGRESS] = {
.name = "egress",
.help = "affect rule to egress",
.next = NEXT(next_vc_attr),
.call = parse_vc,
},
- [TRANSFER] = {
+ [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. */
- [PATTERN] = {
+ [ITEM_PATTERN] = {
.name = "pattern",
.help = "submit a list of pattern items",
.next = NEXT(next_item),
[ITEM_ANY_NUM] = {
.name = "num",
.help = "number of layers covered",
- .next = NEXT(item_any, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_any, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_any, num)),
},
[ITEM_PF] = {
[ITEM_VF_ID] = {
.name = "id",
.help = "VF ID",
- .next = NEXT(item_vf, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_vf, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_vf, id)),
},
[ITEM_PHY_PORT] = {
[ITEM_PHY_PORT_INDEX] = {
.name = "index",
.help = "physical port index",
- .next = NEXT(item_phy_port, NEXT_ENTRY(UNSIGNED), item_param),
+ .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] = {
[ITEM_PORT_ID_ID] = {
.name = "id",
.help = "DPDK port ID",
- .next = NEXT(item_port_id, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_port_id, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_port_id, id)),
},
[ITEM_MARK] = {
[ITEM_MARK_ID] = {
.name = "id",
.help = "Integer value to match against",
- .next = NEXT(item_mark, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_mark, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_mark, id)),
},
[ITEM_RAW] = {
[ITEM_RAW_RELATIVE] = {
.name = "relative",
.help = "look for pattern after the previous item",
- .next = NEXT(item_raw, NEXT_ENTRY(BOOLEAN), item_param),
+ .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(BOOLEAN), item_param),
+ .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(INTEGER), item_param),
+ .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(UNSIGNED), item_param),
+ .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(STRING),
+ NEXT_ENTRY(COMMON_STRING),
NEXT_ENTRY(ITEM_PARAM_IS,
ITEM_PARAM_SPEC,
ITEM_PARAM_MASK)),
[ITEM_ETH_DST] = {
.name = "dst",
.help = "destination MAC",
- .next = NEXT(item_eth, NEXT_ENTRY(MAC_ADDR), item_param),
+ .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(MAC_ADDR), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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_TCI] = {
.name = "tci",
.help = "tag control information",
- .next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .next = NEXT(item_vlan, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_vlan,
has_more_vlan, 1)),
},
.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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(IPV4_ADDR), item_param),
+ .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(IPV4_ADDR), item_param),
+ .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_TC] = {
.name = "tc",
.help = "traffic class",
- .next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(IPV6_ADDR), item_param),
+ .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(IPV6_ADDR), item_param),
+ .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(UNSIGNED), item_param),
+ .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_TYPE] = {
.name = "type",
.help = "ICMP packet type",
- .next = NEXT(item_icmp, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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_SRC] = {
.name = "src",
.help = "UDP source port",
- .next = NEXT(item_udp, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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_SRC] = {
.name = "src",
.help = "TCP source port",
- .next = NEXT(item_tcp, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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_SRC] = {
.name = "src",
.help = "SCTP source port",
- .next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .next = NEXT(item_sctp, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
hdr.cksum)),
},
[ITEM_VXLAN_VNI] = {
.name = "vni",
.help = "VXLAN identifier",
- .next = NEXT(item_vxlan, NEXT_ENTRY(UNSIGNED), item_param),
+ .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",
[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),
+ .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_TNI] = {
.name = "tni",
.help = "virtual subnet ID",
- .next = NEXT(item_nvgre, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_nvgre, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_nvgre, tni)),
},
[ITEM_MPLS] = {
[ITEM_MPLS_LABEL] = {
.name = "label",
.help = "MPLS label",
- .next = NEXT(item_mpls, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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_PROTO] = {
.name = "protocol",
.help = "GRE protocol type",
- .next = NEXT(item_gre, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_gre, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre,
protocol)),
},
"checksum (1b), undefined (1b), key bit (1b),"
" sequence number (1b), reserved 0 (9b),"
" version (3b)",
- .next = NEXT(item_gre, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(BOOLEAN), item_param),
+ .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(BOOLEAN), item_param),
+ .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(BOOLEAN), item_param),
+ .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_THRESH] = {
.name = "thresh",
.help = "match accuracy threshold",
- .next = NEXT(item_fuzzy, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_fuzzy, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_fuzzy,
thresh)),
},
[ITEM_GTP_FLAGS] = {
.name = "v_pt_rsv_flags",
.help = "GTP flags",
- .next = NEXT(item_gtp, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp, teid)),
},
[ITEM_GTPC] = {
[ITEM_GENEVE_VNI] = {
.name = "vni",
.help = "virtual network identifier",
- .next = NEXT(item_geneve, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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",
[ITEM_VXLAN_GPE_VNI] = {
.name = "vni",
.help = "VXLAN-GPE identifier",
- .next = NEXT(item_vxlan_gpe, NEXT_ENTRY(UNSIGNED), item_param),
+ .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_SHA] = {
.name = "sha",
.help = "sender hardware address",
- .next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(MAC_ADDR),
+ .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(IPV4_ADDR),
+ .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(MAC_ADDR),
+ .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(IPV4_ADDR),
+ .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_NEXT_HDR] = {
.name = "next_hdr",
.help = "next header",
- .next = NEXT(item_ipv6_ext, NEXT_ENTRY(UNSIGNED), item_param),
+ .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_NEXT_HDR] = {
.name = "next_hdr",
.help = "next header",
- .next = NEXT(item_ipv6_frag_ext, NEXT_ENTRY(UNSIGNED),
+ .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(UNSIGNED),
+ .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",
[ITEM_ICMP6_TYPE] = {
.name = "type",
.help = "ICMPv6 type",
- .next = NEXT(item_icmp6, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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_TARGET_ADDR] = {
.name = "target_addr",
.help = "target address",
- .next = NEXT(item_icmp6_nd_ns, NEXT_ENTRY(IPV6_ADDR),
+ .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_TARGET_ADDR] = {
.name = "target_addr",
.help = "target address",
- .next = NEXT(item_icmp6_nd_na, NEXT_ENTRY(IPV6_ADDR),
+ .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_TYPE] = {
.name = "type",
.help = "ND option type",
- .next = NEXT(item_icmp6_nd_opt, NEXT_ENTRY(UNSIGNED),
+ .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_SLA] = {
.name = "sla",
.help = "source Ethernet LLA",
- .next = NEXT(item_icmp6_nd_opt_sla_eth, NEXT_ENTRY(MAC_ADDR),
- item_param),
+ .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_TLA] = {
.name = "tla",
.help = "target Ethernet LLA",
- .next = NEXT(item_icmp6_nd_opt_tla_eth, NEXT_ENTRY(MAC_ADDR),
- item_param),
+ .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_DATA] = {
.name = "data",
.help = "metadata value",
- .next = NEXT(item_meta, NEXT_ENTRY(UNSIGNED), item_param),
+ .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_VALUE] = {
.name = "value",
.help = "key value",
- .next = NEXT(item_gre_key, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_gre_key, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
},
[ITEM_GTP_PSC] = {
[ITEM_GTP_PSC_QFI] = {
.name = "qfi",
.help = "QoS flow identifier",
- .next = NEXT(item_gtp_psc, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_gtp_psc, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp_psc,
qfi)),
},
[ITEM_GTP_PSC_PDU_T] = {
.name = "pdu_t",
.help = "PDU type",
- .next = NEXT(item_gtp_psc, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_gtp_psc, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp_psc,
pdu_type)),
},
[ITEM_PPPOE_SEID] = {
.name = "seid",
.help = "session identifier",
- .next = NEXT(item_pppoes, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_pppoes, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_pppoe,
session_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(UNSIGNED),
+ .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)),
[ITEM_HIGIG2_CLASSIFICATION] = {
.name = "classification",
.help = "matches classification of higig2 header",
- .next = NEXT(item_higig2, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .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_DATA] = {
.name = "data",
.help = "tag value to match",
- .next = NEXT(item_tag, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED),
+ .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_SESSION_ID] = {
.name = "session_id",
.help = "session identifier",
- .next = NEXT(item_l2tpv3oip, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_l2tpv3oip, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv3oip,
session_id)),
},
[ITEM_ESP_SPI] = {
.name = "spi",
.help = "security policy index",
- .next = NEXT(item_esp, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_esp, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_esp,
hdr.spi)),
},
[ITEM_AH_SPI] = {
.name = "spi",
.help = "security parameters index",
- .next = NEXT(item_ah, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(item_ah, NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ah, spi)),
},
[ITEM_PFCP] = {
[ITEM_PFCP_S_FIELD] = {
.name = "s_field",
.help = "S field",
- .next = NEXT(item_pfcp, NEXT_ENTRY(UNSIGNED), item_param),
+ .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(UNSIGNED), item_param),
+ .next = NEXT(item_pfcp, NEXT_ENTRY(COMMON_UNSIGNED),
+ item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_pfcp, seid)),
},
[ITEM_ECPRI] = {
[ITEM_ECPRI_MSG_IQ_DATA_PCID] = {
.name = "pc_id",
.help = "Physical Channel ID",
- .next = NEXT(item_ecpri, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_IQ_DATA_PCID,
+ ITEM_ECPRI_COMMON, ITEM_NEXT),
+ NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type0.pc_id)),
},
[ITEM_ECPRI_MSG_RTC_CTRL_RTCID] = {
.name = "rtc_id",
.help = "Real-Time Control Data ID",
- .next = NEXT(item_ecpri, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_RTC_CTRL_RTCID,
+ ITEM_ECPRI_COMMON, ITEM_NEXT),
+ NEXT_ENTRY(COMMON_UNSIGNED), item_param),
.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri,
hdr.type2.rtc_id)),
},
[ITEM_ECPRI_MSG_DLY_MSR_MSRID] = {
.name = "msr_id",
.help = "Measurement ID",
- .next = NEXT(item_ecpri, NEXT_ENTRY(UNSIGNED), item_param),
+ .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_DLY_MSR_MSRID,
+ ITEM_ECPRI_COMMON, ITEM_NEXT),
+ NEXT_ENTRY(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)),
+ },
/* Validate/create actions. */
[ACTIONS] = {
.name = "actions",
[ACTION_JUMP_GROUP] = {
.name = "group",
.help = "group to redirect traffic to",
- .next = NEXT(action_jump, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_jump, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_jump, group)),
.call = parse_vc_conf,
},
[ACTION_MARK_ID] = {
.name = "id",
.help = "32 bit value to return with packets",
- .next = NEXT(action_mark, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_mark, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_mark, id)),
.call = parse_vc_conf,
},
[ACTION_QUEUE_INDEX] = {
.name = "index",
.help = "queue index to use",
- .next = NEXT(action_queue, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_queue, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_queue, index)),
.call = parse_vc_conf,
},
[ACTION_COUNT_ID] = {
.name = "identifier",
.help = "counter identifier to use",
- .next = NEXT(action_count, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_count, NEXT_ENTRY(COMMON_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)),
+ .next = NEXT(action_count, NEXT_ENTRY(COMMON_BOOLEAN)),
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_count,
shared, 1)),
.call = parse_vc_conf,
[ACTION_RSS_LEVEL] = {
.name = "level",
.help = "encapsulation level for \"types\"",
- .next = NEXT(action_rss, NEXT_ENTRY(UNSIGNED)),
+ .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),
[ACTION_RSS_KEY] = {
.name = "key",
.help = "RSS hash key",
- .next = NEXT(action_rss, NEXT_ENTRY(HEX)),
- .args = ARGS(ARGS_ENTRY_ARB(0, 0),
+ .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),
[ACTION_RSS_KEY_LEN] = {
.name = "key_len",
.help = "RSS hash key length in bytes",
- .next = NEXT(action_rss, NEXT_ENTRY(UNSIGNED)),
+ .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),
[ACTION_VF_ORIGINAL] = {
.name = "original",
.help = "use original VF ID if possible",
- .next = NEXT(action_vf, NEXT_ENTRY(BOOLEAN)),
+ .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(UNSIGNED)),
+ .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_ORIGINAL] = {
.name = "original",
.help = "use original port index if possible",
- .next = NEXT(action_phy_port, NEXT_ENTRY(BOOLEAN)),
+ .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(UNSIGNED)),
+ .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_ORIGINAL] = {
.name = "original",
.help = "use original DPDK port ID if possible",
- .next = NEXT(action_port_id, NEXT_ENTRY(BOOLEAN)),
+ .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(UNSIGNED)),
+ .next = NEXT(action_port_id, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY(struct rte_flow_action_port_id, id)),
.call = parse_vc_conf,
},
.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(UNSIGNED)),
+ .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_MPLS_TTL] = {
.name = "mpls_ttl",
.help = "MPLS TTL",
- .next = NEXT(action_of_set_mpls_ttl, NEXT_ENTRY(UNSIGNED)),
+ .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_SET_NW_TTL_NW_TTL] = {
.name = "nw_ttl",
.help = "IP TTL",
- .next = NEXT(action_of_set_nw_ttl, NEXT_ENTRY(UNSIGNED)),
+ .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_PUSH_VLAN_ETHERTYPE] = {
.name = "ethertype",
.help = "EtherType",
- .next = NEXT(action_of_push_vlan, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_of_push_vlan, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_push_vlan,
ethertype)),
[ACTION_OF_SET_VLAN_VID_VLAN_VID] = {
.name = "vlan_vid",
.help = "VLAN id",
- .next = NEXT(action_of_set_vlan_vid, NEXT_ENTRY(UNSIGNED)),
+ .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)),
[ACTION_OF_SET_VLAN_PCP_VLAN_PCP] = {
.name = "vlan_pcp",
.help = "VLAN priority",
- .next = NEXT(action_of_set_vlan_pcp, NEXT_ENTRY(UNSIGNED)),
+ .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)),
[ACTION_OF_POP_MPLS_ETHERTYPE] = {
.name = "ethertype",
.help = "EtherType",
- .next = NEXT(action_of_pop_mpls, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_of_pop_mpls, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_pop_mpls,
ethertype)),
[ACTION_OF_PUSH_MPLS_ETHERTYPE] = {
.name = "ethertype",
.help = "EtherType",
- .next = NEXT(action_of_push_mpls, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_of_push_mpls, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARGS_ENTRY_HTON
(struct rte_flow_action_of_push_mpls,
ethertype)),
[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)),
+ .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_IPV4_DST] = {
.name = "ipv4_addr",
.help = "new IPv4 destination address to set",
- .next = NEXT(action_set_ipv4_dst, NEXT_ENTRY(IPV4_ADDR)),
+ .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_IPV6_SRC] = {
.name = "ipv6_addr",
.help = "new IPv6 source address to set",
- .next = NEXT(action_set_ipv6_src, NEXT_ENTRY(IPV6_ADDR)),
+ .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_IPV6_DST] = {
.name = "ipv6_addr",
.help = "new IPv6 destination address to set",
- .next = NEXT(action_set_ipv6_dst, NEXT_ENTRY(IPV6_ADDR)),
+ .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_TP_SRC] = {
.name = "port",
.help = "new source port number to set",
- .next = NEXT(action_set_tp_src, NEXT_ENTRY(UNSIGNED)),
+ .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_TP_DST] = {
.name = "port",
.help = "new destination port number to set",
- .next = NEXT(action_set_tp_dst, NEXT_ENTRY(UNSIGNED)),
+ .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_SET_TTL_TTL] = {
.name = "ttl_value",
.help = "new ttl value to set",
- .next = NEXT(action_set_ttl, NEXT_ENTRY(UNSIGNED)),
+ .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_MAC_SRC] = {
.name = "mac_addr",
.help = "new source mac address",
- .next = NEXT(action_set_mac_src, NEXT_ENTRY(MAC_ADDR)),
+ .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_MAC_DST] = {
.name = "mac_addr",
.help = "new destination mac address to set",
- .next = NEXT(action_set_mac_dst, NEXT_ENTRY(MAC_ADDR)),
+ .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_VALUE] = {
.name = "value",
.help = "the value to increase TCP sequence number by",
- .next = NEXT(action_inc_tcp_seq, NEXT_ENTRY(UNSIGNED)),
+ .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_VALUE] = {
.name = "value",
.help = "the value to decrease TCP sequence number by",
- .next = NEXT(action_dec_tcp_seq, NEXT_ENTRY(UNSIGNED)),
+ .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_VALUE] = {
.name = "value",
.help = "the value to increase TCP acknowledgment number by",
- .next = NEXT(action_inc_tcp_ack, NEXT_ENTRY(UNSIGNED)),
+ .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_VALUE] = {
.name = "value",
.help = "the value to decrease TCP acknowledgment number by",
- .next = NEXT(action_dec_tcp_ack, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_dec_tcp_ack, NEXT_ENTRY(COMMON_UNSIGNED)),
.args = ARGS(ARG_ENTRY_HTON(rte_be32_t)),
.call = parse_vc_conf,
},
.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,
+ sizeof(struct rte_flow_action_modify_field)),
+ .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_UNSIGNED)),
+ .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field,
+ src.value)),
+ .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",
},
[SET_RAW_INDEX] = {
.name = "{index}",
- .type = "UNSIGNED",
+ .type = "COMMON_UNSIGNED",
.help = "index of raw_encap/raw_decap data",
.next = NEXT(next_item),
.call = parse_port,
[ACTION_SET_TAG_INDEX] = {
.name = "index",
.help = "index of tag array",
- .next = NEXT(action_set_tag, NEXT_ENTRY(UNSIGNED)),
+ .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(UNSIGNED)),
+ .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(UNSIGNED)),
+ .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_DATA] = {
.name = "data",
.help = "metadata value",
- .next = NEXT(action_set_meta, NEXT_ENTRY(UNSIGNED)),
+ .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(UNSIGNED)),
+ .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_VALUE] = {
.name = "dscp_value",
.help = "new IPv4 DSCP value to set",
- .next = NEXT(action_set_ipv4_dscp, NEXT_ENTRY(UNSIGNED)),
+ .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_VALUE] = {
.name = "dscp_value",
.help = "new IPv6 DSCP value to set",
- .next = NEXT(action_set_ipv6_dscp, NEXT_ENTRY(UNSIGNED)),
+ .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,
.help = "flow age timeout value",
.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_age,
timeout, 24)),
- .next = NEXT(action_age, NEXT_ENTRY(UNSIGNED)),
+ .next = NEXT(action_age, NEXT_ENTRY(COMMON_UNSIGNED)),
.call = parse_vc_conf,
},
[ACTION_SAMPLE] = {
[ACTION_SAMPLE_RATIO] = {
.name = "ratio",
.help = "flow sample ratio value",
- .next = NEXT(action_sample, NEXT_ENTRY(UNSIGNED)),
+ .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),
},
[ACTION_SAMPLE_INDEX_VALUE] = {
.name = "{index}",
- .type = "UNSIGNED",
+ .type = "COMMON_UNSIGNED",
.help = "unsigned integer value",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
.call = parse_vc_action_sample_index,
.comp = comp_set_sample_index,
},
- /* Shared action destroy arguments. */
- [SHARED_ACTION_DESTROY_ID] = {
+ [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,
+ },
+ /* Indirect action destroy arguments. */
+ [INDIRECT_ACTION_DESTROY_ID] = {
.name = "action_id",
- .help = "specify a shared action id to destroy",
- .next = NEXT(next_sa_destroy_attr,
- NEXT_ENTRY(SHARED_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.sa_destroy.action_id)),
- .call = parse_sa_destroy,
+ args.ia_destroy.action_id)),
+ .call = parse_ia_destroy,
},
- /* Shared action create arguments. */
- [SHARED_ACTION_CREATE_ID] = {
+ /* Indirect action create arguments. */
+ [INDIRECT_ACTION_CREATE_ID] = {
.name = "action_id",
- .help = "specify a shared action id to create",
- .next = NEXT(next_sa_create_attr,
- NEXT_ENTRY(SHARED_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_SHARED] = {
- .name = "shared",
- .help = "apply shared action by id",
- .priv = PRIV_ACTION(SHARED, 0),
- .next = NEXT(NEXT_ENTRY(SHARED_ACTION_ID2PTR)),
+ [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,
},
- [SHARED_ACTION_ID2PTR] = {
+ [INDIRECT_ACTION_ID2PTR] = {
.name = "{action_id}",
- .type = "SHARED_ACTION_ID",
- .help = "shared action id",
+ .type = "INDIRECT_ACTION_ID",
+ .help = "indirect action id",
.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
- .call = parse_sa_id2ptr,
+ .call = parse_ia_id2ptr,
.comp = comp_none,
},
- [SHARED_ACTION_INGRESS] = {
+ [INDIRECT_ACTION_INGRESS] = {
.name = "ingress",
.help = "affect rule to ingress",
- .next = NEXT(next_sa_create_attr),
- .call = parse_sa,
+ .next = NEXT(next_ia_create_attr),
+ .call = parse_ia,
},
- [SHARED_ACTION_EGRESS] = {
+ [INDIRECT_ACTION_EGRESS] = {
.name = "egress",
.help = "affect rule to egress",
- .next = NEXT(next_sa_create_attr),
- .call = parse_sa,
+ .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,
},
- [SHARED_ACTION_SPEC] = {
+ [INDIRECT_ACTION_SPEC] = {
.name = "action",
- .help = "specify action to share",
+ .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. */
return len;
}
-/** Parse tokens for shared action commands. */
+/** Parse tokens for indirect action commands. */
static int
-parse_sa(struct context *ctx, const struct token *token,
+parse_ia(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
if (!out)
return len;
if (!out->command) {
- if (ctx->curr != SHARED_ACTION)
+ if (ctx->curr != INDIRECT_ACTION)
return -1;
if (sizeof(*out) > size)
return -1;
return len;
}
switch (ctx->curr) {
- case SHARED_ACTION_CREATE:
- case SHARED_ACTION_UPDATE:
+ 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 SHARED_ACTION_QUERY:
+ case INDIRECT_ACTION_QUERY:
out->command = ctx->curr;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
return len;
- case SHARED_ACTION_EGRESS:
+ case INDIRECT_ACTION_EGRESS:
out->args.vc.attr.egress = 1;
return len;
- case SHARED_ACTION_INGRESS:
+ 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 shared action destroy command. */
+/** Parse tokens for indirect action destroy command. */
static int
-parse_sa_destroy(struct context *ctx, const struct token *token,
+parse_ia_destroy(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
/* Nothing else to do if there is no buffer. */
if (!out)
return len;
- if (!out->command || out->command == SHARED_ACTION) {
- if (ctx->curr != SHARED_ACTION_DESTROY)
+ if (!out->command || out->command == INDIRECT_ACTION) {
+ if (ctx->curr != INDIRECT_ACTION_DESTROY)
return -1;
if (sizeof(*out) > size)
return -1;
ctx->objdata = 0;
ctx->object = out;
ctx->objmask = NULL;
- out->args.sa_destroy.action_id =
+ out->args.ia_destroy.action_id =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return len;
}
- action_id = out->args.sa_destroy.action_id
- + out->args.sa_destroy.action_id_n++;
+ 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;
return len;
}
-/** Parse tokens for validate/create commands. */
+/** Parse tokens for meter policy action commands. */
static int
-parse_vc(struct context *ctx, const struct token *token,
- const char *str, unsigned int len,
- void *buf, unsigned int size)
+parse_mp(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)
if (!out)
return len;
if (!out->command) {
- if (ctx->curr != VALIDATE && ctx->curr != CREATE)
+ if (ctx->curr != ITEM_POL_POLICY)
return -1;
if (sizeof(*out) > size)
return -1;
out->args.vc.data = (uint8_t *)out + size;
return len;
}
- ctx->objdata = 0;
- ctx->object = &out->args.vc.attr;
- ctx->objmask = NULL;
switch (ctx->curr) {
- case GROUP:
- case PRIORITY:
- return len;
- case INGRESS:
- out->args.vc.attr.ingress = 1;
- return len;
- case EGRESS:
+ 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)
+ 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 TRANSFER:
+ case VC_TRANSFER:
out->args.vc.attr.transfer = 1;
return len;
- case PATTERN:
+ case ITEM_PATTERN:
out->args.vc.pattern =
(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
sizeof(double));
return -1;
/* Parse parameter types. */
switch (ctx->curr) {
- static const enum index prefix[] = NEXT_ENTRY(PREFIX);
+ static const enum index prefix[] = NEXT_ENTRY(COMMON_PREFIX);
case ITEM_PARAM_IS:
index = 0;
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,
.func = RTE_ETH_HASH_FUNCTION_DEFAULT,
.level = 0,
.types = rss_hf,
- .key_len = sizeof(action_rss_data->key),
+ .key_len = 0,
.queue_num = RTE_MIN(nb_rxq, ACTION_RSS_QUEUE_NUM),
- .key = action_rss_data->key,
+ .key = NULL,
.queue = action_rss_data->queue,
},
- .key = "testpmd's default RSS hash key, "
- "override it for better balancing",
.queue = { 0 },
};
for (i = 0; i < action_rss_data->conf.queue_num; ++i)
action_rss_data->queue[i] = i;
- if (!port_id_is_invalid(ctx->port, DISABLED_WARN) &&
- ctx->port != (portid_t)RTE_PORT_ALL) {
- struct rte_eth_dev_info info;
- int ret2;
-
- ret2 = rte_eth_dev_info_get(ctx->port, &info);
- if (ret2 != 0)
- return ret2;
-
- action_rss_data->conf.key_len =
- RTE_MIN(sizeof(action_rss_data->key),
- info.hash_key_size);
- }
action->conf = &action_rss_data->conf;
return ret;
}
return len;
}
-/** Parse VXLAN encap action. */
+/** Setup VXLAN encap configuration. */
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)
+parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_data)
{
- 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;
/* Set up default configuration. */
- action_vxlan_encap_data = ctx->object;
*action_vxlan_encap_data = (struct action_vxlan_encap_data){
.conf = (struct rte_flow_action_vxlan_encap){
.definition = action_vxlan_encap_data->items,
}
memcpy(action_vxlan_encap_data->item_vxlan.vni, vxlan_encap_conf.vni,
RTE_DIM(vxlan_encap_conf.vni));
- action->conf = &action_vxlan_encap_data->conf;
- return ret;
+ return 0;
}
-/** Parse NVGRE encap action. */
+/** Parse VXLAN encap action. */
static int
-parse_vc_action_nvgre_encap(struct context *ctx, const struct token *token,
+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_nvgre_encap_data *action_nvgre_encap_data;
+ struct action_vxlan_encap_data *action_vxlan_encap_data;
int ret;
ret = parse_vc(ctx, token, str, len, buf, size);
/* 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 = ctx->object;
*action_nvgre_encap_data = (struct action_nvgre_encap_data){
.conf = (struct rte_flow_action_nvgre_encap){
.definition = action_nvgre_encap_data->items,
.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,
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;
}
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,
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;
}
- return len;
}
/** Parse tokens for query command. */
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.
*
ret = snprintf(tmp, sizeof(tmp), "%u", hexlen);
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;
+ /* 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. */
}
static int
-parse_sa_id2ptr(struct context *ctx, const struct token *token,
+parse_ia_id2ptr(struct context *ctx, const struct token *token,
const char *str, unsigned int len,
void *buf, unsigned int size)
{
ctx->object = action;
if (ret != (int)len)
return ret;
- /* set shared action */
+ /* set indirect action */
if (action) {
- action->conf = port_shared_action_get_by_id(ctx->port, id);
+ action->conf = port_action_handle_get_by_id(ctx->port, id);
ret = (action->conf) ? ret : -1;
}
return ret;
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)
+{
+ uint16_t idx = 0;
+
+ RTE_SET_USED(ctx);
+ RTE_SET_USED(token);
+ for (idx = 0; modify_field_ops[idx]; ++idx)
+ ;
+ if (!buf)
+ return idx + 1;
+ if (ent < idx)
+ 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)
+{
+ uint16_t idx = 0;
+
+ RTE_SET_USED(ctx);
+ RTE_SET_USED(token);
+ for (idx = 0; modify_field_ids[idx]; ++idx)
+ ;
+ if (!buf)
+ return idx + 1;
+ if (ent < idx)
+ return strlcpy(buf, modify_field_ids[ent], size);
+ return -1;
+}
+
/** Internal context. */
static struct context cmd_flow_context;
cmd_flow_parsed(const struct buffer *in)
{
switch (in->command) {
- case SHARED_ACTION_CREATE:
- port_shared_action_create(
+ case INDIRECT_ACTION_CREATE:
+ port_action_handle_create(
in->port, in->args.vc.attr.group,
- &((const struct rte_flow_shared_action_conf) {
+ &((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 SHARED_ACTION_DESTROY:
- port_shared_action_destroy(in->port,
- in->args.sa_destroy.action_id_n,
- in->args.sa_destroy.action_id);
+ 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 SHARED_ACTION_UPDATE:
- port_shared_action_update(in->port, in->args.vc.attr.group,
+ case INDIRECT_ACTION_UPDATE:
+ port_action_handle_update(in->port, in->args.vc.attr.group,
in->args.vc.actions);
break;
- case SHARED_ACTION_QUERY:
- port_shared_action_query(in->port, in->args.sa.action_id);
+ 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.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.pattern, in->args.vc.actions,
+ &in->args.vc.tunnel_ops);
break;
case DESTROY:
port_flow_destroy(in->port, in->args.destroy.rule_n,
case FLUSH:
port_flow_flush(in->port);
break;
- case DUMP:
- port_flow_dump(in->port, in->args.dump.file);
+ 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,
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;
default:
break;
}
static void
update_fields(uint8_t *buf, struct rte_flow_item *item, uint16_t next_proto)
{
- struct rte_flow_item_ipv4 *ipv4;
- struct rte_flow_item_eth *eth;
- struct rte_flow_item_ipv6 *ipv6;
- struct rte_flow_item_vxlan *vxlan;
- struct rte_flow_item_vxlan_gpe *gpe;
+ struct rte_ipv4_hdr *ipv4;
+ struct rte_ether_hdr *eth;
+ struct rte_ipv6_hdr *ipv6;
+ struct rte_vxlan_hdr *vxlan;
+ struct rte_vxlan_gpe_hdr *gpe;
struct rte_flow_item_nvgre *nvgre;
uint32_t ipv6_vtc_flow;
switch (item->type) {
case RTE_FLOW_ITEM_TYPE_ETH:
- eth = (struct rte_flow_item_eth *)buf;
+ eth = (struct rte_ether_hdr *)buf;
if (next_proto)
- eth->type = rte_cpu_to_be_16(next_proto);
+ eth->ether_type = rte_cpu_to_be_16(next_proto);
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
- ipv4 = (struct rte_flow_item_ipv4 *)buf;
- ipv4->hdr.version_ihl = 0x45;
- if (next_proto && ipv4->hdr.next_proto_id == 0)
- ipv4->hdr.next_proto_id = (uint8_t)next_proto;
+ ipv4 = (struct rte_ipv4_hdr *)buf;
+ 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_flow_item_ipv6 *)buf;
- if (next_proto && ipv6->hdr.proto == 0)
- ipv6->hdr.proto = (uint8_t)next_proto;
- ipv6_vtc_flow = rte_be_to_cpu_32(ipv6->hdr.vtc_flow);
+ ipv6 = (struct rte_ipv6_hdr *)buf;
+ if (next_proto && ipv6->proto == 0)
+ ipv6->proto = (uint8_t)next_proto;
+ ipv6_vtc_flow = rte_be_to_cpu_32(ipv6->vtc_flow);
ipv6_vtc_flow &= 0x0FFFFFFF; /*< reset version bits. */
ipv6_vtc_flow |= 0x60000000; /*< set ipv6 version. */
- ipv6->hdr.vtc_flow = rte_cpu_to_be_32(ipv6_vtc_flow);
+ ipv6->vtc_flow = rte_cpu_to_be_32(ipv6_vtc_flow);
break;
case RTE_FLOW_ITEM_TYPE_VXLAN:
- vxlan = (struct rte_flow_item_vxlan *)buf;
- vxlan->flags = 0x08;
+ vxlan = (struct rte_vxlan_hdr *)buf;
+ vxlan->vx_flags = 0x08;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
- gpe = (struct rte_flow_item_vxlan_gpe *)buf;
- gpe->flags = 0x0C;
+ gpe = (struct rte_vxlan_gpe_hdr *)buf;
+ gpe->vx_flags = 0x0C;
break;
case RTE_FLOW_ITEM_TYPE_NVGRE:
nvgre = (struct rte_flow_item_nvgre *)buf;
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;
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) *
(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_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:
- printf("Error - Not supported action\n");
+ fprintf(stderr, "Error - Not supported action\n");
return;
}
rte_memcpy(data, action, sizeof(struct rte_flow_action));
uint16_t upper_layer = 0;
uint16_t proto = 0;
uint16_t idx = in->port; /* We borrow port field as index */
+ int gtp_psc = -1; /* GTP PSC option index. */
if (in->command == SET_SAMPLE_ACTIONS)
return cmd_set_raw_parsed_sample(in);
/* process hdr from upper layer to low layer (L3/L4 -> L2). */
data_tail = data + ACTION_RAW_ENCAP_MAX_DATA;
for (i = n - 1 ; i >= 0; --i) {
+ const struct rte_flow_item_gtp *gtp;
+ 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_flow_item_eth);
+ size = sizeof(struct rte_ether_hdr);
break;
case RTE_FLOW_ITEM_TYPE_VLAN:
- size = sizeof(struct rte_flow_item_vlan);
+ size = sizeof(struct rte_vlan_hdr);
proto = RTE_ETHER_TYPE_VLAN;
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
- size = sizeof(struct rte_flow_item_ipv4);
+ size = sizeof(struct rte_ipv4_hdr);
proto = RTE_ETHER_TYPE_IPV4;
break;
case RTE_FLOW_ITEM_TYPE_IPV6:
- size = sizeof(struct rte_flow_item_ipv6);
+ size = sizeof(struct rte_ipv6_hdr);
proto = RTE_ETHER_TYPE_IPV6;
break;
case RTE_FLOW_ITEM_TYPE_UDP:
- size = sizeof(struct rte_flow_item_udp);
+ size = sizeof(struct rte_udp_hdr);
proto = 0x11;
break;
case RTE_FLOW_ITEM_TYPE_TCP:
- size = sizeof(struct rte_flow_item_tcp);
+ size = sizeof(struct rte_tcp_hdr);
proto = 0x06;
break;
case RTE_FLOW_ITEM_TYPE_VXLAN:
- size = sizeof(struct rte_flow_item_vxlan);
+ size = sizeof(struct rte_vxlan_hdr);
break;
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
- size = sizeof(struct rte_flow_item_vxlan_gpe);
+ size = sizeof(struct rte_vxlan_gpe_hdr);
break;
case RTE_FLOW_ITEM_TYPE_GRE:
- size = sizeof(struct rte_flow_item_gre);
+ size = sizeof(struct rte_gre_hdr);
proto = 0x2F;
break;
case RTE_FLOW_ITEM_TYPE_GRE_KEY:
proto = 0x0;
break;
case RTE_FLOW_ITEM_TYPE_MPLS:
- size = sizeof(struct rte_flow_item_mpls);
+ size = sizeof(struct rte_mpls_hdr);
proto = 0x0;
break;
case RTE_FLOW_ITEM_TYPE_NVGRE:
proto = 0x2F;
break;
case RTE_FLOW_ITEM_TYPE_GENEVE:
- size = sizeof(struct rte_flow_item_geneve);
+ size = sizeof(struct rte_geneve_hdr);
+ break;
+ case RTE_FLOW_ITEM_TYPE_GENEVE_OPT:
+ opt = (const struct rte_flow_item_geneve_opt *)
+ item->spec;
+ size = offsetof(struct rte_flow_item_geneve_opt, data);
+ 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(struct rte_flow_item_l2tpv3oip);
+ size = sizeof(rte_be32_t);
proto = 0x73;
break;
case RTE_FLOW_ITEM_TYPE_ESP:
- size = sizeof(struct rte_flow_item_esp);
+ size = sizeof(struct rte_esp_hdr);
proto = 0x32;
break;
case RTE_FLOW_ITEM_TYPE_AH:
proto = 0x33;
break;
case RTE_FLOW_ITEM_TYPE_GTP:
- size = sizeof(struct rte_flow_item_gtp);
+ if (gtp_psc < 0) {
+ size = sizeof(struct rte_gtp_hdr);
+ break;
+ }
+ if (gtp_psc != i + 1) {
+ 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;
+ uint8_t qfi;
+ uint8_t next;
+ } psc;
+
+ if (opt->pdu_type & 0x0F) {
+ /* Support the minimal option only. */
+ fprintf(stderr,
+ "Error - GTP PSC option with extra fields not supported\n");
+ goto error;
+ }
+ psc.len = sizeof(psc);
+ psc.pdu_type = opt->pdu_type;
+ psc.qfi = opt->qfi;
+ psc.next = 0;
+ *total_size += sizeof(psc);
+ rte_memcpy(data_tail - (*total_size),
+ &psc, sizeof(psc));
+ gtp_psc = i;
+ size = 0;
+ }
break;
case RTE_FLOW_ITEM_TYPE_PFCP:
size = sizeof(struct rte_flow_item_pfcp);
break;
default:
- printf("Error - Not supported item\n");
- *total_size = 0;
- memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA);
- return;
+ fprintf(stderr, "Error - Not supported item\n");
+ goto error;
}
*total_size += size;
rte_memcpy(data_tail - (*total_size), item->spec, size);
printf("total data size is %zu\n", (*total_size));
RTE_ASSERT((*total_size) <= ACTION_RAW_ENCAP_MAX_DATA);
memmove(data, (data_tail - (*total_size)), *total_size);
+ return;
+
+error:
+ *total_size = 0;
+ memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA);
}
/** Populate help strings for current token (cmdline API). */
all = 1;
index = 0;
} else if (index >= RAW_ENCAP_CONFS_MAX_NUM) {
- printf("index should be 0-%u\n", RAW_ENCAP_CONFS_MAX_NUM - 1);
+ fprintf(stderr, "index should be 0-%u\n",
+ RAW_ENCAP_CONFS_MAX_NUM - 1);
return;
}
do {
cmd_what, "raw_encap#raw_decap");
cmdline_parse_token_num_t cmd_show_set_raw_cmd_index =
TOKEN_NUM_INITIALIZER(struct cmd_show_set_raw_result,
- cmd_index, UINT16);
+ cmd_index, RTE_UINT16);
cmdline_parse_token_string_t cmd_show_set_raw_cmd_all =
TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result,
cmd_all, "all");
git.droids-corp.org / dpdk.git / blobdiff