X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline_flow.c;h=cfd55c598d3b9d3105bcaa61291fa8432365aa3e;hb=6496922368fe03be9ab4137f2d615dba1a766f39;hp=231dee7e29e7a657f7b7615685114222dfbb4b0f;hpb=dc7b3bfcf8a905aa9d55fab893f72decb0141d0a;p=dpdk.git diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 231dee7e29..cfd55c598d 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -10,8 +10,6 @@ #include #include #include -#include -#include #include #include @@ -40,21 +38,31 @@ enum index { 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, - INDIRECT_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, + COMMON_FLEX_HANDLE, + COMMON_FLEX_TOKEN, + COMMON_PATTERN_TEMPLATE_ID, + COMMON_ACTIONS_TEMPLATE_ID, + COMMON_TABLE_ID, + COMMON_QUEUE_ID, + + /* TOP-level command. */ + ADD, /* Top-level command. */ SET, @@ -68,6 +76,11 @@ enum index { /* Top-level command. */ FLOW, /* Sub-level commands. */ + INFO, + CONFIGURE, + PATTERN_TEMPLATE, + ACTIONS_TEMPLATE, + TABLE, INDIRECT_ACTION, VALIDATE, CREATE, @@ -79,6 +92,94 @@ enum index { AGED, ISOLATE, TUNNEL, + FLEX, + QUEUE, + PUSH, + PULL, + + /* Flex arguments */ + FLEX_ITEM_INIT, + FLEX_ITEM_CREATE, + FLEX_ITEM_DESTROY, + + /* Pattern template arguments. */ + PATTERN_TEMPLATE_CREATE, + PATTERN_TEMPLATE_DESTROY, + PATTERN_TEMPLATE_CREATE_ID, + PATTERN_TEMPLATE_DESTROY_ID, + PATTERN_TEMPLATE_RELAXED_MATCHING, + PATTERN_TEMPLATE_INGRESS, + PATTERN_TEMPLATE_EGRESS, + PATTERN_TEMPLATE_TRANSFER, + PATTERN_TEMPLATE_SPEC, + + /* Actions template arguments. */ + ACTIONS_TEMPLATE_CREATE, + ACTIONS_TEMPLATE_DESTROY, + ACTIONS_TEMPLATE_CREATE_ID, + ACTIONS_TEMPLATE_DESTROY_ID, + ACTIONS_TEMPLATE_INGRESS, + ACTIONS_TEMPLATE_EGRESS, + ACTIONS_TEMPLATE_TRANSFER, + ACTIONS_TEMPLATE_SPEC, + ACTIONS_TEMPLATE_MASK, + + /* Queue arguments. */ + QUEUE_CREATE, + QUEUE_DESTROY, + QUEUE_INDIRECT_ACTION, + + /* Queue create arguments. */ + QUEUE_CREATE_ID, + QUEUE_CREATE_POSTPONE, + QUEUE_TEMPLATE_TABLE, + QUEUE_PATTERN_TEMPLATE, + QUEUE_ACTIONS_TEMPLATE, + QUEUE_SPEC, + + /* Queue destroy arguments. */ + QUEUE_DESTROY_ID, + QUEUE_DESTROY_POSTPONE, + + /* Queue indirect action arguments */ + QUEUE_INDIRECT_ACTION_CREATE, + QUEUE_INDIRECT_ACTION_UPDATE, + QUEUE_INDIRECT_ACTION_DESTROY, + + /* Queue indirect action create arguments */ + QUEUE_INDIRECT_ACTION_CREATE_ID, + QUEUE_INDIRECT_ACTION_INGRESS, + QUEUE_INDIRECT_ACTION_EGRESS, + QUEUE_INDIRECT_ACTION_TRANSFER, + QUEUE_INDIRECT_ACTION_CREATE_POSTPONE, + QUEUE_INDIRECT_ACTION_SPEC, + + /* Queue indirect action update arguments */ + QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE, + + /* Queue indirect action destroy arguments */ + QUEUE_INDIRECT_ACTION_DESTROY_ID, + QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE, + + /* Push arguments. */ + PUSH_QUEUE, + + /* Pull arguments. */ + PULL_QUEUE, + + /* Table arguments. */ + TABLE_CREATE, + TABLE_DESTROY, + TABLE_CREATE_ID, + TABLE_DESTROY_ID, + TABLE_GROUP, + TABLE_PRIORITY, + TABLE_INGRESS, + TABLE_EGRESS, + TABLE_TRANSFER, + TABLE_RULES_NUMBER, + TABLE_PATTERN_TEMPLATE, + TABLE_ACTIONS_TEMPLATE, /* Tunnel arguments. */ TUNNEL_CREATE, @@ -100,18 +201,25 @@ enum index { AGED_DESTROY, /* Validate/create arguments. */ - GROUP, - PRIORITY, - INGRESS, - EGRESS, - TRANSFER, - TUNNEL_SET, - TUNNEL_MATCH, + VC_GROUP, + VC_PRIORITY, + VC_INGRESS, + VC_EGRESS, + VC_TRANSFER, + VC_TUNNEL_SET, + VC_TUNNEL_MATCH, /* Dump arguments */ DUMP_ALL, DUMP_ONE, + /* Configure arguments */ + CONFIG_QUEUES_NUMBER, + CONFIG_QUEUES_SIZE, + CONFIG_COUNTERS_NUMBER, + CONFIG_AGING_OBJECTS_NUMBER, + CONFIG_METERS_NUMBER, + /* Indirect action arguments */ INDIRECT_ACTION_CREATE, INDIRECT_ACTION_UPDATE, @@ -129,7 +237,7 @@ enum index { INDIRECT_ACTION_DESTROY_ID, /* Validate/create pattern. */ - PATTERN, + ITEM_PATTERN, ITEM_PARAM_IS, ITEM_PARAM_SPEC, ITEM_PARAM_LAST, @@ -156,6 +264,7 @@ enum index { ITEM_RAW_OFFSET, ITEM_RAW_LIMIT, ITEM_RAW_PATTERN, + ITEM_RAW_PATTERN_HEX, ITEM_ETH, ITEM_ETH_DST, ITEM_ETH_SRC, @@ -169,6 +278,7 @@ enum index { 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, @@ -203,6 +313,7 @@ enum index { ITEM_SCTP_CKSUM, ITEM_VXLAN, ITEM_VXLAN_VNI, + ITEM_VXLAN_LAST_RSVD, ITEM_E_TAG, ITEM_E_TAG_GRP_ECID_B, ITEM_NVGRE, @@ -259,6 +370,10 @@ enum index { ITEM_META_DATA, ITEM_GRE_KEY, ITEM_GRE_KEY_VALUE, + ITEM_GRE_OPTION, + ITEM_GRE_OPTION_CHECKSUM, + ITEM_GRE_OPTION_KEY, + ITEM_GRE_OPTION_SEQUENCE, ITEM_GTP_PSC, ITEM_GTP_PSC_QFI, ITEM_GTP_PSC_PDU_T, @@ -298,6 +413,51 @@ enum index { ITEM_INTEGRITY, ITEM_INTEGRITY_LEVEL, ITEM_INTEGRITY_VALUE, + ITEM_CONNTRACK, + ITEM_POL_PORT, + ITEM_POL_METER, + ITEM_POL_POLICY, + ITEM_PORT_REPRESENTOR, + ITEM_PORT_REPRESENTOR_PORT_ID, + ITEM_REPRESENTED_PORT, + ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID, + ITEM_FLEX, + ITEM_FLEX_ITEM_HANDLE, + ITEM_FLEX_PATTERN_HANDLE, + ITEM_L2TPV2, + ITEM_L2TPV2_TYPE, + ITEM_L2TPV2_TYPE_DATA, + ITEM_L2TPV2_TYPE_DATA_L, + ITEM_L2TPV2_TYPE_DATA_S, + ITEM_L2TPV2_TYPE_DATA_O, + ITEM_L2TPV2_TYPE_DATA_L_S, + ITEM_L2TPV2_TYPE_CTRL, + ITEM_L2TPV2_MSG_DATA_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_L_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_S_NS, + ITEM_L2TPV2_MSG_DATA_S_NR, + ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_O_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_O_OFFSET, + ITEM_L2TPV2_MSG_DATA_L_S_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_L_S_NS, + ITEM_L2TPV2_MSG_DATA_L_S_NR, + ITEM_L2TPV2_MSG_CTRL_LENGTH, + ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID, + ITEM_L2TPV2_MSG_CTRL_SESSION_ID, + ITEM_L2TPV2_MSG_CTRL_NS, + ITEM_L2TPV2_MSG_CTRL_NR, + ITEM_PPP, + ITEM_PPP_ADDR, + ITEM_PPP_CTRL, + ITEM_PPP_PROTO_ID, /* Validate/create actions. */ ACTIONS, @@ -314,7 +474,6 @@ enum index { ACTION_QUEUE_INDEX, ACTION_DROP, ACTION_COUNT, - ACTION_COUNT_SHARED, ACTION_COUNT_ID, ACTION_RSS, ACTION_RSS_FUNC, @@ -340,6 +499,11 @@ enum index { 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, @@ -435,11 +599,23 @@ enum index { ACTION_MODIFY_FIELD_SRC_LEVEL, ACTION_MODIFY_FIELD_SRC_OFFSET, ACTION_MODIFY_FIELD_SRC_VALUE, + ACTION_MODIFY_FIELD_SRC_POINTER, ACTION_MODIFY_FIELD_WIDTH, + ACTION_CONNTRACK, + ACTION_CONNTRACK_UPDATE, + ACTION_CONNTRACK_UPDATE_DIR, + ACTION_CONNTRACK_UPDATE_CTX, + ACTION_POL_G, + ACTION_POL_Y, + ACTION_POL_R, + ACTION_PORT_REPRESENTOR, + ACTION_PORT_REPRESENTOR_PORT_ID, + ACTION_REPRESENTED_PORT, + ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID, }; /** Maximum size for pattern in struct rte_flow_item_raw. */ -#define ITEM_RAW_PATTERN_SIZE 40 +#define ITEM_RAW_PATTERN_SIZE 512 /** Maximum size for GENEVE option data pattern in bytes. */ #define ITEM_GENEVE_OPT_DATA_SIZE 124 @@ -448,6 +624,14 @@ enum index { #define ITEM_RAW_SIZE \ (sizeof(struct rte_flow_item_raw) + ITEM_RAW_PATTERN_SIZE) +/** Maximum size for external pattern in struct rte_flow_action_modify_data. */ +#define ACTION_MODIFY_PATTERN_SIZE 32 + +/** Storage size for struct rte_flow_action_modify_field including pattern. */ +#define ACTION_MODIFY_SIZE \ + (sizeof(struct rte_flow_action_modify_field) + \ + ACTION_MODIFY_PATTERN_SIZE) + /** Maximum number of queue indices in struct rte_flow_action_rss. */ #define ACTION_RSS_QUEUE_NUM 128 @@ -574,6 +758,8 @@ struct mplsoudp_encap_conf mplsoudp_encap_conf; struct mplsoudp_decap_conf mplsoudp_decap_conf; +struct rte_flow_action_conntrack conntrack_context; + #define ACTION_SAMPLE_ACTIONS_NUM 10 #define RAW_SAMPLE_CONFS_MAX_NUM 8 /** Storage for struct rte_flow_action_sample including external data. */ @@ -609,7 +795,8 @@ static const char *const modify_field_ids[] = { "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 + "tag", "mark", "meta", "pointer", "value", + "ipv4_ecn", "ipv6_ecn", NULL }; /** Maximum number of subsequent tokens and arguments on the stack. */ @@ -779,7 +966,30 @@ struct token { struct buffer { enum index command; /**< Flow command. */ portid_t port; /**< Affected port ID. */ + queueid_t queue; /** Async queue ID. */ + bool postpone; /** Postpone async operation */ union { + struct { + struct rte_flow_port_attr port_attr; + uint32_t nb_queue; + struct rte_flow_queue_attr queue_attr; + } configure; /**< Configuration arguments. */ + struct { + uint32_t *template_id; + uint32_t template_id_n; + } templ_destroy; /**< Template destroy arguments. */ + struct { + uint32_t id; + struct rte_flow_template_table_attr attr; + uint32_t *pat_templ_id; + uint32_t pat_templ_id_n; + uint32_t *act_templ_id; + uint32_t act_templ_id_n; + } table; /**< Table arguments. */ + struct { + uint32_t *table_id; + uint32_t table_id_n; + } table_destroy; /**< Template destroy arguments. */ struct { uint32_t *action_id; uint32_t action_id_n; @@ -788,10 +998,14 @@ struct buffer { uint32_t action_id; } ia; /* Indirect action query arguments */ struct { + uint32_t table_id; + uint32_t pat_templ_id; + uint32_t act_templ_id; struct rte_flow_attr attr; struct tunnel_ops tunnel_ops; struct rte_flow_item *pattern; struct rte_flow_action *actions; + struct rte_flow_action *masks; uint32_t pattern_n; uint32_t actions_n; uint8_t *data; @@ -819,6 +1033,14 @@ struct buffer { struct { int destroy; } aged; /**< Aged arguments. */ + struct { + uint32_t policy_id; + } policy;/**< Policy arguments. */ + struct { + uint16_t token; + uintptr_t uintptr; + char filename[128]; + } flex; /**< Flex arguments*/ } args; /**< Command arguments. */ }; @@ -846,6 +1068,135 @@ struct parse_action_priv { .size = s, \ }) +static const enum index next_flex_item[] = { + FLEX_ITEM_INIT, + FLEX_ITEM_CREATE, + FLEX_ITEM_DESTROY, + ZERO, +}; + +static const enum index next_config_attr[] = { + CONFIG_QUEUES_NUMBER, + CONFIG_QUEUES_SIZE, + CONFIG_COUNTERS_NUMBER, + CONFIG_AGING_OBJECTS_NUMBER, + CONFIG_METERS_NUMBER, + END, + ZERO, +}; + +static const enum index next_pt_subcmd[] = { + PATTERN_TEMPLATE_CREATE, + PATTERN_TEMPLATE_DESTROY, + ZERO, +}; + +static const enum index next_pt_attr[] = { + PATTERN_TEMPLATE_CREATE_ID, + PATTERN_TEMPLATE_RELAXED_MATCHING, + PATTERN_TEMPLATE_INGRESS, + PATTERN_TEMPLATE_EGRESS, + PATTERN_TEMPLATE_TRANSFER, + PATTERN_TEMPLATE_SPEC, + ZERO, +}; + +static const enum index next_pt_destroy_attr[] = { + PATTERN_TEMPLATE_DESTROY_ID, + END, + ZERO, +}; + +static const enum index next_at_subcmd[] = { + ACTIONS_TEMPLATE_CREATE, + ACTIONS_TEMPLATE_DESTROY, + ZERO, +}; + +static const enum index next_at_attr[] = { + ACTIONS_TEMPLATE_CREATE_ID, + ACTIONS_TEMPLATE_INGRESS, + ACTIONS_TEMPLATE_EGRESS, + ACTIONS_TEMPLATE_TRANSFER, + ACTIONS_TEMPLATE_SPEC, + ZERO, +}; + +static const enum index next_at_destroy_attr[] = { + ACTIONS_TEMPLATE_DESTROY_ID, + END, + ZERO, +}; + +static const enum index next_table_subcmd[] = { + TABLE_CREATE, + TABLE_DESTROY, + ZERO, +}; + +static const enum index next_table_attr[] = { + TABLE_CREATE_ID, + TABLE_GROUP, + TABLE_PRIORITY, + TABLE_INGRESS, + TABLE_EGRESS, + TABLE_TRANSFER, + TABLE_RULES_NUMBER, + TABLE_PATTERN_TEMPLATE, + TABLE_ACTIONS_TEMPLATE, + END, + ZERO, +}; + +static const enum index next_table_destroy_attr[] = { + TABLE_DESTROY_ID, + END, + ZERO, +}; + +static const enum index next_queue_subcmd[] = { + QUEUE_CREATE, + QUEUE_DESTROY, + QUEUE_INDIRECT_ACTION, + ZERO, +}; + +static const enum index next_queue_destroy_attr[] = { + QUEUE_DESTROY_ID, + END, + ZERO, +}; + +static const enum index next_qia_subcmd[] = { + QUEUE_INDIRECT_ACTION_CREATE, + QUEUE_INDIRECT_ACTION_UPDATE, + QUEUE_INDIRECT_ACTION_DESTROY, + ZERO, +}; + +static const enum index next_qia_create_attr[] = { + QUEUE_INDIRECT_ACTION_CREATE_ID, + QUEUE_INDIRECT_ACTION_INGRESS, + QUEUE_INDIRECT_ACTION_EGRESS, + QUEUE_INDIRECT_ACTION_TRANSFER, + QUEUE_INDIRECT_ACTION_CREATE_POSTPONE, + QUEUE_INDIRECT_ACTION_SPEC, + ZERO, +}; + +static const enum index next_qia_update_attr[] = { + QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE, + QUEUE_INDIRECT_ACTION_SPEC, + ZERO, +}; + +static const enum index next_qia_destroy_attr[] = { + QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE, + QUEUE_INDIRECT_ACTION_DESTROY_ID, + END, + ZERO, +}; + static const enum index next_ia_create_attr[] = { INDIRECT_ACTION_CREATE_ID, INDIRECT_ACTION_INGRESS, @@ -870,14 +1221,14 @@ static const enum index next_ia_subcmd[] = { }; static const enum index next_vc_attr[] = { - GROUP, - PRIORITY, - INGRESS, - EGRESS, - TRANSFER, - TUNNEL_SET, - TUNNEL_MATCH, - PATTERN, + VC_GROUP, + VC_PRIORITY, + VC_INGRESS, + VC_EGRESS, + VC_TRANSFER, + VC_TUNNEL_SET, + VC_TUNNEL_MATCH, + ITEM_PATTERN, ZERO, }; @@ -888,7 +1239,7 @@ static const enum index next_destroy_attr[] = { }; static const enum index next_dump_attr[] = { - FILE_PATH, + COMMON_FILE_PATH, END, ZERO, }; @@ -961,6 +1312,7 @@ static const enum index next_item[] = { ITEM_ICMP6_ND_OPT_TLA_ETH, ITEM_META, ITEM_GRE_KEY, + ITEM_GRE_OPTION, ITEM_GTP_PSC, ITEM_PPPOES, ITEM_PPPOED, @@ -974,6 +1326,12 @@ static const enum index next_item[] = { ITEM_ECPRI, ITEM_GENEVE_OPT, ITEM_INTEGRITY, + ITEM_CONNTRACK, + ITEM_PORT_REPRESENTOR, + ITEM_REPRESENTED_PORT, + ITEM_FLEX, + ITEM_L2TPV2, + ITEM_PPP, END_SET, ZERO, }; @@ -1020,6 +1378,7 @@ static const enum index item_raw[] = { ITEM_RAW_OFFSET, ITEM_RAW_LIMIT, ITEM_RAW_PATTERN, + ITEM_RAW_PATTERN_HEX, ITEM_NEXT, ZERO, }; @@ -1045,6 +1404,7 @@ static const enum index item_vlan[] = { }; static const enum index item_ipv4[] = { + ITEM_IPV4_VER_IHL, ITEM_IPV4_TOS, ITEM_IPV4_ID, ITEM_IPV4_FRAGMENT_OFFSET, @@ -1103,6 +1463,7 @@ static const enum index item_sctp[] = { static const enum index item_vxlan[] = { ITEM_VXLAN_VNI, + ITEM_VXLAN_LAST_RSVD, ITEM_NEXT, ZERO, }; @@ -1143,6 +1504,14 @@ static const enum index item_gre_key[] = { ZERO, }; +static const enum index item_gre_option[] = { + ITEM_GRE_OPTION_CHECKSUM, + ITEM_GRE_OPTION_KEY, + ITEM_GRE_OPTION_SEQUENCE, + ITEM_NEXT, + ZERO, +}; + static const enum index item_gtp[] = { ITEM_GTP_FLAGS, ITEM_GTP_MSG_TYPE, @@ -1340,6 +1709,101 @@ static const enum index item_integrity_lv[] = { ZERO, }; +static const enum index item_port_representor[] = { + ITEM_PORT_REPRESENTOR_PORT_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_represented_port[] = { + ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_flex[] = { + ITEM_FLEX_PATTERN_HANDLE, + ITEM_FLEX_ITEM_HANDLE, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2[] = { + ITEM_L2TPV2_TYPE, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type[] = { + ITEM_L2TPV2_TYPE_DATA, + ITEM_L2TPV2_TYPE_DATA_L, + ITEM_L2TPV2_TYPE_DATA_S, + ITEM_L2TPV2_TYPE_DATA_O, + ITEM_L2TPV2_TYPE_DATA_L_S, + ITEM_L2TPV2_TYPE_CTRL, + ZERO, +}; + +static const enum index item_l2tpv2_type_data[] = { + ITEM_L2TPV2_MSG_DATA_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_SESSION_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_l[] = { + ITEM_L2TPV2_MSG_DATA_L_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_SESSION_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_s[] = { + ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_S_NS, + ITEM_L2TPV2_MSG_DATA_S_NR, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_o[] = { + ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_O_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_O_OFFSET, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_l_s[] = { + ITEM_L2TPV2_MSG_DATA_L_S_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_L_S_NS, + ITEM_L2TPV2_MSG_DATA_L_S_NR, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_ctrl[] = { + ITEM_L2TPV2_MSG_CTRL_LENGTH, + ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID, + ITEM_L2TPV2_MSG_CTRL_SESSION_ID, + ITEM_L2TPV2_MSG_CTRL_NS, + ITEM_L2TPV2_MSG_CTRL_NR, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_ppp[] = { + ITEM_PPP_ADDR, + ITEM_PPP_CTRL, + ITEM_PPP_PROTO_ID, + ITEM_NEXT, + ZERO, +}; + static const enum index next_action[] = { ACTION_END, ACTION_VOID, @@ -1356,6 +1820,7 @@ static const enum index next_action[] = { 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, @@ -1403,6 +1868,10 @@ static const enum index next_action[] = { ACTION_SAMPLE, ACTION_INDIRECT, ACTION_MODIFY_FIELD, + ACTION_CONNTRACK, + ACTION_CONNTRACK_UPDATE, + ACTION_PORT_REPRESENTOR, + ACTION_REPRESENTED_PORT, ZERO, }; @@ -1420,7 +1889,6 @@ static const enum index action_queue[] = { static const enum index action_count[] = { ACTION_COUNT_ID, - ACTION_COUNT_SHARED, ACTION_NEXT, ZERO, }; @@ -1463,6 +1931,12 @@ static const enum index action_meter[] = { 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, @@ -1667,10 +2141,30 @@ static const enum index action_modify_field_src[] = { ACTION_MODIFY_FIELD_SRC_LEVEL, ACTION_MODIFY_FIELD_SRC_OFFSET, ACTION_MODIFY_FIELD_SRC_VALUE, + ACTION_MODIFY_FIELD_SRC_POINTER, ACTION_MODIFY_FIELD_WIDTH, ZERO, }; +static const enum index action_update_conntrack[] = { + ACTION_CONNTRACK_UPDATE_DIR, + ACTION_CONNTRACK_UPDATE_CTX, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_port_representor[] = { + ACTION_PORT_REPRESENTOR_PORT_ID, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_represented_port[] = { + ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID, + ACTION_NEXT, + ZERO, +}; + static int parse_set_raw_encap_decap(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1680,6 +2174,9 @@ static int parse_set_sample_action(struct context *, const struct token *, static int parse_set_init(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int +parse_flex_handle(struct context *, const struct token *, + const char *, unsigned int, void *, unsigned int); static int parse_init(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1693,6 +2190,13 @@ static int parse_vc_conf(struct context *, const struct token *, static int parse_vc_item_ecpri_type(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_vc_item_l2tpv2_type(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_vc_action_meter_color_type(struct context *, + const struct token *, + const char *, unsigned int, void *, + unsigned int); static int parse_vc_action_rss(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1761,6 +2265,10 @@ 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); @@ -1785,9 +2293,43 @@ static int parse_aged(struct context *, const struct token *, static int parse_isolate(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_configure(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_template(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_template_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_table(struct context *, const struct token *, + const char *, unsigned int, void *, unsigned int); +static int parse_table_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qo(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qo_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qia(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qia_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_push(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_pull(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); static int parse_tunnel(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_flex(struct context *, const struct token *, + const char *, unsigned int, void *, unsigned int); static int parse_int(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1827,6 +2369,9 @@ static int parse_ia_destroy(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 *, @@ -1849,6 +2394,14 @@ static int comp_set_modify_field_op(struct context *, const struct token *, unsigned int, char *, unsigned int); static int comp_set_modify_field_id(struct context *, const struct token *, unsigned int, char *, unsigned int); +static int comp_pattern_template_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_actions_template_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_table_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_queue_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); /** Token definitions. */ static const struct token token_list[] = { @@ -1856,7 +2409,7 @@ 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 = "", @@ -1874,117 +2427,171 @@ static const struct token token_list[] = { .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, }, - [INDIRECT_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 = "POLICY_ID", + .help = "policy id", + .call = parse_int, + .comp = comp_none, + }, + [COMMON_FLEX_TOKEN] = { + .name = "{flex token}", + .type = "flex token", + .help = "flex token", + .call = parse_int, + .comp = comp_none, + }, + [COMMON_FLEX_HANDLE] = { + .name = "{flex handle}", + .type = "FLEX HANDLE", + .help = "fill flex item data", + .call = parse_flex_handle, + .comp = comp_none, + }, + [COMMON_PATTERN_TEMPLATE_ID] = { + .name = "{pattern_template_id}", + .type = "PATTERN_TEMPLATE_ID", + .help = "pattern template id", + .call = parse_int, + .comp = comp_pattern_template_id, + }, + [COMMON_ACTIONS_TEMPLATE_ID] = { + .name = "{actions_template_id}", + .type = "ACTIONS_TEMPLATE_ID", + .help = "actions template id", + .call = parse_int, + .comp = comp_actions_template_id, + }, + [COMMON_TABLE_ID] = { + .name = "{table_id}", + .type = "TABLE_ID", + .help = "table id", + .call = parse_int, + .comp = comp_table_id, + }, + [COMMON_QUEUE_ID] = { + .name = "{queue_id}", + .type = "QUEUE_ID", + .help = "queue id", + .call = parse_int, + .comp = comp_queue_id, + }, /* Top-level command. */ [FLOW] = { .name = "flow", .type = "{command} {port_id} [{arg} [...]]", .help = "manage ingress/egress flow rules", .next = NEXT(NEXT_ENTRY - (INDIRECT_ACTION, + (INFO, + CONFIGURE, + PATTERN_TEMPLATE, + ACTIONS_TEMPLATE, + TABLE, + INDIRECT_ACTION, VALIDATE, CREATE, DESTROY, @@ -1994,116 +2601,655 @@ static const struct token token_list[] = { AGED, QUERY, ISOLATE, - TUNNEL)), + TUNNEL, + FLEX, + QUEUE, + PUSH, + PULL)), .call = parse_init, }, /* Top-level command. */ - [INDIRECT_ACTION] = { - .name = "indirect_action", + [INFO] = { + .name = "info", + .help = "get information about flow engine", + .next = NEXT(NEXT_ENTRY(END), + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_configure, + }, + /* Top-level command. */ + [CONFIGURE] = { + .name = "configure", + .help = "configure flow engine", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_configure, + }, + /* Configure arguments. */ + [CONFIG_QUEUES_NUMBER] = { + .name = "queues_number", + .help = "number of queues", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.nb_queue)), + }, + [CONFIG_QUEUES_SIZE] = { + .name = "queues_size", + .help = "number of elements in queues", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.queue_attr.size)), + }, + [CONFIG_COUNTERS_NUMBER] = { + .name = "counters_number", + .help = "number of counters", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.port_attr.nb_counters)), + }, + [CONFIG_AGING_OBJECTS_NUMBER] = { + .name = "aging_counters_number", + .help = "number of aging objects", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.port_attr.nb_aging_objects)), + }, + [CONFIG_METERS_NUMBER] = { + .name = "meters_number", + .help = "number of meters", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.port_attr.nb_meters)), + }, + /* Top-level command. */ + [PATTERN_TEMPLATE] = { + .name = "pattern_template", .type = "{command} {port_id} [{arg} [...]]", - .help = "manage indirect actions", - .next = NEXT(next_ia_subcmd, NEXT_ENTRY(PORT_ID)), + .help = "manage pattern templates", + .next = NEXT(next_pt_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_ia, + .call = parse_template, }, /* Sub-level commands. */ - [INDIRECT_ACTION_CREATE] = { + [PATTERN_TEMPLATE_CREATE] = { .name = "create", - .help = "create indirect action", - .next = NEXT(next_ia_create_attr), - .call = parse_ia, - }, - [INDIRECT_ACTION_UPDATE] = { - .name = "update", - .help = "update indirect action", - .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_SPEC), - NEXT_ENTRY(INDIRECT_ACTION_ID)), - .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), - .call = parse_ia, + .help = "create pattern template", + .next = NEXT(next_pt_attr), + .call = parse_template, }, - [INDIRECT_ACTION_DESTROY] = { + [PATTERN_TEMPLATE_DESTROY] = { .name = "destroy", - .help = "destroy indirect action", - .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_DESTROY_ID)), + .help = "destroy pattern template", + .next = NEXT(NEXT_ENTRY(PATTERN_TEMPLATE_DESTROY_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_ia_destroy, + .call = parse_template_destroy, + }, + /* Pattern template arguments. */ + [PATTERN_TEMPLATE_CREATE_ID] = { + .name = "pattern_template_id", + .help = "specify a pattern template id to create", + .next = NEXT(next_pt_attr, + NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.pat_templ_id)), + }, + [PATTERN_TEMPLATE_DESTROY_ID] = { + .name = "pattern_template", + .help = "specify a pattern template id to destroy", + .next = NEXT(next_pt_destroy_attr, + NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.templ_destroy.template_id)), + .call = parse_template_destroy, + }, + [PATTERN_TEMPLATE_RELAXED_MATCHING] = { + .name = "relaxed", + .help = "is matching relaxed", + .next = NEXT(next_pt_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY_BF(struct buffer, + args.vc.attr.reserved, 1)), + }, + [PATTERN_TEMPLATE_INGRESS] = { + .name = "ingress", + .help = "attribute pattern to ingress", + .next = NEXT(next_pt_attr), + .call = parse_template, }, - [INDIRECT_ACTION_QUERY] = { - .name = "query", - .help = "query indirect action", - .next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(INDIRECT_ACTION_ID)), - .args = ARGS(ARGS_ENTRY(struct buffer, args.ia.action_id)), - .call = parse_ia, + [PATTERN_TEMPLATE_EGRESS] = { + .name = "egress", + .help = "attribute pattern to egress", + .next = NEXT(next_pt_attr), + .call = parse_template, }, - [VALIDATE] = { - .name = "validate", - .help = "check whether a flow rule can be created", - .next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)), + [PATTERN_TEMPLATE_TRANSFER] = { + .name = "transfer", + .help = "attribute pattern to transfer", + .next = NEXT(next_pt_attr), + .call = parse_template, + }, + [PATTERN_TEMPLATE_SPEC] = { + .name = "template", + .help = "specify item to create pattern template", + .next = NEXT(next_item), + }, + /* Top-level command. */ + [ACTIONS_TEMPLATE] = { + .name = "actions_template", + .type = "{command} {port_id} [{arg} [...]]", + .help = "manage actions templates", + .next = NEXT(next_at_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_vc, + .call = parse_template, }, - [CREATE] = { + /* Sub-level commands. */ + [ACTIONS_TEMPLATE_CREATE] = { .name = "create", - .help = "create a flow rule", - .next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)), - .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_vc, + .help = "create actions template", + .next = NEXT(next_at_attr), + .call = parse_template, }, - [DESTROY] = { + [ACTIONS_TEMPLATE_DESTROY] = { .name = "destroy", - .help = "destroy specific flow rules", - .next = NEXT(NEXT_ENTRY(DESTROY_RULE), NEXT_ENTRY(PORT_ID)), + .help = "destroy actions template", + .next = NEXT(NEXT_ENTRY(ACTIONS_TEMPLATE_DESTROY_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_destroy, + .call = parse_template_destroy, + }, + /* Actions template arguments. */ + [ACTIONS_TEMPLATE_CREATE_ID] = { + .name = "actions_template_id", + .help = "specify an actions template id to create", + .next = NEXT(NEXT_ENTRY(ACTIONS_TEMPLATE_MASK), + NEXT_ENTRY(ACTIONS_TEMPLATE_SPEC), + NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.act_templ_id)), + }, + [ACTIONS_TEMPLATE_DESTROY_ID] = { + .name = "actions_template", + .help = "specify an actions template id to destroy", + .next = NEXT(next_at_destroy_attr, + NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.templ_destroy.template_id)), + .call = parse_template_destroy, }, - [FLUSH] = { - .name = "flush", - .help = "destroy all flow rules", - .next = NEXT(NEXT_ENTRY(PORT_ID)), - .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_flush, + [ACTIONS_TEMPLATE_INGRESS] = { + .name = "ingress", + .help = "attribute actions to ingress", + .next = NEXT(next_at_attr), + .call = parse_template, }, - [DUMP] = { - .name = "dump", - .help = "dump single/all flow rules to file", - .next = NEXT(next_dump_subcmd, NEXT_ENTRY(PORT_ID)), - .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_dump, + [ACTIONS_TEMPLATE_EGRESS] = { + .name = "egress", + .help = "attribute actions to egress", + .next = NEXT(next_at_attr), + .call = parse_template, }, - [QUERY] = { - .name = "query", - .help = "query an existing flow rule", - .next = NEXT(NEXT_ENTRY(QUERY_ACTION), - NEXT_ENTRY(RULE_ID), - NEXT_ENTRY(PORT_ID)), - .args = ARGS(ARGS_ENTRY(struct buffer, args.query.action.type), - ARGS_ENTRY(struct buffer, args.query.rule), - ARGS_ENTRY(struct buffer, port)), - .call = parse_query, + [ACTIONS_TEMPLATE_TRANSFER] = { + .name = "transfer", + .help = "attribute actions to transfer", + .next = NEXT(next_at_attr), + .call = parse_template, }, - [LIST] = { - .name = "list", - .help = "list existing flow rules", - .next = NEXT(next_list_attr, NEXT_ENTRY(PORT_ID)), + [ACTIONS_TEMPLATE_SPEC] = { + .name = "template", + .help = "specify action to create actions template", + .next = NEXT(next_action), + .call = parse_template, + }, + [ACTIONS_TEMPLATE_MASK] = { + .name = "mask", + .help = "specify action mask to create actions template", + .next = NEXT(next_action), + .call = parse_template, + }, + /* Top-level command. */ + [TABLE] = { + .name = "template_table", + .type = "{command} {port_id} [{arg} [...]]", + .help = "manage template tables", + .next = NEXT(next_table_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), - .call = parse_list, + .call = parse_table, + }, + /* Sub-level commands. */ + [TABLE_CREATE] = { + .name = "create", + .help = "create template table", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_DESTROY] = { + .name = "destroy", + .help = "destroy template table", + .next = NEXT(NEXT_ENTRY(TABLE_DESTROY_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_table_destroy, + }, + /* Table arguments. */ + [TABLE_CREATE_ID] = { + .name = "table_id", + .help = "specify table id to create", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_TABLE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.table.id)), + }, + [TABLE_DESTROY_ID] = { + .name = "table", + .help = "specify table id to destroy", + .next = NEXT(next_table_destroy_attr, + NEXT_ENTRY(COMMON_TABLE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.table_destroy.table_id)), + .call = parse_table_destroy, + }, + [TABLE_GROUP] = { + .name = "group", + .help = "specify a group", + .next = NEXT(next_table_attr, NEXT_ENTRY(COMMON_GROUP_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.table.attr.flow_attr.group)), + }, + [TABLE_PRIORITY] = { + .name = "priority", + .help = "specify a priority level", + .next = NEXT(next_table_attr, NEXT_ENTRY(COMMON_PRIORITY_LEVEL)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.table.attr.flow_attr.priority)), + }, + [TABLE_EGRESS] = { + .name = "egress", + .help = "affect rule to egress", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_INGRESS] = { + .name = "ingress", + .help = "affect rule to ingress", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_TRANSFER] = { + .name = "transfer", + .help = "affect rule to transfer", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_RULES_NUMBER] = { + .name = "rules_number", + .help = "number of rules in table", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.table.attr.nb_flows)), + }, + [TABLE_PATTERN_TEMPLATE] = { + .name = "pattern_template", + .help = "specify pattern template id", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.table.pat_templ_id)), + .call = parse_table, + }, + [TABLE_ACTIONS_TEMPLATE] = { + .name = "actions_template", + .help = "specify actions template id", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.table.act_templ_id)), + .call = parse_table, + }, + /* Top-level command. */ + [QUEUE] = { + .name = "queue", + .help = "queue a flow rule operation", + .next = NEXT(next_queue_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_qo, + }, + /* Sub-level commands. */ + [QUEUE_CREATE] = { + .name = "create", + .help = "create a flow rule", + .next = NEXT(NEXT_ENTRY(QUEUE_TEMPLATE_TABLE), + NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + .call = parse_qo, + }, + [QUEUE_DESTROY] = { + .name = "destroy", + .help = "destroy a flow rule", + .next = NEXT(NEXT_ENTRY(QUEUE_DESTROY_ID), + NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + .call = parse_qo_destroy, + }, + [QUEUE_INDIRECT_ACTION] = { + .name = "indirect_action", + .help = "queue indirect actions", + .next = NEXT(next_qia_subcmd, NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + .call = parse_qia, + }, + /* Queue arguments. */ + [QUEUE_TEMPLATE_TABLE] = { + .name = "template table", + .help = "specify table id", + .next = NEXT(NEXT_ENTRY(QUEUE_PATTERN_TEMPLATE), + NEXT_ENTRY(COMMON_TABLE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.vc.table_id)), + .call = parse_qo, + }, + [QUEUE_PATTERN_TEMPLATE] = { + .name = "pattern_template", + .help = "specify pattern template index", + .next = NEXT(NEXT_ENTRY(QUEUE_ACTIONS_TEMPLATE), + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.vc.pat_templ_id)), + .call = parse_qo, + }, + [QUEUE_ACTIONS_TEMPLATE] = { + .name = "actions_template", + .help = "specify actions template index", + .next = NEXT(NEXT_ENTRY(QUEUE_CREATE_POSTPONE), + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.vc.act_templ_id)), + .call = parse_qo, + }, + [QUEUE_CREATE_POSTPONE] = { + .name = "postpone", + .help = "postpone create operation", + .next = NEXT(NEXT_ENTRY(ITEM_PATTERN), + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + .call = parse_qo, + }, + [QUEUE_DESTROY_POSTPONE] = { + .name = "postpone", + .help = "postpone destroy operation", + .next = NEXT(NEXT_ENTRY(QUEUE_DESTROY_ID), + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + .call = parse_qo_destroy, + }, + [QUEUE_DESTROY_ID] = { + .name = "rule", + .help = "specify rule id to destroy", + .next = NEXT(next_queue_destroy_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.destroy.rule)), + .call = parse_qo_destroy, + }, + /* Queue indirect action arguments */ + [QUEUE_INDIRECT_ACTION_CREATE] = { + .name = "create", + .help = "create indirect action", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_UPDATE] = { + .name = "update", + .help = "update indirect action", + .next = NEXT(next_qia_update_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_DESTROY] = { + .name = "destroy", + .help = "destroy indirect action", + .next = NEXT(next_qia_destroy_attr), + .call = parse_qia_destroy, + }, + /* Indirect action destroy arguments. */ + [QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE] = { + .name = "postpone", + .help = "postpone destroy operation", + .next = NEXT(next_qia_destroy_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + }, + [QUEUE_INDIRECT_ACTION_DESTROY_ID] = { + .name = "action_id", + .help = "specify a indirect action id to destroy", + .next = NEXT(next_qia_destroy_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.ia_destroy.action_id)), + .call = parse_qia_destroy, + }, + /* Indirect action update arguments. */ + [QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE] = { + .name = "postpone", + .help = "postpone update operation", + .next = NEXT(next_qia_update_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + }, + /* Indirect action create arguments. */ + [QUEUE_INDIRECT_ACTION_CREATE_ID] = { + .name = "action_id", + .help = "specify a indirect action id to create", + .next = NEXT(next_qia_create_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), + }, + [QUEUE_INDIRECT_ACTION_INGRESS] = { + .name = "ingress", + .help = "affect rule to ingress", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_EGRESS] = { + .name = "egress", + .help = "affect rule to egress", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_TRANSFER] = { + .name = "transfer", + .help = "affect rule to transfer", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_CREATE_POSTPONE] = { + .name = "postpone", + .help = "postpone create operation", + .next = NEXT(next_qia_create_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + }, + [QUEUE_INDIRECT_ACTION_SPEC] = { + .name = "action", + .help = "specify action to create indirect handle", + .next = NEXT(next_action), + }, + /* Top-level command. */ + [PUSH] = { + .name = "push", + .help = "push enqueued operations", + .next = NEXT(NEXT_ENTRY(PUSH_QUEUE), NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_push, + }, + /* Sub-level commands. */ + [PUSH_QUEUE] = { + .name = "queue", + .help = "specify queue id", + .next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + }, + /* Top-level command. */ + [PULL] = { + .name = "pull", + .help = "pull flow operations results", + .next = NEXT(NEXT_ENTRY(PULL_QUEUE), NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_pull, + }, + /* Sub-level commands. */ + [PULL_QUEUE] = { + .name = "queue", + .help = "specify queue id", + .next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + }, + /* Top-level command. */ + [INDIRECT_ACTION] = { + .name = "indirect_action", + .type = "{command} {port_id} [{arg} [...]]", + .help = "manage indirect actions", + .next = NEXT(next_ia_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_ia, + }, + /* Sub-level commands. */ + [INDIRECT_ACTION_CREATE] = { + .name = "create", + .help = "create indirect action", + .next = NEXT(next_ia_create_attr), + .call = parse_ia, + }, + [INDIRECT_ACTION_UPDATE] = { + .name = "update", + .help = "update indirect action", + .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_SPEC), + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), + .call = parse_ia, + }, + [INDIRECT_ACTION_DESTROY] = { + .name = "destroy", + .help = "destroy indirect action", + .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_DESTROY_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_ia_destroy, + }, + [INDIRECT_ACTION_QUERY] = { + .name = "query", + .help = "query indirect action", + .next = NEXT(NEXT_ENTRY(END), + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.ia.action_id)), + .call = parse_ia, + }, + [VALIDATE] = { + .name = "validate", + .help = "check whether a flow rule can be created", + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_vc, + }, + [CREATE] = { + .name = "create", + .help = "create a flow rule", + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_vc, + }, + [DESTROY] = { + .name = "destroy", + .help = "destroy specific flow rules", + .next = NEXT(NEXT_ENTRY(DESTROY_RULE), + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_destroy, + }, + [FLUSH] = { + .name = "flush", + .help = "destroy all flow rules", + .next = NEXT(NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_flush, + }, + [DUMP] = { + .name = "dump", + .help = "dump single/all flow rules to file", + .next = NEXT(next_dump_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_dump, + }, + [QUERY] = { + .name = "query", + .help = "query an existing flow rule", + .next = NEXT(NEXT_ENTRY(QUERY_ACTION), + NEXT_ENTRY(COMMON_RULE_ID), + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.query.action.type), + ARGS_ENTRY(struct buffer, args.query.rule), + ARGS_ENTRY(struct buffer, port)), + .call = parse_query, + }, + [LIST] = { + .name = "list", + .help = "list existing flow rules", + .next = NEXT(next_list_attr, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_list, }, [AGED] = { .name = "aged", .help = "list and destroy aged flows", - .next = NEXT(next_aged_attr, NEXT_ENTRY(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, }, + [FLEX] = { + .name = "flex_item", + .help = "flex item API", + .next = NEXT(next_flex_item), + .call = parse_flex, + }, + [FLEX_ITEM_INIT] = { + .name = "init", + .help = "flex item init", + .args = ARGS(ARGS_ENTRY(struct buffer, args.flex.token), + ARGS_ENTRY(struct buffer, port)), + .next = NEXT(NEXT_ENTRY(COMMON_FLEX_TOKEN), + NEXT_ENTRY(COMMON_PORT_ID)), + .call = parse_flex + }, + [FLEX_ITEM_CREATE] = { + .name = "create", + .help = "flex item create", + .args = ARGS(ARGS_ENTRY(struct buffer, args.flex.filename), + ARGS_ENTRY(struct buffer, args.flex.token), + ARGS_ENTRY(struct buffer, port)), + .next = NEXT(NEXT_ENTRY(COMMON_FILE_PATH), + NEXT_ENTRY(COMMON_FLEX_TOKEN), + NEXT_ENTRY(COMMON_PORT_ID)), + .call = parse_flex + }, + [FLEX_ITEM_DESTROY] = { + .name = "destroy", + .help = "flex item destroy", + .args = ARGS(ARGS_ENTRY(struct buffer, args.flex.token), + ARGS_ENTRY(struct buffer, port)), + .next = NEXT(NEXT_ENTRY(COMMON_FLEX_TOKEN), + NEXT_ENTRY(COMMON_PORT_ID)), + .call = parse_flex + }, [TUNNEL] = { .name = "tunnel", .help = "new tunnel API", @@ -2116,36 +3262,36 @@ static const struct token token_list[] = { .name = "create", .help = "create new tunnel object", .next = NEXT(NEXT_ENTRY(TUNNEL_CREATE_TYPE), - NEXT_ENTRY(PORT_ID)), + 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(FILE_PATH)), + .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", + .help = "destroy tunnel", .next = NEXT(NEXT_ENTRY(TUNNEL_DESTROY_ID), - NEXT_ENTRY(PORT_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(UNSIGNED)), + .help = "tunnel identifier to destroy", + .next = NEXT(NEXT_ENTRY(COMMON_UNSIGNED)), .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)), .call = parse_tunnel, }, [TUNNEL_LIST] = { .name = "list", .help = "list existing tunnels", - .next = NEXT(NEXT_ENTRY(PORT_ID)), + .next = NEXT(NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), .call = parse_tunnel, }, @@ -2153,7 +3299,7 @@ static const struct token token_list[] = { [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, }, @@ -2168,7 +3314,7 @@ static const struct token token_list[] = { [DUMP_ONE] = { .name = "rule", .help = "dump one rule", - .next = NEXT(next_dump_attr, NEXT_ENTRY(RULE_ID)), + .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, @@ -2185,7 +3331,7 @@ static const struct token token_list[] = { [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, }, @@ -2196,54 +3342,54 @@ static const struct token token_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, }, - [TUNNEL_SET] = { + [VC_TUNNEL_SET] = { .name = "tunnel_set", .help = "tunnel steer rule", - .next = NEXT(next_vc_attr, NEXT_ENTRY(UNSIGNED)), + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_UNSIGNED)), .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)), .call = parse_vc, }, - [TUNNEL_MATCH] = { + [VC_TUNNEL_MATCH] = { .name = "tunnel_match", .help = "tunnel match rule", - .next = NEXT(next_vc_attr, NEXT_ENTRY(UNSIGNED)), + .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), @@ -2283,7 +3429,7 @@ static const struct token token_list[] = { .name = "end", .help = "end list of pattern items", .priv = PRIV_ITEM(END, 0), - .next = NEXT(NEXT_ENTRY(ACTIONS)), + .next = NEXT(NEXT_ENTRY(ACTIONS, END)), .call = parse_vc, }, [ITEM_VOID] = { @@ -2310,7 +3456,7 @@ static const struct token token_list[] = { [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] = { @@ -2330,7 +3476,7 @@ static const struct token token_list[] = { [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] = { @@ -2344,7 +3490,8 @@ static const struct token token_list[] = { [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] = { @@ -2358,7 +3505,8 @@ static const struct token token_list[] = { [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] = { @@ -2371,7 +3519,8 @@ static const struct token token_list[] = { [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] = { @@ -2384,34 +3533,47 @@ static const struct token token_list[] = { [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)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, pattern), + ARGS_ENTRY(struct rte_flow_item_raw, length), + ARGS_ENTRY_ARB(sizeof(struct rte_flow_item_raw), + ITEM_RAW_PATTERN_SIZE)), + }, + [ITEM_RAW_PATTERN_HEX] = { + .name = "pattern_hex", + .help = "hex string to look for", + .next = NEXT(item_raw, + NEXT_ENTRY(COMMON_HEX), NEXT_ENTRY(ITEM_PARAM_IS, ITEM_PARAM_SPEC, ITEM_PARAM_MASK)), @@ -2430,25 +3592,25 @@ static const struct token token_list[] = { [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)), }, @@ -2462,41 +3624,47 @@ static const struct token token_list[] = { [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)), }, @@ -2507,52 +3675,67 @@ static const struct token token_list[] = { .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(UNSIGNED), item_param), + .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)), }, @@ -2566,7 +3749,8 @@ static const struct token token_list[] = { [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")), @@ -2574,7 +3758,8 @@ static const struct token token_list[] = { [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")), @@ -2582,35 +3767,40 @@ static const struct token token_list[] = { [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)), }, @@ -2624,28 +3814,32 @@ static const struct token token_list[] = { [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)), }, @@ -2659,14 +3853,15 @@ static const struct token token_list[] = { [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)), }, @@ -2680,21 +3875,21 @@ static const struct token token_list[] = { [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)), }, @@ -2708,28 +3903,32 @@ static const struct token token_list[] = { [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)), }, @@ -2743,9 +3942,18 @@ static const struct token token_list[] = { [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", @@ -2756,7 +3964,8 @@ static const struct token token_list[] = { [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")), @@ -2771,7 +3980,8 @@ static const struct token token_list[] = { [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] = { @@ -2784,7 +3994,8 @@ static const struct token token_list[] = { [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")), @@ -2792,7 +4003,8 @@ static const struct token token_list[] = { [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")), @@ -2800,7 +4012,8 @@ static const struct token token_list[] = { [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")), @@ -2815,7 +4028,8 @@ static const struct token token_list[] = { [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)), }, @@ -2825,14 +4039,16 @@ static const struct token token_list[] = { "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")), @@ -2840,7 +4056,7 @@ static const struct token token_list[] = { [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")), @@ -2848,7 +4064,7 @@ static const struct token token_list[] = { [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")), @@ -2864,7 +4080,8 @@ static const struct token token_list[] = { [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)), }, @@ -2878,20 +4095,20 @@ static const struct token token_list[] = { [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] = { @@ -2918,20 +4135,23 @@ static const struct token token_list[] = { [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(UNSIGNED), item_param), + .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")), @@ -2947,7 +4167,8 @@ static const struct token token_list[] = { [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)), }, @@ -2962,7 +4183,7 @@ static const struct token token_list[] = { [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)), @@ -2970,7 +4191,7 @@ static const struct token token_list[] = { [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)), @@ -2978,7 +4199,7 @@ static const struct token token_list[] = { [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)), @@ -2986,7 +4207,7 @@ static const struct token token_list[] = { [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)), @@ -3002,7 +4223,8 @@ static const struct token token_list[] = { [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)), }, @@ -3017,7 +4239,7 @@ static const struct token token_list[] = { [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)), @@ -3025,7 +4247,7 @@ static const struct token token_list[] = { [ITEM_IPV6_FRAG_EXT_FRAG_DATA] = { .name = "frag_data", .help = "fragment flags and offset", - .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_HTON(struct rte_flow_item_ipv6_frag_ext, hdr.frag_data)), @@ -3033,7 +4255,7 @@ static const struct token token_list[] = { [ITEM_IPV6_FRAG_EXT_ID] = { .name = "packet_id", .help = "fragment packet id", - .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_HTON(struct rte_flow_item_ipv6_frag_ext, hdr.id)), @@ -3048,14 +4270,16 @@ static const struct token token_list[] = { [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)), }, @@ -3070,7 +4294,7 @@ static const struct token token_list[] = { [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)), @@ -3086,7 +4310,7 @@ static const struct token token_list[] = { [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)), @@ -3103,7 +4327,7 @@ static const struct token token_list[] = { [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)), @@ -3121,8 +4345,8 @@ static const struct token token_list[] = { [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)), }, @@ -3139,8 +4363,8 @@ static const struct token token_list[] = { [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)), }, @@ -3154,7 +4378,8 @@ static const struct token token_list[] = { [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")), }, @@ -3168,9 +4393,42 @@ static const struct token token_list[] = { [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_GRE_OPTION] = { + .name = "gre_option", + .help = "match GRE optional fields", + .priv = PRIV_ITEM(GRE_OPTION, + sizeof(struct rte_flow_item_gre_opt)), + .next = NEXT(item_gre_option), + .call = parse_vc, + }, + [ITEM_GRE_OPTION_CHECKSUM] = { + .name = "checksum", + .help = "match GRE checksum", + .next = NEXT(item_gre_option, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre_opt, + checksum_rsvd.checksum)), + }, + [ITEM_GRE_OPTION_KEY] = { + .name = "key", + .help = "match GRE key", + .next = NEXT(item_gre_option, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre_opt, + key.key)), + }, + [ITEM_GRE_OPTION_SEQUENCE] = { + .name = "sequence", + .help = "match GRE sequence", + .next = NEXT(item_gre_option, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre_opt, + sequence.sequence)), + }, [ITEM_GTP_PSC] = { .name = "gtp_psc", .help = "match GTP extension header with type 0x85", @@ -3182,16 +4440,18 @@ static const struct token token_list[] = { [ITEM_GTP_PSC_QFI] = { .name = "qfi", .help = "QoS flow identifier", - .next = NEXT(item_gtp_psc, NEXT_ENTRY(UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp_psc, - qfi)), + .next = NEXT(item_gtp_psc, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_gtp_psc, + hdr.qfi, 6)), }, [ITEM_GTP_PSC_PDU_T] = { .name = "pdu_t", .help = "PDU type", - .next = NEXT(item_gtp_psc, NEXT_ENTRY(UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp_psc, - pdu_type)), + .next = NEXT(item_gtp_psc, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_gtp_psc, + hdr.type, 4)), }, [ITEM_PPPOES] = { .name = "pppoes", @@ -3210,7 +4470,8 @@ static const struct token token_list[] = { [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)), }, @@ -3219,7 +4480,7 @@ static const struct token token_list[] = { .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)), @@ -3236,14 +4497,16 @@ static const struct token token_list[] = { [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)), }, @@ -3257,13 +4520,13 @@ static const struct token token_list[] = { [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)), }, @@ -3278,7 +4541,8 @@ static const struct token token_list[] = { [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)), }, @@ -3292,7 +4556,7 @@ static const struct token token_list[] = { [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)), }, @@ -3306,7 +4570,7 @@ static const struct token token_list[] = { [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] = { @@ -3319,14 +4583,16 @@ static const struct token token_list[] = { [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] = { @@ -3359,7 +4625,7 @@ static const struct token token_list[] = { .help = "Physical Channel ID", .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_IQ_DATA_PCID, ITEM_ECPRI_COMMON, ITEM_NEXT), - NEXT_ENTRY(UNSIGNED), item_param), + NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri, hdr.type0.pc_id)), }, @@ -3375,7 +4641,7 @@ static const struct token token_list[] = { .help = "Real-Time Control Data ID", .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_RTC_CTRL_RTCID, ITEM_ECPRI_COMMON, ITEM_NEXT), - NEXT_ENTRY(UNSIGNED), item_param), + NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri, hdr.type2.rtc_id)), }, @@ -3391,7 +4657,7 @@ static const struct token token_list[] = { .help = "Measurement ID", .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_DLY_MSR_MSRID, ITEM_ECPRI_COMMON, ITEM_NEXT), - NEXT_ENTRY(UNSIGNED), item_param), + NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri, hdr.type5.msr_id)), }, @@ -3407,21 +4673,24 @@ static const struct token token_list[] = { [ITEM_GENEVE_OPT_CLASS] = { .name = "class", .help = "GENEVE option class", - .next = NEXT(item_geneve_opt, NEXT_ENTRY(UNSIGNED), item_param), + .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(UNSIGNED), item_param), + .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(UNSIGNED), item_param), + .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)), @@ -3429,7 +4698,8 @@ static const struct token token_list[] = { [ITEM_GENEVE_OPT_DATA] = { .name = "data", .help = "GENEVE option data pattern", - .next = NEXT(item_geneve_opt, NEXT_ENTRY(HEX), item_param), + .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 @@ -3447,17 +4717,353 @@ static const struct token token_list[] = { [ITEM_INTEGRITY_LEVEL] = { .name = "level", .help = "integrity level", - .next = NEXT(item_integrity_lv, NEXT_ENTRY(UNSIGNED), + .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(UNSIGNED), + .next = NEXT(item_integrity_lv, NEXT_ENTRY(COMMON_UNSIGNED), item_param), .args = ARGS(ARGS_ENTRY(struct rte_flow_item_integrity, value)), }, + [ITEM_CONNTRACK] = { + .name = "conntrack", + .help = "conntrack state", + .next = NEXT(NEXT_ENTRY(ITEM_NEXT), NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_conntrack, flags)), + }, + [ITEM_PORT_REPRESENTOR] = { + .name = "port_representor", + .help = "match traffic entering the embedded switch from the given ethdev", + .priv = PRIV_ITEM(PORT_REPRESENTOR, + sizeof(struct rte_flow_item_ethdev)), + .next = NEXT(item_port_representor), + .call = parse_vc, + }, + [ITEM_PORT_REPRESENTOR_PORT_ID] = { + .name = "port_id", + .help = "ethdev port ID", + .next = NEXT(item_port_representor, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)), + }, + [ITEM_REPRESENTED_PORT] = { + .name = "represented_port", + .help = "match traffic entering the embedded switch from the entity represented by the given ethdev", + .priv = PRIV_ITEM(REPRESENTED_PORT, + sizeof(struct rte_flow_item_ethdev)), + .next = NEXT(item_represented_port), + .call = parse_vc, + }, + [ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID] = { + .name = "ethdev_port_id", + .help = "ethdev port ID", + .next = NEXT(item_represented_port, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)), + }, + [ITEM_FLEX] = { + .name = "flex", + .help = "match flex header", + .priv = PRIV_ITEM(FLEX, sizeof(struct rte_flow_item_flex)), + .next = NEXT(item_flex), + .call = parse_vc, + }, + [ITEM_FLEX_ITEM_HANDLE] = { + .name = "item", + .help = "flex item handle", + .next = NEXT(item_flex, NEXT_ENTRY(COMMON_FLEX_HANDLE), + NEXT_ENTRY(ITEM_PARAM_IS)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_flex, handle)), + }, + [ITEM_FLEX_PATTERN_HANDLE] = { + .name = "pattern", + .help = "flex pattern handle", + .next = NEXT(item_flex, NEXT_ENTRY(COMMON_FLEX_HANDLE), + NEXT_ENTRY(ITEM_PARAM_IS)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_flex, pattern)), + }, + [ITEM_L2TPV2] = { + .name = "l2tpv2", + .help = "match L2TPv2 header", + .priv = PRIV_ITEM(L2TPV2, sizeof(struct rte_flow_item_l2tpv2)), + .next = NEXT(item_l2tpv2), + .call = parse_vc, + }, + [ITEM_L2TPV2_TYPE] = { + .name = "type", + .help = "type of l2tpv2", + .next = NEXT(item_l2tpv2_type), + .args = ARGS(ARG_ENTRY_HTON(struct rte_flow_item_l2tpv2)), + }, + [ITEM_L2TPV2_TYPE_DATA] = { + .name = "data", + .help = "Type #7: data message without any options", + .next = NEXT(item_l2tpv2_type_data), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type7.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type7.session_id)), + }, + [ITEM_L2TPV2_TYPE_DATA_L] = { + .name = "data_l", + .help = "Type #6: data message with length option", + .next = NEXT(item_l2tpv2_type_data_l), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_L_LENGTH] = { + .name = "length", + .help = "message length", + .next = NEXT(item_l2tpv2_type_data_l, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type6.length)), + }, + [ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_l, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type6.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_L_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_l, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type6.session_id)), + }, + [ITEM_L2TPV2_TYPE_DATA_S] = { + .name = "data_s", + .help = "Type #5: data message with ns, nr option", + .next = NEXT(item_l2tpv2_type_data_s), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_S_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.session_id)), + }, + [ITEM_L2TPV2_MSG_DATA_S_NS] = { + .name = "ns", + .help = "sequence number for message", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.ns)), + }, + [ITEM_L2TPV2_MSG_DATA_S_NR] = { + .name = "nr", + .help = "sequence number for next receive message", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.nr)), + }, + [ITEM_L2TPV2_TYPE_DATA_O] = { + .name = "data_o", + .help = "Type #4: data message with offset option", + .next = NEXT(item_l2tpv2_type_data_o), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_o, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type4.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_O_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_o, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.session_id)), + }, + [ITEM_L2TPV2_MSG_DATA_O_OFFSET] = { + .name = "offset_size", + .help = "the size of offset padding", + .next = NEXT(item_l2tpv2_type_data_o, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type4.offset_size)), + }, + [ITEM_L2TPV2_TYPE_DATA_L_S] = { + .name = "data_l_s", + .help = "Type #3: data message contains length, ns, nr " + "options", + .next = NEXT(item_l2tpv2_type_data_l_s), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_L_S_LENGTH] = { + .name = "length", + .help = "message length", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.length)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.session_id)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_NS] = { + .name = "ns", + .help = "sequence number for message", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.ns)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_NR] = { + .name = "nr", + .help = "sequence number for next receive message", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.nr)), + }, + [ITEM_L2TPV2_TYPE_CTRL] = { + .name = "control", + .help = "Type #3: conrtol message contains length, ns, nr " + "options", + .next = NEXT(item_l2tpv2_type_ctrl), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_CTRL_LENGTH] = { + .name = "length", + .help = "message length", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.length)), + }, + [ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_CTRL_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.session_id)), + }, + [ITEM_L2TPV2_MSG_CTRL_NS] = { + .name = "ns", + .help = "sequence number for message", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.ns)), + }, + [ITEM_L2TPV2_MSG_CTRL_NR] = { + .name = "nr", + .help = "sequence number for next receive message", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.nr)), + }, + [ITEM_PPP] = { + .name = "ppp", + .help = "match PPP header", + .priv = PRIV_ITEM(PPP, sizeof(struct rte_flow_item_ppp)), + .next = NEXT(item_ppp), + .call = parse_vc, + }, + [ITEM_PPP_ADDR] = { + .name = "addr", + .help = "PPP address", + .next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, hdr.addr)), + }, + [ITEM_PPP_CTRL] = { + .name = "ctrl", + .help = "PPP control", + .next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, hdr.ctrl)), + }, + [ITEM_PPP_PROTO_ID] = { + .name = "proto_id", + .help = "PPP protocol identifier", + .next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, + hdr.proto_id)), + }, /* Validate/create actions. */ [ACTIONS] = { .name = "actions", @@ -3500,7 +5106,7 @@ static const struct token token_list[] = { [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, }, @@ -3514,7 +5120,7 @@ static const struct token token_list[] = { [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, }, @@ -3536,7 +5142,7 @@ static const struct token token_list[] = { [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, }, @@ -3558,18 +5164,10 @@ static const struct token token_list[] = { [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)), - .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_count, - shared, 1)), - .call = parse_vc_conf, - }, [ACTION_RSS] = { .name = "rss", .help = "spread packets among several queues", @@ -3609,7 +5207,7 @@ static const struct token token_list[] = { [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), @@ -3630,7 +5228,7 @@ static const struct token token_list[] = { [ACTION_RSS_KEY] = { .name = "key", .help = "RSS hash key", - .next = NEXT(action_rss, NEXT_ENTRY(HEX)), + .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), @@ -3645,7 +5243,7 @@ static const struct token token_list[] = { [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), @@ -3683,7 +5281,7 @@ static const struct token token_list[] = { [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, @@ -3691,7 +5289,7 @@ static const struct token token_list[] = { [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, }, @@ -3706,7 +5304,7 @@ static const struct token token_list[] = { [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, @@ -3714,7 +5312,7 @@ static const struct token token_list[] = { [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, @@ -3730,7 +5328,7 @@ static const struct token token_list[] = { [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, @@ -3738,7 +5336,7 @@ static const struct token token_list[] = { [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, }, @@ -3750,10 +5348,41 @@ static const struct token token_list[] = { .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, }, @@ -3769,7 +5398,8 @@ static const struct token token_list[] = { [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, @@ -3793,7 +5423,7 @@ static const struct token token_list[] = { [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, @@ -3838,7 +5468,7 @@ static const struct token token_list[] = { [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)), @@ -3856,7 +5486,8 @@ static const struct token token_list[] = { [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)), @@ -3874,7 +5505,8 @@ static const struct token token_list[] = { [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)), @@ -3891,7 +5523,7 @@ static const struct token token_list[] = { [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)), @@ -3909,7 +5541,7 @@ static const struct token token_list[] = { [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)), @@ -4017,7 +5649,7 @@ static const struct token token_list[] = { [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, @@ -4034,7 +5666,7 @@ static const struct token token_list[] = { [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, @@ -4051,7 +5683,7 @@ static const struct token token_list[] = { [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, @@ -4068,7 +5700,7 @@ static const struct token token_list[] = { [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, @@ -4085,7 +5717,7 @@ static const struct token token_list[] = { [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, @@ -4102,7 +5734,7 @@ static const struct token token_list[] = { [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, @@ -4133,7 +5765,7 @@ static const struct token token_list[] = { [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, @@ -4149,7 +5781,7 @@ static const struct token token_list[] = { [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, @@ -4165,7 +5797,7 @@ static const struct token token_list[] = { [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, @@ -4180,7 +5812,7 @@ static const struct token token_list[] = { [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, }, @@ -4194,7 +5826,7 @@ static const struct token token_list[] = { [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, }, @@ -4208,7 +5840,7 @@ static const struct token token_list[] = { [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, }, @@ -4222,7 +5854,7 @@ static const struct token token_list[] = { [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, }, @@ -4271,8 +5903,7 @@ static const struct token token_list[] = { [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)), + .priv = PRIV_ACTION(MODIFY_FIELD, ACTION_MODIFY_SIZE), .next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_OP)), .call = parse_vc, }, @@ -4305,7 +5936,8 @@ static const struct token token_list[] = { [ACTION_MODIFY_FIELD_DST_LEVEL] = { .name = "dst_level", .help = "destination field level", - .next = NEXT(action_modify_field_dst, NEXT_ENTRY(UNSIGNED)), + .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, @@ -4313,7 +5945,8 @@ static const struct token token_list[] = { [ACTION_MODIFY_FIELD_DST_OFFSET] = { .name = "dst_offset", .help = "destination field bit offset", - .next = NEXT(action_modify_field_dst, NEXT_ENTRY(UNSIGNED)), + .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, @@ -4334,7 +5967,8 @@ static const struct token token_list[] = { [ACTION_MODIFY_FIELD_SRC_LEVEL] = { .name = "src_level", .help = "source field level", - .next = NEXT(action_modify_field_src, NEXT_ENTRY(UNSIGNED)), + .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, @@ -4342,7 +5976,8 @@ static const struct token token_list[] = { [ACTION_MODIFY_FIELD_SRC_OFFSET] = { .name = "src_offset", .help = "source field bit offset", - .next = NEXT(action_modify_field_src, NEXT_ENTRY(UNSIGNED)), + .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, @@ -4351,16 +5986,31 @@ static const struct token token_list[] = { .name = "src_value", .help = "source immediate value", .next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_WIDTH), - NEXT_ENTRY(UNSIGNED)), - .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + NEXT_ENTRY(COMMON_HEX)), + .args = ARGS(ARGS_ENTRY_ARB(0, 0), + ARGS_ENTRY_ARB(0, 0), + ARGS_ENTRY(struct rte_flow_action_modify_field, src.value)), .call = parse_vc_conf, }, + [ACTION_MODIFY_FIELD_SRC_POINTER] = { + .name = "src_ptr", + .help = "pointer to source immediate value", + .next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_WIDTH), + NEXT_ENTRY(COMMON_HEX)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + src.pvalue), + ARGS_ENTRY_ARB(0, 0), + ARGS_ENTRY_ARB + (sizeof(struct rte_flow_action_modify_field), + ACTION_MODIFY_PATTERN_SIZE)), + .call = parse_vc_conf, + }, [ACTION_MODIFY_FIELD_WIDTH] = { .name = "width", .help = "number of bits to copy", .next = NEXT(NEXT_ENTRY(ACTION_NEXT), - NEXT_ENTRY(UNSIGNED)), + NEXT_ENTRY(COMMON_UNSIGNED)), .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, width)), .call = parse_vc_conf, @@ -4400,7 +6050,7 @@ static const struct token token_list[] = { }, [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, @@ -4433,14 +6083,14 @@ static const struct token token_list[] = { [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, @@ -4448,7 +6098,7 @@ static const struct token token_list[] = { [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, @@ -4464,7 +6114,7 @@ static const struct token token_list[] = { [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, @@ -4472,7 +6122,7 @@ static const struct token token_list[] = { [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, @@ -4488,7 +6138,7 @@ static const struct token token_list[] = { [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, @@ -4504,7 +6154,7 @@ static const struct token token_list[] = { [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, @@ -4522,7 +6172,7 @@ static const struct token token_list[] = { .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] = { @@ -4536,7 +6186,7 @@ static const struct token token_list[] = { [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), @@ -4550,18 +6200,80 @@ static const struct token token_list[] = { }, [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, }, + [ACTION_CONNTRACK] = { + .name = "conntrack", + .help = "create a conntrack object", + .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + .priv = PRIV_ACTION(CONNTRACK, + sizeof(struct rte_flow_action_conntrack)), + .call = parse_vc, + }, + [ACTION_CONNTRACK_UPDATE] = { + .name = "conntrack_update", + .help = "update a conntrack object", + .next = NEXT(action_update_conntrack), + .priv = PRIV_ACTION(CONNTRACK, + sizeof(struct rte_flow_modify_conntrack)), + .call = parse_vc, + }, + [ACTION_CONNTRACK_UPDATE_DIR] = { + .name = "dir", + .help = "update a conntrack object direction", + .next = NEXT(action_update_conntrack), + .call = parse_vc_action_conntrack_update, + }, + [ACTION_CONNTRACK_UPDATE_CTX] = { + .name = "ctx", + .help = "update a conntrack object context", + .next = NEXT(action_update_conntrack), + .call = parse_vc_action_conntrack_update, + }, + [ACTION_PORT_REPRESENTOR] = { + .name = "port_representor", + .help = "at embedded switch level, send matching traffic to the given ethdev", + .priv = PRIV_ACTION(PORT_REPRESENTOR, + sizeof(struct rte_flow_action_ethdev)), + .next = NEXT(action_port_representor), + .call = parse_vc, + }, + [ACTION_PORT_REPRESENTOR_PORT_ID] = { + .name = "port_id", + .help = "ethdev port ID", + .next = NEXT(action_port_representor, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev, + port_id)), + .call = parse_vc_conf, + }, + [ACTION_REPRESENTED_PORT] = { + .name = "represented_port", + .help = "at embedded switch level, send matching traffic to the entity represented by the given ethdev", + .priv = PRIV_ACTION(REPRESENTED_PORT, + sizeof(struct rte_flow_action_ethdev)), + .next = NEXT(action_represented_port), + .call = parse_vc, + }, + [ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID] = { + .name = "ethdev_port_id", + .help = "ethdev port ID", + .next = NEXT(action_represented_port, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev, + port_id)), + .call = parse_vc_conf, + }, /* Indirect action destroy arguments. */ [INDIRECT_ACTION_DESTROY_ID] = { .name = "action_id", .help = "specify a indirect action id to destroy", .next = NEXT(next_ia_destroy_attr, - NEXT_ENTRY(INDIRECT_ACTION_ID)), + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), .args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.ia_destroy.action_id)), .call = parse_ia_destroy, @@ -4571,7 +6283,7 @@ static const struct token token_list[] = { .name = "action_id", .help = "specify a indirect action id to create", .next = NEXT(next_ia_create_attr, - NEXT_ENTRY(INDIRECT_ACTION_ID)), + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), }, [ACTION_INDIRECT] = { @@ -4613,6 +6325,54 @@ static const struct token token_list[] = { .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. */ @@ -4891,6 +6651,151 @@ parse_ia_destroy(struct context *ctx, const struct token *token, return len; } +/** Parse tokens for indirect action commands. */ +static int +parse_qia(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != QUEUE) + return -1; + if (sizeof(*out) > size) + return -1; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case QUEUE_INDIRECT_ACTION: + return len; + case QUEUE_INDIRECT_ACTION_CREATE: + case QUEUE_INDIRECT_ACTION_UPDATE: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + out->args.vc.attr.group = UINT32_MAX; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case QUEUE_INDIRECT_ACTION_EGRESS: + out->args.vc.attr.egress = 1; + return len; + case QUEUE_INDIRECT_ACTION_INGRESS: + out->args.vc.attr.ingress = 1; + return len; + case QUEUE_INDIRECT_ACTION_TRANSFER: + out->args.vc.attr.transfer = 1; + return len; + case QUEUE_INDIRECT_ACTION_CREATE_POSTPONE: + return len; + default: + return -1; + } +} + +/** Parse tokens for indirect action destroy command. */ +static int +parse_qia_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *action_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command || out->command == QUEUE) { + if (ctx->curr != QUEUE_INDIRECT_ACTION_DESTROY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.ia_destroy.action_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + switch (ctx->curr) { + case QUEUE_INDIRECT_ACTION: + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case QUEUE_INDIRECT_ACTION_DESTROY_ID: + action_id = out->args.ia_destroy.action_id + + out->args.ia_destroy.action_id_n++; + if ((uint8_t *)action_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = action_id; + ctx->objmask = NULL; + return len; + case QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE: + return len; + default: + return -1; + } +} + +/** Parse tokens for meter policy action commands. */ +static int +parse_mp(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != ITEM_POL_POLICY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case ACTION_POL_G: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + default: + return -1; + } +} + /** Parse tokens for validate/create commands. */ static int parse_vc(struct context *ctx, const struct token *token, @@ -4908,7 +6813,9 @@ parse_vc(struct context *ctx, const struct token *token, if (!out) return len; if (!out->command) { - if (ctx->curr != VALIDATE && ctx->curr != CREATE) + if (ctx->curr != VALIDATE && ctx->curr != CREATE && + ctx->curr != PATTERN_TEMPLATE_CREATE && + ctx->curr != ACTIONS_TEMPLATE_CREATE) return -1; if (sizeof(*out) > size) return -1; @@ -4924,40 +6831,48 @@ parse_vc(struct context *ctx, const struct token *token, default: ctx->object = &out->args.vc.attr; break; - case TUNNEL_SET: - case TUNNEL_MATCH: + case VC_TUNNEL_SET: + case VC_TUNNEL_MATCH: ctx->object = &out->args.vc.tunnel_ops; break; } ctx->objmask = NULL; switch (ctx->curr) { - case GROUP: - case PRIORITY: + case VC_GROUP: + case VC_PRIORITY: return len; - case TUNNEL_SET: + case VC_TUNNEL_SET: out->args.vc.tunnel_ops.enabled = 1; out->args.vc.tunnel_ops.actions = 1; return len; - case TUNNEL_MATCH: + case VC_TUNNEL_MATCH: out->args.vc.tunnel_ops.enabled = 1; out->args.vc.tunnel_ops.items = 1; return len; - case INGRESS: + case VC_INGRESS: out->args.vc.attr.ingress = 1; return len; - case EGRESS: + 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)); ctx->object = out->args.vc.pattern; ctx->objmask = NULL; return len; + case ITEM_END: + if ((out->command == VALIDATE || out->command == CREATE) && + ctx->last) + return -1; + if (out->command == PATTERN_TEMPLATE_CREATE && + !ctx->last) + return -1; + break; case ACTIONS: out->args.vc.actions = (void *)RTE_ALIGN_CEIL((uintptr_t) @@ -5032,7 +6947,7 @@ parse_vc_spec(struct context *ctx, const struct token *token, 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; @@ -5150,6 +7065,107 @@ parse_vc_item_ecpri_type(struct context *ctx, const struct token *token, return len; } +/** Parse L2TPv2 common header type field. */ +static int +parse_vc_item_l2tpv2_type(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct rte_flow_item_l2tpv2 *l2tpv2; + struct rte_flow_item_l2tpv2 *l2tpv2_mask; + struct rte_flow_item *item; + uint32_t data_size; + uint16_t msg_type = 0; + struct buffer *out = buf; + const struct arg *arg; + + (void)size; + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + switch (ctx->curr) { + case ITEM_L2TPV2_TYPE_DATA: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA; + break; + case ITEM_L2TPV2_TYPE_DATA_L: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_L; + break; + case ITEM_L2TPV2_TYPE_DATA_S: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_S; + break; + case ITEM_L2TPV2_TYPE_DATA_O: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_O; + break; + case ITEM_L2TPV2_TYPE_DATA_L_S: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_L_S; + break; + case ITEM_L2TPV2_TYPE_CTRL: + msg_type |= RTE_L2TPV2_MSG_TYPE_CONTROL; + break; + default: + return -1; + } + if (!ctx->object) + return len; + arg = pop_args(ctx); + if (!arg) + return -1; + l2tpv2 = (struct rte_flow_item_l2tpv2 *)out->args.vc.data; + l2tpv2->hdr.common.flags_version |= msg_type; + data_size = ctx->objdata / 3; /* spec, last, mask */ + l2tpv2_mask = (struct rte_flow_item_l2tpv2 *)(out->args.vc.data + + (data_size * 2)); + l2tpv2_mask->hdr.common.flags_version = 0xFFFF; + if (arg->hton) { + l2tpv2->hdr.common.flags_version = + rte_cpu_to_be_16(l2tpv2->hdr.common.flags_version); + l2tpv2_mask->hdr.common.flags_version = + rte_cpu_to_be_16(l2tpv2_mask->hdr.common.flags_version); + } + item = &out->args.vc.pattern[out->args.vc.pattern_n - 1]; + item->spec = l2tpv2; + item->mask = l2tpv2_mask; + return len; +} + +/** Parse meter color action type. */ +static int +parse_vc_action_meter_color_type(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct rte_flow_action *action_data; + struct rte_flow_action_meter_color *conf; + enum rte_color color; + + (void)buf; + (void)size; + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + switch (ctx->curr) { + case ACTION_METER_COLOR_GREEN: + color = RTE_COLOR_GREEN; + break; + case ACTION_METER_COLOR_YELLOW: + color = RTE_COLOR_YELLOW; + break; + case ACTION_METER_COLOR_RED: + color = RTE_COLOR_RED; + break; + default: + return -1; + } + + if (!ctx->object) + return len; + action_data = ctx->object; + conf = (struct rte_flow_action_meter_color *) + (uintptr_t)(action_data->conf); + conf->color = color; + return len; +} + /** Parse RSS action. */ static int parse_vc_action_rss(struct context *ctx, const struct token *token, @@ -6362,6 +8378,42 @@ parse_vc_modify_field_id(struct context *ctx, const struct token *token, 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, @@ -6465,13 +8517,494 @@ parse_dump(struct context *ctx, const struct token *token, } } -/** Parse tokens for query command. */ +/** Parse tokens for query command. */ +static int +parse_query(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != QUERY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + return len; +} + +/** Parse action names. */ +static int +parse_action(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + const struct arg *arg = pop_args(ctx); + unsigned int i; + + (void)size; + /* Argument is expected. */ + if (!arg) + return -1; + /* Parse action name. */ + for (i = 0; next_action[i]; ++i) { + const struct parse_action_priv *priv; + + token = &token_list[next_action[i]]; + if (strcmp_partial(token->name, str, len)) + continue; + priv = token->priv; + if (!priv) + goto error; + if (out) + memcpy((uint8_t *)ctx->object + arg->offset, + &priv->type, + arg->size); + return len; + } +error: + push_args(ctx, arg); + return -1; +} + +/** Parse tokens for list command. */ +static int +parse_list(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != LIST) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.list.group = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + if (((uint8_t *)(out->args.list.group + out->args.list.group_n) + + sizeof(*out->args.list.group)) > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = out->args.list.group + out->args.list.group_n++; + ctx->objmask = NULL; + return len; +} + +/** Parse tokens for list all aged flows command. */ +static int +parse_aged(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != AGED) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + if (ctx->curr == AGED_DESTROY) + out->args.aged.destroy = 1; + return len; +} + +/** Parse tokens for isolate command. */ +static int +parse_isolate(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != ISOLATE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + return len; +} + +/** Parse tokens for info/configure command. */ +static int +parse_configure(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != INFO && ctx->curr != CONFIGURE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + return len; +} + +/** Parse tokens for template create command. */ +static int +parse_template(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != PATTERN_TEMPLATE && + ctx->curr != ACTIONS_TEMPLATE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case PATTERN_TEMPLATE_CREATE: + out->args.vc.pattern = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + out->args.vc.pat_templ_id = UINT32_MAX; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case PATTERN_TEMPLATE_EGRESS: + out->args.vc.attr.egress = 1; + return len; + case PATTERN_TEMPLATE_INGRESS: + out->args.vc.attr.ingress = 1; + return len; + case PATTERN_TEMPLATE_TRANSFER: + out->args.vc.attr.transfer = 1; + return len; + case ACTIONS_TEMPLATE_CREATE: + out->args.vc.act_templ_id = UINT32_MAX; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case ACTIONS_TEMPLATE_SPEC: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + ctx->object = out->args.vc.actions; + ctx->objmask = NULL; + return len; + case ACTIONS_TEMPLATE_MASK: + out->args.vc.masks = + (void *)RTE_ALIGN_CEIL((uintptr_t) + (out->args.vc.actions + + out->args.vc.actions_n), + sizeof(double)); + ctx->object = out->args.vc.masks; + ctx->objmask = NULL; + return len; + case ACTIONS_TEMPLATE_EGRESS: + out->args.vc.attr.egress = 1; + return len; + case ACTIONS_TEMPLATE_INGRESS: + out->args.vc.attr.ingress = 1; + return len; + case ACTIONS_TEMPLATE_TRANSFER: + out->args.vc.attr.transfer = 1; + return len; + default: + return -1; + } +} + +/** Parse tokens for template destroy command. */ +static int +parse_template_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *template_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command || + out->command == PATTERN_TEMPLATE || + out->command == ACTIONS_TEMPLATE) { + if (ctx->curr != PATTERN_TEMPLATE_DESTROY && + ctx->curr != ACTIONS_TEMPLATE_DESTROY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.templ_destroy.template_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + template_id = out->args.templ_destroy.template_id + + out->args.templ_destroy.template_id_n++; + if ((uint8_t *)template_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = template_id; + ctx->objmask = NULL; + return len; +} + +/** Parse tokens for table create command. */ +static int +parse_table(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *template_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != TABLE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + } + switch (ctx->curr) { + case TABLE_CREATE: + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.table.id = UINT32_MAX; + return len; + case TABLE_PATTERN_TEMPLATE: + out->args.table.pat_templ_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + template_id = out->args.table.pat_templ_id + + out->args.table.pat_templ_id_n++; + if ((uint8_t *)template_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = template_id; + ctx->objmask = NULL; + return len; + case TABLE_ACTIONS_TEMPLATE: + out->args.table.act_templ_id = + (void *)RTE_ALIGN_CEIL((uintptr_t) + (out->args.table.pat_templ_id + + out->args.table.pat_templ_id_n), + sizeof(double)); + template_id = out->args.table.act_templ_id + + out->args.table.act_templ_id_n++; + if ((uint8_t *)template_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = template_id; + ctx->objmask = NULL; + return len; + case TABLE_INGRESS: + out->args.table.attr.flow_attr.ingress = 1; + return len; + case TABLE_EGRESS: + out->args.table.attr.flow_attr.egress = 1; + return len; + case TABLE_TRANSFER: + out->args.table.attr.flow_attr.transfer = 1; + return len; + default: + return -1; + } +} + +/** Parse tokens for table destroy command. */ +static int +parse_table_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *table_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command || out->command == TABLE) { + if (ctx->curr != TABLE_DESTROY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.table_destroy.table_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + table_id = out->args.table_destroy.table_id + + out->args.table_destroy.table_id_n++; + if ((uint8_t *)table_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = table_id; + ctx->objmask = NULL; + return len; +} + +/** Parse tokens for queue create commands. */ +static int +parse_qo(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != QUEUE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case QUEUE_CREATE: + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case QUEUE_TEMPLATE_TABLE: + case QUEUE_PATTERN_TEMPLATE: + case QUEUE_ACTIONS_TEMPLATE: + case QUEUE_CREATE_POSTPONE: + return len; + case ITEM_PATTERN: + out->args.vc.pattern = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + ctx->object = out->args.vc.pattern; + ctx->objmask = NULL; + return len; + case ACTIONS: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t) + (out->args.vc.pattern + + out->args.vc.pattern_n), + sizeof(double)); + ctx->object = out->args.vc.actions; + ctx->objmask = NULL; + return len; + default: + return -1; + } +} + +/** Parse tokens for queue destroy command. */ static int -parse_query(struct context *ctx, const struct token *token, - const char *str, unsigned int len, - void *buf, unsigned int size) +parse_qo_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) { struct buffer *out = buf; + uint32_t *flow_id; /* Token name must match. */ if (parse_default(ctx, token, str, len, NULL, 0) < 0) @@ -6479,8 +9012,8 @@ parse_query(struct context *ctx, const struct token *token, /* Nothing else to do if there is no buffer. */ if (!out) return len; - if (!out->command) { - if (ctx->curr != QUERY) + if (!out->command || out->command == QUEUE) { + if (ctx->curr != QUEUE_DESTROY) return -1; if (sizeof(*out) > size) return -1; @@ -6488,48 +9021,31 @@ parse_query(struct context *ctx, const struct token *token, ctx->objdata = 0; ctx->object = out; ctx->objmask = NULL; + out->args.destroy.rule = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; } - return len; -} - -/** Parse action names. */ -static int -parse_action(struct context *ctx, const struct token *token, - const char *str, unsigned int len, - void *buf, unsigned int size) -{ - struct buffer *out = buf; - const struct arg *arg = pop_args(ctx); - unsigned int i; - - (void)size; - /* Argument is expected. */ - if (!arg) - return -1; - /* Parse action name. */ - for (i = 0; next_action[i]; ++i) { - const struct parse_action_priv *priv; - - token = &token_list[next_action[i]]; - if (strcmp_partial(token->name, str, len)) - continue; - priv = token->priv; - if (!priv) - goto error; - if (out) - memcpy((uint8_t *)ctx->object + arg->offset, - &priv->type, - arg->size); + switch (ctx->curr) { + case QUEUE_DESTROY_ID: + flow_id = out->args.destroy.rule + + out->args.destroy.rule_n++; + if ((uint8_t *)flow_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = flow_id; + ctx->objmask = NULL; return len; + case QUEUE_DESTROY_POSTPONE: + return len; + default: + return -1; } -error: - push_args(ctx, arg); - return -1; } -/** Parse tokens for list command. */ +/** Parse tokens for push queue command. */ static int -parse_list(struct context *ctx, const struct token *token, +parse_push(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size) { @@ -6542,7 +9058,7 @@ parse_list(struct context *ctx, const struct token *token, if (!out) return len; if (!out->command) { - if (ctx->curr != LIST) + if (ctx->curr != PUSH) return -1; if (sizeof(*out) > size) return -1; @@ -6550,23 +9066,14 @@ parse_list(struct context *ctx, const struct token *token, ctx->objdata = 0; ctx->object = out; ctx->objmask = NULL; - out->args.list.group = - (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), - sizeof(double)); - return len; + out->args.vc.data = (uint8_t *)out + size; } - if (((uint8_t *)(out->args.list.group + out->args.list.group_n) + - sizeof(*out->args.list.group)) > (uint8_t *)out + size) - return -1; - ctx->objdata = 0; - ctx->object = out->args.list.group + out->args.list.group_n++; - ctx->objmask = NULL; return len; } -/** Parse tokens for list all aged flows command. */ +/** Parse tokens for pull command. */ static int -parse_aged(struct context *ctx, const struct token *token, +parse_pull(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size) { @@ -6579,7 +9086,7 @@ parse_aged(struct context *ctx, const struct token *token, if (!out) return len; if (!out->command) { - if (ctx->curr != AGED) + if (ctx->curr != PULL) return -1; if (sizeof(*out) > size) return -1; @@ -6587,17 +9094,15 @@ parse_aged(struct context *ctx, const struct token *token, ctx->objdata = 0; ctx->object = out; ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; } - if (ctx->curr == AGED_DESTROY) - out->args.aged.destroy = 1; return len; } -/** Parse tokens for isolate command. */ static int -parse_isolate(struct context *ctx, const struct token *token, - const char *str, unsigned int len, - void *buf, unsigned int size) +parse_flex(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) { struct buffer *out = buf; @@ -6607,8 +9112,8 @@ parse_isolate(struct context *ctx, const struct token *token, /* Nothing else to do if there is no buffer. */ if (!out) return len; - if (!out->command) { - if (ctx->curr != ISOLATE) + if (out->command == ZERO) { + if (ctx->curr != FLEX) return -1; if (sizeof(*out) > size) return -1; @@ -6616,7 +9121,18 @@ parse_isolate(struct context *ctx, const struct token *token, ctx->objdata = 0; ctx->object = out; ctx->objmask = NULL; + } else { + switch (ctx->curr) { + default: + break; + case FLEX_ITEM_INIT: + case FLEX_ITEM_CREATE: + case FLEX_ITEM_DESTROY: + out->command = ctx->curr; + break; + } } + return len; } @@ -6820,31 +9336,32 @@ error: static int parse_hex_string(const char *src, uint8_t *dst, uint32_t *size) { - char *c = NULL; - uint32_t i, len; - char tmp[3]; + const uint8_t *head = dst; + uint32_t left; - /* Check input parameters */ - if ((src == NULL) || - (dst == NULL) || - (size == NULL) || - (*size == 0)) + if (*size == 0) return -1; + left = *size; + /* Convert chars to bytes */ - for (i = 0, len = 0; i < *size; i += 2) { - snprintf(tmp, 3, "%s", src + i); - dst[len++] = strtoul(tmp, &c, 16); - if (*c != 0) { - len--; - dst[len] = 0; - *size = len; + while (left) { + char tmp[3], *end = tmp; + uint32_t read_lim = left & 1 ? 1 : 2; + + snprintf(tmp, read_lim + 1, "%s", src); + *dst = strtoul(tmp, &end, 16); + if (*end) { + *dst = 0; + *size = (uint32_t)(dst - head); return -1; } + left -= read_lim; + src += read_lim; + dst++; } - dst[len] = 0; - *size = len; - + *dst = 0; + *size = (uint32_t)(dst - head); return 0; } @@ -6888,10 +9405,13 @@ parse_hex(struct context *ctx, const struct token *token, hexlen -= 2; } if (hexlen > length) - return -1; + goto error; ret = parse_hex_string(str, hex_tmp, &hexlen); if (ret < 0) goto error; + /* Check the converted binary fits into data buffer. */ + if (hexlen > size) + goto error; /* Let parse_int() fill length information first. */ ret = snprintf(tmp, sizeof(tmp), "%u", hexlen); if (ret < 0) @@ -7282,6 +9802,71 @@ parse_set_init(struct context *ctx, const struct token *token, return len; } +/* + * Replace testpmd handles in a flex flow item with real values. + */ +static int +parse_flex_handle(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct rte_flow_item_flex *spec, *mask; + const struct rte_flow_item_flex *src_spec, *src_mask; + const struct arg *arg = pop_args(ctx); + uint32_t offset; + uint16_t handle; + int ret; + + if (!arg) { + printf("Bad environment\n"); + return -1; + } + offset = arg->offset; + push_args(ctx, arg); + ret = parse_int(ctx, token, str, len, buf, size); + if (ret <= 0 || !ctx->object) + return ret; + if (ctx->port >= RTE_MAX_ETHPORTS) { + printf("Bad port\n"); + return -1; + } + if (offset == offsetof(struct rte_flow_item_flex, handle)) { + const struct flex_item *fp; + struct rte_flow_item_flex *item_flex = ctx->object; + handle = (uint16_t)(uintptr_t)item_flex->handle; + if (handle >= FLEX_MAX_PARSERS_NUM) { + printf("Bad flex item handle\n"); + return -1; + } + fp = flex_items[ctx->port][handle]; + if (!fp) { + printf("Bad flex item handle\n"); + return -1; + } + item_flex->handle = fp->flex_handle; + } else if (offset == offsetof(struct rte_flow_item_flex, pattern)) { + handle = (uint16_t)(uintptr_t) + ((struct rte_flow_item_flex *)ctx->object)->pattern; + if (handle >= FLEX_MAX_PATTERNS_NUM) { + printf("Bad pattern handle\n"); + return -1; + } + src_spec = &flex_patterns[handle].spec; + src_mask = &flex_patterns[handle].mask; + spec = ctx->object; + mask = spec + 2; /* spec, last, mask */ + /* fill flow rule spec and mask parameters */ + spec->length = src_spec->length; + spec->pattern = src_spec->pattern; + mask->length = src_mask->length; + mask->pattern = src_mask->pattern; + } else { + printf("Bad arguments - unknown flex item offset\n"); + return -1; + } + return ret; +} + /** No completion. */ static int comp_none(struct context *ctx, const struct token *token, @@ -7451,15 +10036,11 @@ 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 RTE_DIM(modify_field_ops); + if (ent < RTE_DIM(modify_field_ops) - 1) return strlcpy(buf, modify_field_ops[ent], size); return -1; } @@ -7469,19 +10050,114 @@ 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; + const char *name; - 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 RTE_DIM(modify_field_ids); + if (ent >= RTE_DIM(modify_field_ids) - 1) + return -1; + name = modify_field_ids[ent]; + if (ctx->curr == ACTION_MODIFY_FIELD_SRC_TYPE || + (strcmp(name, "pointer") && strcmp(name, "value"))) + return strlcpy(buf, name, size); return -1; } +/** Complete available pattern template IDs. */ +static int +comp_pattern_template_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + struct port_template *pt; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (pt = port->pattern_templ_list; pt != NULL; pt = pt->next) { + if (buf && i == ent) + return snprintf(buf, size, "%u", pt->id); + ++i; + } + if (buf) + return -1; + return i; +} + +/** Complete available actions template IDs. */ +static int +comp_actions_template_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + struct port_template *pt; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (pt = port->actions_templ_list; pt != NULL; pt = pt->next) { + if (buf && i == ent) + return snprintf(buf, size, "%u", pt->id); + ++i; + } + if (buf) + return -1; + return i; +} + +/** Complete available table IDs. */ +static int +comp_table_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + struct port_table *pt; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (pt = port->table_list; pt != NULL; pt = pt->next) { + if (buf && i == ent) + return snprintf(buf, size, "%u", pt->id); + ++i; + } + if (buf) + return -1; + return i; +} + +/** Complete available queue IDs. */ +static int +comp_queue_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (i = 0; i < port->queue_nb; i++) { + if (buf && i == ent) + return snprintf(buf, size, "%u", i); + } + if (buf) + return -1; + return i; +} + /** Internal context. */ static struct context cmd_flow_context; @@ -7583,6 +10259,30 @@ cmd_flow_parse(cmdline_parse_token_hdr_t *hdr, const char *src, void *result, return len; } +int +flow_parse(const char *src, void *result, unsigned int size, + struct rte_flow_attr **attr, + struct rte_flow_item **pattern, struct rte_flow_action **actions) +{ + int ret; + struct context saved_flow_ctx = cmd_flow_context; + + cmd_flow_context_init(&cmd_flow_context); + do { + ret = cmd_flow_parse(NULL, src, result, size); + if (ret > 0) { + src += ret; + while (isspace(*src)) + src++; + } + } while (ret > 0 && strlen(src)); + cmd_flow_context = saved_flow_ctx; + *attr = &((struct buffer *)result)->args.vc.attr; + *pattern = ((struct buffer *)result)->args.vc.pattern; + *actions = ((struct buffer *)result)->args.vc.actions; + return (ret >= 0 && !strlen(src)) ? 0 : -1; +} + /** Return number of completion entries (cmdline API). */ static int cmd_flow_complete_get_nb(cmdline_parse_token_hdr_t *hdr) @@ -7717,6 +10417,98 @@ static void cmd_flow_parsed(const struct buffer *in) { switch (in->command) { + case INFO: + port_flow_get_info(in->port); + break; + case CONFIGURE: + port_flow_configure(in->port, + &in->args.configure.port_attr, + in->args.configure.nb_queue, + &in->args.configure.queue_attr); + break; + case PATTERN_TEMPLATE_CREATE: + port_flow_pattern_template_create(in->port, + in->args.vc.pat_templ_id, + &((const struct rte_flow_pattern_template_attr) { + .relaxed_matching = in->args.vc.attr.reserved, + .ingress = in->args.vc.attr.ingress, + .egress = in->args.vc.attr.egress, + .transfer = in->args.vc.attr.transfer, + }), + in->args.vc.pattern); + break; + case PATTERN_TEMPLATE_DESTROY: + port_flow_pattern_template_destroy(in->port, + in->args.templ_destroy.template_id_n, + in->args.templ_destroy.template_id); + break; + case ACTIONS_TEMPLATE_CREATE: + port_flow_actions_template_create(in->port, + in->args.vc.act_templ_id, + &((const struct rte_flow_actions_template_attr) { + .ingress = in->args.vc.attr.ingress, + .egress = in->args.vc.attr.egress, + .transfer = in->args.vc.attr.transfer, + }), + in->args.vc.actions, + in->args.vc.masks); + break; + case ACTIONS_TEMPLATE_DESTROY: + port_flow_actions_template_destroy(in->port, + in->args.templ_destroy.template_id_n, + in->args.templ_destroy.template_id); + break; + case TABLE_CREATE: + port_flow_template_table_create(in->port, in->args.table.id, + &in->args.table.attr, in->args.table.pat_templ_id_n, + in->args.table.pat_templ_id, in->args.table.act_templ_id_n, + in->args.table.act_templ_id); + break; + case TABLE_DESTROY: + port_flow_template_table_destroy(in->port, + in->args.table_destroy.table_id_n, + in->args.table_destroy.table_id); + break; + case QUEUE_CREATE: + port_queue_flow_create(in->port, in->queue, in->postpone, + in->args.vc.table_id, in->args.vc.pat_templ_id, + in->args.vc.act_templ_id, in->args.vc.pattern, + in->args.vc.actions); + break; + case QUEUE_DESTROY: + port_queue_flow_destroy(in->port, in->queue, in->postpone, + in->args.destroy.rule_n, + in->args.destroy.rule); + break; + case PUSH: + port_queue_flow_push(in->port, in->queue); + break; + case PULL: + port_queue_flow_pull(in->port, in->queue); + break; + case QUEUE_INDIRECT_ACTION_CREATE: + port_queue_action_handle_create( + in->port, in->queue, in->postpone, + in->args.vc.attr.group, + &((const struct rte_flow_indir_action_conf) { + .ingress = in->args.vc.attr.ingress, + .egress = in->args.vc.attr.egress, + .transfer = in->args.vc.attr.transfer, + }), + in->args.vc.actions); + break; + case QUEUE_INDIRECT_ACTION_DESTROY: + port_queue_action_handle_destroy(in->port, + in->queue, in->postpone, + in->args.ia_destroy.action_id_n, + in->args.ia_destroy.action_id); + break; + case QUEUE_INDIRECT_ACTION_UPDATE: + port_queue_action_handle_update(in->port, + in->queue, in->postpone, + in->args.vc.attr.group, + in->args.vc.actions); + break; case INDIRECT_ACTION_CREATE: port_action_handle_create( in->port, in->args.vc.attr.group, @@ -7784,6 +10576,17 @@ cmd_flow_parsed(const struct buffer *in) case TUNNEL_LIST: port_flow_tunnel_list(in->port); break; + case ACTION_POL_G: + port_meter_policy_add(in->port, in->args.policy.policy_id, + in->args.vc.actions); + break; + case FLEX_ITEM_CREATE: + flex_item_create(in->port, in->args.flex.token, + in->args.flex.filename); + break; + case FLEX_ITEM_DESTROY: + flex_item_destroy(in->port, in->args.flex.token); + break; default: break; } @@ -7830,7 +10633,8 @@ update_fields(uint8_t *buf, struct rte_flow_item *item, uint16_t next_proto) break; case RTE_FLOW_ITEM_TYPE_IPV4: ipv4 = (struct rte_ipv4_hdr *)buf; - ipv4->version_ihl = 0x45; + 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; @@ -7959,6 +10763,16 @@ flow_item_default_mask(const struct rte_flow_item *item) case RTE_FLOW_ITEM_TYPE_PFCP: mask = &rte_flow_item_pfcp_mask; break; + case RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR: + case RTE_FLOW_ITEM_TYPE_REPRESENTED_PORT: + mask = &rte_flow_item_ethdev_mask; + break; + case RTE_FLOW_ITEM_TYPE_L2TPV2: + mask = &rte_flow_item_l2tpv2_mask; + break; + case RTE_FLOW_ITEM_TYPE_PPP: + mask = &rte_flow_item_ppp_mask; + break; default: break; } @@ -8059,7 +10873,7 @@ cmd_set_raw_parsed_sample(const struct buffer *in) 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)); @@ -8157,7 +10971,8 @@ cmd_set_raw_parsed(const struct buffer *in) 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); + size = offsetof(struct rte_flow_item_geneve_opt, + option_len) + sizeof(uint8_t); if (opt->option_len && opt->data) { *total_size += opt->option_len * sizeof(uint32_t); @@ -8184,13 +10999,15 @@ cmd_set_raw_parsed(const struct buffer *in) break; } if (gtp_psc != i + 1) { - printf("Error - GTP PSC does not follow GTP\n"); + 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. */ - printf("Error - GTP unsupported flags\n"); + fprintf(stderr, + "Error - GTP unsupported flags\n"); goto error; } else { struct rte_gtp_hdr_ext_word ext_word = { @@ -8206,27 +11023,21 @@ cmd_set_raw_parsed(const struct buffer *in) break; case RTE_FLOW_ITEM_TYPE_GTP_PSC: if (gtp_psc >= 0) { - printf("Error - Multiple GTP PSC items\n"); + 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 pdu_type:4; + uint8_t qfi:6; uint8_t next; } psc; - - if (opt->pdu_type & 0x0F) { - /* Support the minimal option only. */ - printf("Error - GTP PSC option with " - "extra fields not supported\n"); - goto error; - } - psc.len = sizeof(psc); - psc.pdu_type = opt->pdu_type; - psc.qfi = opt->qfi; + psc.len = sizeof(psc) / 4; + psc.pdu_type = opt->hdr.type; + psc.qfi = opt->hdr.qfi; psc.next = 0; *total_size += sizeof(psc); rte_memcpy(data_tail - (*total_size), @@ -8238,8 +11049,40 @@ cmd_set_raw_parsed(const struct buffer *in) case RTE_FLOW_ITEM_TYPE_PFCP: size = sizeof(struct rte_flow_item_pfcp); break; + case RTE_FLOW_ITEM_TYPE_FLEX: + size = item->spec ? + ((const struct rte_flow_item_flex *) + item->spec)->length : 0; + break; + case RTE_FLOW_ITEM_TYPE_GRE_OPTION: + size = 0; + if (item->spec) { + const struct rte_flow_item_gre_opt + *opt = item->spec; + if (opt->checksum_rsvd.checksum) { + *total_size += + sizeof(opt->checksum_rsvd); + rte_memcpy(data_tail - (*total_size), + &opt->checksum_rsvd, + sizeof(opt->checksum_rsvd)); + } + if (opt->key.key) { + *total_size += sizeof(opt->key.key); + rte_memcpy(data_tail - (*total_size), + &opt->key.key, + sizeof(opt->key.key)); + } + if (opt->sequence.sequence) { + *total_size += sizeof(opt->sequence.sequence); + rte_memcpy(data_tail - (*total_size), + &opt->sequence.sequence, + sizeof(opt->sequence.sequence)); + } + } + proto = 0x2F; + break; default: - printf("Error - Not supported item\n"); + fprintf(stderr, "Error - Not supported item\n"); goto error; } *total_size += size; @@ -8367,7 +11210,8 @@ cmd_show_set_raw_parsed(void *parsed_result, struct cmdline *cl, void *data) 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 { @@ -8385,16 +11229,16 @@ cmd_show_set_raw_parsed(void *parsed_result, struct cmdline *cl, void *data) } while (all && ++index < RAW_ENCAP_CONFS_MAX_NUM); } -cmdline_parse_token_string_t cmd_show_set_raw_cmd_show = +static cmdline_parse_token_string_t cmd_show_set_raw_cmd_show = TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result, cmd_show, "show"); -cmdline_parse_token_string_t cmd_show_set_raw_cmd_what = +static cmdline_parse_token_string_t cmd_show_set_raw_cmd_what = TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result, cmd_what, "raw_encap#raw_decap"); -cmdline_parse_token_num_t cmd_show_set_raw_cmd_index = +static cmdline_parse_token_num_t cmd_show_set_raw_cmd_index = TOKEN_NUM_INITIALIZER(struct cmd_show_set_raw_result, cmd_index, RTE_UINT16); -cmdline_parse_token_string_t cmd_show_set_raw_cmd_all = +static cmdline_parse_token_string_t cmd_show_set_raw_cmd_all = TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result, cmd_all, "all"); cmdline_parse_inst_t cmd_show_set_raw = {