X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline_flow.c;h=cfd55c598d3b9d3105bcaa61291fa8432365aa3e;hb=6496922368fe03be9ab4137f2d615dba1a766f39;hp=f7e0a622032d947f6b3c033ec012b613312a5caa;hpb=6a42e7ef9dd86a554e060fcef0be03aa9ddd394c;p=dpdk.git diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index f7e0a62203..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 @@ -23,6 +21,11 @@ #include #include #include +#include +#include +#include +#include +#include #include "testpmd.h" @@ -35,19 +38,31 @@ enum index { END_SET, /* Common tokens. */ - INTEGER, - UNSIGNED, - PREFIX, - BOOLEAN, - STRING, - HEX, - MAC_ADDR, - IPV4_ADDR, - IPV6_ADDR, - RULE_ID, - PORT_ID, - GROUP_ID, - PRIORITY_LEVEL, + 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, @@ -55,17 +70,123 @@ enum index { SET_RAW_ENCAP, SET_RAW_DECAP, SET_RAW_INDEX, + SET_SAMPLE_ACTIONS, + SET_SAMPLE_INDEX, /* Top-level command. */ FLOW, /* Sub-level commands. */ + INFO, + CONFIGURE, + PATTERN_TEMPLATE, + ACTIONS_TEMPLATE, + TABLE, + INDIRECT_ACTION, VALIDATE, CREATE, DESTROY, FLUSH, + DUMP, QUERY, LIST, + AGED, ISOLATE, + TUNNEL, + FLEX, + QUEUE, + PUSH, + PULL, + + /* Flex arguments */ + FLEX_ITEM_INIT, + FLEX_ITEM_CREATE, + FLEX_ITEM_DESTROY, + + /* Pattern template arguments. */ + PATTERN_TEMPLATE_CREATE, + PATTERN_TEMPLATE_DESTROY, + PATTERN_TEMPLATE_CREATE_ID, + PATTERN_TEMPLATE_DESTROY_ID, + PATTERN_TEMPLATE_RELAXED_MATCHING, + PATTERN_TEMPLATE_INGRESS, + PATTERN_TEMPLATE_EGRESS, + PATTERN_TEMPLATE_TRANSFER, + PATTERN_TEMPLATE_SPEC, + + /* Actions template arguments. */ + ACTIONS_TEMPLATE_CREATE, + ACTIONS_TEMPLATE_DESTROY, + ACTIONS_TEMPLATE_CREATE_ID, + ACTIONS_TEMPLATE_DESTROY_ID, + ACTIONS_TEMPLATE_INGRESS, + ACTIONS_TEMPLATE_EGRESS, + ACTIONS_TEMPLATE_TRANSFER, + ACTIONS_TEMPLATE_SPEC, + ACTIONS_TEMPLATE_MASK, + + /* Queue arguments. */ + QUEUE_CREATE, + QUEUE_DESTROY, + QUEUE_INDIRECT_ACTION, + + /* Queue create arguments. */ + QUEUE_CREATE_ID, + QUEUE_CREATE_POSTPONE, + QUEUE_TEMPLATE_TABLE, + QUEUE_PATTERN_TEMPLATE, + QUEUE_ACTIONS_TEMPLATE, + QUEUE_SPEC, + + /* Queue destroy arguments. */ + QUEUE_DESTROY_ID, + QUEUE_DESTROY_POSTPONE, + + /* Queue indirect action arguments */ + QUEUE_INDIRECT_ACTION_CREATE, + QUEUE_INDIRECT_ACTION_UPDATE, + QUEUE_INDIRECT_ACTION_DESTROY, + + /* Queue indirect action create arguments */ + QUEUE_INDIRECT_ACTION_CREATE_ID, + QUEUE_INDIRECT_ACTION_INGRESS, + QUEUE_INDIRECT_ACTION_EGRESS, + QUEUE_INDIRECT_ACTION_TRANSFER, + QUEUE_INDIRECT_ACTION_CREATE_POSTPONE, + QUEUE_INDIRECT_ACTION_SPEC, + + /* Queue indirect action update arguments */ + QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE, + + /* Queue indirect action destroy arguments */ + QUEUE_INDIRECT_ACTION_DESTROY_ID, + QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE, + + /* Push arguments. */ + PUSH_QUEUE, + + /* Pull arguments. */ + PULL_QUEUE, + + /* Table arguments. */ + TABLE_CREATE, + TABLE_DESTROY, + TABLE_CREATE_ID, + TABLE_DESTROY_ID, + TABLE_GROUP, + TABLE_PRIORITY, + TABLE_INGRESS, + TABLE_EGRESS, + TABLE_TRANSFER, + TABLE_RULES_NUMBER, + TABLE_PATTERN_TEMPLATE, + TABLE_ACTIONS_TEMPLATE, + + /* Tunnel arguments. */ + TUNNEL_CREATE, + TUNNEL_CREATE_TYPE, + TUNNEL_LIST, + TUNNEL_DESTROY, + TUNNEL_DESTROY_ID, /* Destroy arguments. */ DESTROY_RULE, @@ -76,15 +197,47 @@ enum index { /* List arguments. */ LIST_GROUP, + /* Destroy aged flow arguments. */ + AGED_DESTROY, + /* Validate/create arguments. */ - GROUP, - PRIORITY, - INGRESS, - EGRESS, - TRANSFER, + VC_GROUP, + VC_PRIORITY, + VC_INGRESS, + VC_EGRESS, + VC_TRANSFER, + VC_TUNNEL_SET, + VC_TUNNEL_MATCH, + + /* Dump arguments */ + DUMP_ALL, + DUMP_ONE, + + /* Configure arguments */ + CONFIG_QUEUES_NUMBER, + CONFIG_QUEUES_SIZE, + CONFIG_COUNTERS_NUMBER, + CONFIG_AGING_OBJECTS_NUMBER, + CONFIG_METERS_NUMBER, + + /* Indirect action arguments */ + INDIRECT_ACTION_CREATE, + INDIRECT_ACTION_UPDATE, + INDIRECT_ACTION_DESTROY, + INDIRECT_ACTION_QUERY, + + /* Indirect action create arguments */ + INDIRECT_ACTION_CREATE_ID, + INDIRECT_ACTION_INGRESS, + INDIRECT_ACTION_EGRESS, + INDIRECT_ACTION_TRANSFER, + INDIRECT_ACTION_SPEC, + + /* Indirect action destroy arguments */ + INDIRECT_ACTION_DESTROY_ID, /* Validate/create pattern. */ - PATTERN, + ITEM_PATTERN, ITEM_PARAM_IS, ITEM_PARAM_SPEC, ITEM_PARAM_LAST, @@ -111,18 +264,24 @@ enum index { ITEM_RAW_OFFSET, ITEM_RAW_LIMIT, ITEM_RAW_PATTERN, + ITEM_RAW_PATTERN_HEX, ITEM_ETH, ITEM_ETH_DST, ITEM_ETH_SRC, ITEM_ETH_TYPE, + ITEM_ETH_HAS_VLAN, ITEM_VLAN, ITEM_VLAN_TCI, ITEM_VLAN_PCP, ITEM_VLAN_DEI, ITEM_VLAN_VID, ITEM_VLAN_INNER_TYPE, + ITEM_VLAN_HAS_MORE_VLAN, ITEM_IPV4, + ITEM_IPV4_VER_IHL, ITEM_IPV4_TOS, + ITEM_IPV4_ID, + ITEM_IPV4_FRAGMENT_OFFSET, ITEM_IPV4_TTL, ITEM_IPV4_PROTO, ITEM_IPV4_SRC, @@ -134,9 +293,12 @@ enum index { ITEM_IPV6_HOP, ITEM_IPV6_SRC, ITEM_IPV6_DST, + ITEM_IPV6_HAS_FRAG_EXT, ITEM_ICMP, ITEM_ICMP_TYPE, ITEM_ICMP_CODE, + ITEM_ICMP_IDENT, + ITEM_ICMP_SEQ, ITEM_UDP, ITEM_UDP_SRC, ITEM_UDP_DST, @@ -151,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, @@ -168,12 +331,15 @@ enum index { ITEM_FUZZY, ITEM_FUZZY_THRESH, ITEM_GTP, + ITEM_GTP_FLAGS, + ITEM_GTP_MSG_TYPE, ITEM_GTP_TEID, ITEM_GTPC, ITEM_GTPU, ITEM_GENEVE, ITEM_GENEVE_VNI, ITEM_GENEVE_PROTO, + ITEM_GENEVE_OPTLEN, ITEM_VXLAN_GPE, ITEM_VXLAN_GPE_VNI, ITEM_ARP_ETH_IPV4, @@ -183,6 +349,10 @@ enum index { ITEM_ARP_ETH_IPV4_TPA, ITEM_IPV6_EXT, ITEM_IPV6_EXT_NEXT_HDR, + ITEM_IPV6_FRAG_EXT, + ITEM_IPV6_FRAG_EXT_NEXT_HDR, + ITEM_IPV6_FRAG_EXT_FRAG_DATA, + ITEM_IPV6_FRAG_EXT_ID, ITEM_ICMP6, ITEM_ICMP6_TYPE, ITEM_ICMP6_CODE, @@ -200,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, @@ -217,6 +391,73 @@ enum index { ITEM_L2TPV3OIP_SESSION_ID, ITEM_ESP, ITEM_ESP_SPI, + ITEM_AH, + ITEM_AH_SPI, + ITEM_PFCP, + ITEM_PFCP_S_FIELD, + ITEM_PFCP_SEID, + ITEM_ECPRI, + ITEM_ECPRI_COMMON, + ITEM_ECPRI_COMMON_TYPE, + ITEM_ECPRI_COMMON_TYPE_IQ_DATA, + ITEM_ECPRI_COMMON_TYPE_RTC_CTRL, + ITEM_ECPRI_COMMON_TYPE_DLY_MSR, + ITEM_ECPRI_MSG_IQ_DATA_PCID, + ITEM_ECPRI_MSG_RTC_CTRL_RTCID, + ITEM_ECPRI_MSG_DLY_MSR_MSRID, + ITEM_GENEVE_OPT, + ITEM_GENEVE_OPT_CLASS, + ITEM_GENEVE_OPT_TYPE, + ITEM_GENEVE_OPT_LENGTH, + ITEM_GENEVE_OPT_DATA, + ITEM_INTEGRITY, + ITEM_INTEGRITY_LEVEL, + ITEM_INTEGRITY_VALUE, + ITEM_CONNTRACK, + ITEM_POL_PORT, + ITEM_POL_METER, + ITEM_POL_POLICY, + ITEM_PORT_REPRESENTOR, + ITEM_PORT_REPRESENTOR_PORT_ID, + ITEM_REPRESENTED_PORT, + ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID, + ITEM_FLEX, + ITEM_FLEX_ITEM_HANDLE, + ITEM_FLEX_PATTERN_HANDLE, + ITEM_L2TPV2, + ITEM_L2TPV2_TYPE, + ITEM_L2TPV2_TYPE_DATA, + ITEM_L2TPV2_TYPE_DATA_L, + ITEM_L2TPV2_TYPE_DATA_S, + ITEM_L2TPV2_TYPE_DATA_O, + ITEM_L2TPV2_TYPE_DATA_L_S, + ITEM_L2TPV2_TYPE_CTRL, + ITEM_L2TPV2_MSG_DATA_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_L_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_S_NS, + ITEM_L2TPV2_MSG_DATA_S_NR, + ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_O_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_O_OFFSET, + ITEM_L2TPV2_MSG_DATA_L_S_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_L_S_NS, + ITEM_L2TPV2_MSG_DATA_L_S_NR, + ITEM_L2TPV2_MSG_CTRL_LENGTH, + ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID, + ITEM_L2TPV2_MSG_CTRL_SESSION_ID, + ITEM_L2TPV2_MSG_CTRL_NS, + ITEM_L2TPV2_MSG_CTRL_NR, + ITEM_PPP, + ITEM_PPP_ADDR, + ITEM_PPP_CTRL, + ITEM_PPP_PROTO_ID, /* Validate/create actions. */ ACTIONS, @@ -233,7 +474,6 @@ enum index { ACTION_QUEUE_INDEX, ACTION_DROP, ACTION_COUNT, - ACTION_COUNT_SHARED, ACTION_COUNT_ID, ACTION_RSS, ACTION_RSS_FUNC, @@ -259,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, @@ -334,15 +579,59 @@ enum index { ACTION_SET_IPV4_DSCP_VALUE, ACTION_SET_IPV6_DSCP, ACTION_SET_IPV6_DSCP_VALUE, + ACTION_AGE, + ACTION_AGE_TIMEOUT, + ACTION_SAMPLE, + ACTION_SAMPLE_RATIO, + ACTION_SAMPLE_INDEX, + ACTION_SAMPLE_INDEX_VALUE, + ACTION_INDIRECT, + INDIRECT_ACTION_ID2PTR, + ACTION_MODIFY_FIELD, + ACTION_MODIFY_FIELD_OP, + ACTION_MODIFY_FIELD_OP_VALUE, + ACTION_MODIFY_FIELD_DST_TYPE, + ACTION_MODIFY_FIELD_DST_TYPE_VALUE, + ACTION_MODIFY_FIELD_DST_LEVEL, + ACTION_MODIFY_FIELD_DST_OFFSET, + ACTION_MODIFY_FIELD_SRC_TYPE, + ACTION_MODIFY_FIELD_SRC_TYPE_VALUE, + ACTION_MODIFY_FIELD_SRC_LEVEL, + ACTION_MODIFY_FIELD_SRC_OFFSET, + ACTION_MODIFY_FIELD_SRC_VALUE, + ACTION_MODIFY_FIELD_SRC_POINTER, + ACTION_MODIFY_FIELD_WIDTH, + ACTION_CONNTRACK, + ACTION_CONNTRACK_UPDATE, + ACTION_CONNTRACK_UPDATE_DIR, + ACTION_CONNTRACK_UPDATE_CTX, + ACTION_POL_G, + ACTION_POL_Y, + ACTION_POL_R, + ACTION_PORT_REPRESENTOR, + ACTION_PORT_REPRESENTOR_PORT_ID, + ACTION_REPRESENTED_PORT, + ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID, }; /** Maximum size for pattern in struct rte_flow_item_raw. */ -#define ITEM_RAW_PATTERN_SIZE 40 +#define ITEM_RAW_PATTERN_SIZE 512 + +/** Maximum size for GENEVE option data pattern in bytes. */ +#define ITEM_GENEVE_OPT_DATA_SIZE 124 /** Storage size for struct rte_flow_item_raw including pattern. */ #define ITEM_RAW_SIZE \ (sizeof(struct rte_flow_item_raw) + ITEM_RAW_PATTERN_SIZE) +/** Maximum size for external pattern in struct rte_flow_action_modify_data. */ +#define ACTION_MODIFY_PATTERN_SIZE 32 + +/** Storage size for struct rte_flow_action_modify_field including pattern. */ +#define ACTION_MODIFY_SIZE \ + (sizeof(struct rte_flow_action_modify_field) + \ + ACTION_MODIFY_PATTERN_SIZE) + /** Maximum number of queue indices in struct rte_flow_action_rss. */ #define ACTION_RSS_QUEUE_NUM 128 @@ -354,7 +643,7 @@ struct action_rss_data { }; /** Maximum data size in struct rte_flow_action_raw_encap. */ -#define ACTION_RAW_ENCAP_MAX_DATA 128 +#define ACTION_RAW_ENCAP_MAX_DATA 512 #define RAW_ENCAP_CONFS_MAX_NUM 8 /** Storage for struct rte_flow_action_raw_encap. */ @@ -395,7 +684,7 @@ struct vxlan_encap_conf vxlan_encap_conf = { .select_tos_ttl = 0, .vni = "\x00\x00\x00", .udp_src = 0, - .udp_dst = RTE_BE16(4789), + .udp_dst = RTE_BE16(RTE_VXLAN_DEFAULT_PORT), .ipv4_src = RTE_IPV4(127, 0, 0, 1), .ipv4_dst = RTE_IPV4(255, 255, 255, 255), .ipv6_src = "\x00\x00\x00\x00\x00\x00\x00\x00" @@ -469,6 +758,47 @@ struct mplsoudp_encap_conf mplsoudp_encap_conf; struct mplsoudp_decap_conf mplsoudp_decap_conf; +struct rte_flow_action_conntrack conntrack_context; + +#define ACTION_SAMPLE_ACTIONS_NUM 10 +#define RAW_SAMPLE_CONFS_MAX_NUM 8 +/** Storage for struct rte_flow_action_sample including external data. */ +struct action_sample_data { + struct rte_flow_action_sample conf; + uint32_t idx; +}; +/** Storage for struct rte_flow_action_sample. */ +struct raw_sample_conf { + struct rte_flow_action data[ACTION_SAMPLE_ACTIONS_NUM]; +}; +struct raw_sample_conf raw_sample_confs[RAW_SAMPLE_CONFS_MAX_NUM]; +struct rte_flow_action_mark sample_mark[RAW_SAMPLE_CONFS_MAX_NUM]; +struct rte_flow_action_queue sample_queue[RAW_SAMPLE_CONFS_MAX_NUM]; +struct rte_flow_action_count sample_count[RAW_SAMPLE_CONFS_MAX_NUM]; +struct rte_flow_action_port_id sample_port_id[RAW_SAMPLE_CONFS_MAX_NUM]; +struct rte_flow_action_raw_encap sample_encap[RAW_SAMPLE_CONFS_MAX_NUM]; +struct action_vxlan_encap_data sample_vxlan_encap[RAW_SAMPLE_CONFS_MAX_NUM]; +struct action_nvgre_encap_data sample_nvgre_encap[RAW_SAMPLE_CONFS_MAX_NUM]; +struct action_rss_data sample_rss_data[RAW_SAMPLE_CONFS_MAX_NUM]; +struct rte_flow_action_vf sample_vf[RAW_SAMPLE_CONFS_MAX_NUM]; + +static const char *const modify_field_ops[] = { + "set", "add", "sub", NULL +}; + +static const char *const modify_field_ids[] = { + "start", "mac_dst", "mac_src", + "vlan_type", "vlan_id", "mac_type", + "ipv4_dscp", "ipv4_ttl", "ipv4_src", "ipv4_dst", + "ipv6_dscp", "ipv6_hoplimit", "ipv6_src", "ipv6_dst", + "tcp_port_src", "tcp_port_dst", + "tcp_seq_num", "tcp_ack_num", "tcp_flags", + "udp_port_src", "udp_port_dst", + "vxlan_vni", "geneve_vni", "gtp_teid", + "tag", "mark", "meta", "pointer", "value", + "ipv4_ecn", "ipv6_ecn", NULL +}; + /** Maximum number of subsequent tokens and arguments on the stack. */ #define CTX_STACK_SIZE 16 @@ -566,6 +896,16 @@ struct token { .mask = (const void *)&(const s){ .f = (1 << (b)) - 1 }, \ }) +/** Static initializer for ARGS() to target a field with limits. */ +#define ARGS_ENTRY_BOUNDED(s, f, i, a) \ + (&(const struct arg){ \ + .bounded = 1, \ + .min = (i), \ + .max = (a), \ + .offset = offsetof(s, f), \ + .size = sizeof(((s *)0)->f), \ + }) + /** Static initializer for ARGS() to target an arbitrary bit-mask. */ #define ARGS_ENTRY_MASK(s, f, m) \ (&(const struct arg){ \ @@ -626,11 +966,46 @@ 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; + } ia_destroy; /**< Indirect action destroy arguments. */ + struct { + uint32_t action_id; + } ia; /* Indirect action query arguments */ + struct { + uint32_t table_id; + uint32_t pat_templ_id; + uint32_t act_templ_id; struct rte_flow_attr attr; + struct tunnel_ops tunnel_ops; struct rte_flow_item *pattern; struct rte_flow_action *actions; + struct rte_flow_action *masks; uint32_t pattern_n; uint32_t actions_n; uint8_t *data; @@ -639,6 +1014,11 @@ struct buffer { uint32_t *rule; uint32_t rule_n; } destroy; /**< Destroy arguments. */ + struct { + char file[128]; + bool mode; + uint32_t rule; + } dump; /**< Dump arguments. */ struct { uint32_t rule; struct rte_flow_action action; @@ -650,6 +1030,17 @@ struct buffer { struct { int set; } isolate; /**< Isolated mode arguments. */ + struct { + int destroy; + } aged; /**< Aged arguments. */ + struct { + uint32_t policy_id; + } policy;/**< Policy arguments. */ + struct { + uint16_t token; + uintptr_t uintptr; + char filename[128]; + } flex; /**< Flex arguments*/ } args; /**< Command arguments. */ }; @@ -677,13 +1068,167 @@ 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, + INDIRECT_ACTION_EGRESS, + INDIRECT_ACTION_TRANSFER, + INDIRECT_ACTION_SPEC, + ZERO, +}; + +static const enum index next_dump_subcmd[] = { + DUMP_ALL, + DUMP_ONE, + ZERO, +}; + +static const enum index next_ia_subcmd[] = { + INDIRECT_ACTION_CREATE, + INDIRECT_ACTION_UPDATE, + INDIRECT_ACTION_DESTROY, + INDIRECT_ACTION_QUERY, + ZERO, +}; + static const enum index next_vc_attr[] = { - GROUP, - PRIORITY, - INGRESS, - EGRESS, - TRANSFER, - PATTERN, + VC_GROUP, + VC_PRIORITY, + VC_INGRESS, + VC_EGRESS, + VC_TRANSFER, + VC_TUNNEL_SET, + VC_TUNNEL_MATCH, + ITEM_PATTERN, ZERO, }; @@ -693,12 +1238,30 @@ static const enum index next_destroy_attr[] = { ZERO, }; +static const enum index next_dump_attr[] = { + COMMON_FILE_PATH, + END, + ZERO, +}; + static const enum index next_list_attr[] = { LIST_GROUP, END, ZERO, }; +static const enum index next_aged_attr[] = { + AGED_DESTROY, + END, + ZERO, +}; + +static const enum index next_ia_destroy_attr[] = { + INDIRECT_ACTION_DESTROY_ID, + END, + ZERO, +}; + static const enum index item_param[] = { ITEM_PARAM_IS, ITEM_PARAM_SPEC, @@ -740,6 +1303,7 @@ static const enum index next_item[] = { ITEM_VXLAN_GPE, ITEM_ARP_ETH_IPV4, ITEM_IPV6_EXT, + ITEM_IPV6_FRAG_EXT, ITEM_ICMP6, ITEM_ICMP6_ND_NS, ITEM_ICMP6_ND_NA, @@ -748,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, @@ -756,6 +1321,17 @@ static const enum index next_item[] = { ITEM_TAG, ITEM_L2TPV3OIP, ITEM_ESP, + ITEM_AH, + ITEM_PFCP, + ITEM_ECPRI, + ITEM_GENEVE_OPT, + ITEM_INTEGRITY, + ITEM_CONNTRACK, + ITEM_PORT_REPRESENTOR, + ITEM_REPRESENTED_PORT, + ITEM_FLEX, + ITEM_L2TPV2, + ITEM_PPP, END_SET, ZERO, }; @@ -802,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, }; @@ -810,6 +1387,7 @@ static const enum index item_eth[] = { ITEM_ETH_DST, ITEM_ETH_SRC, ITEM_ETH_TYPE, + ITEM_ETH_HAS_VLAN, ITEM_NEXT, ZERO, }; @@ -820,12 +1398,16 @@ static const enum index item_vlan[] = { ITEM_VLAN_DEI, ITEM_VLAN_VID, ITEM_VLAN_INNER_TYPE, + ITEM_VLAN_HAS_MORE_VLAN, ITEM_NEXT, ZERO, }; static const enum index item_ipv4[] = { + ITEM_IPV4_VER_IHL, ITEM_IPV4_TOS, + ITEM_IPV4_ID, + ITEM_IPV4_FRAGMENT_OFFSET, ITEM_IPV4_TTL, ITEM_IPV4_PROTO, ITEM_IPV4_SRC, @@ -841,6 +1423,7 @@ static const enum index item_ipv6[] = { ITEM_IPV6_HOP, ITEM_IPV6_SRC, ITEM_IPV6_DST, + ITEM_IPV6_HAS_FRAG_EXT, ITEM_NEXT, ZERO, }; @@ -848,6 +1431,8 @@ static const enum index item_ipv6[] = { static const enum index item_icmp[] = { ITEM_ICMP_TYPE, ITEM_ICMP_CODE, + ITEM_ICMP_IDENT, + ITEM_ICMP_SEQ, ITEM_NEXT, ZERO, }; @@ -878,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, }; @@ -918,7 +1504,17 @@ 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, ITEM_GTP_TEID, ITEM_NEXT, ZERO, @@ -927,6 +1523,7 @@ static const enum index item_gtp[] = { static const enum index item_geneve[] = { ITEM_GENEVE_VNI, ITEM_GENEVE_PROTO, + ITEM_GENEVE_OPTLEN, ITEM_NEXT, ZERO, }; @@ -952,6 +1549,14 @@ static const enum index item_ipv6_ext[] = { ZERO, }; +static const enum index item_ipv6_frag_ext[] = { + ITEM_IPV6_FRAG_EXT_NEXT_HDR, + ITEM_IPV6_FRAG_EXT_FRAG_DATA, + ITEM_IPV6_FRAG_EXT_ID, + ITEM_NEXT, + ZERO, +}; + static const enum index item_icmp6[] = { ITEM_ICMP6_TYPE, ITEM_ICMP6_CODE, @@ -1015,7 +1620,6 @@ static const enum index item_pppoes[] = { }; static const enum index item_pppoe_proto_id[] = { - ITEM_PPPOE_PROTO_ID, ITEM_NEXT, ZERO, }; @@ -1033,6 +1637,19 @@ static const enum index item_esp[] = { ZERO, }; +static const enum index item_ah[] = { + ITEM_AH_SPI, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_pfcp[] = { + ITEM_PFCP_S_FIELD, + ITEM_PFCP_SEID, + ITEM_NEXT, + ZERO, +}; + static const enum index next_set_raw[] = { SET_RAW_INDEX, ITEM_ETH, @@ -1052,6 +1669,141 @@ static const enum index item_l2tpv3oip[] = { ZERO, }; +static const enum index item_ecpri[] = { + ITEM_ECPRI_COMMON, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_ecpri_common[] = { + ITEM_ECPRI_COMMON_TYPE, + ZERO, +}; + +static const enum index item_ecpri_common_type[] = { + ITEM_ECPRI_COMMON_TYPE_IQ_DATA, + ITEM_ECPRI_COMMON_TYPE_RTC_CTRL, + ITEM_ECPRI_COMMON_TYPE_DLY_MSR, + ZERO, +}; + +static const enum index item_geneve_opt[] = { + ITEM_GENEVE_OPT_CLASS, + ITEM_GENEVE_OPT_TYPE, + ITEM_GENEVE_OPT_LENGTH, + ITEM_GENEVE_OPT_DATA, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_integrity[] = { + ITEM_INTEGRITY_LEVEL, + ITEM_INTEGRITY_VALUE, + ZERO, +}; + +static const enum index item_integrity_lv[] = { + ITEM_INTEGRITY_LEVEL, + ITEM_INTEGRITY_VALUE, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_port_representor[] = { + ITEM_PORT_REPRESENTOR_PORT_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_represented_port[] = { + ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_flex[] = { + ITEM_FLEX_PATTERN_HANDLE, + ITEM_FLEX_ITEM_HANDLE, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2[] = { + ITEM_L2TPV2_TYPE, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type[] = { + ITEM_L2TPV2_TYPE_DATA, + ITEM_L2TPV2_TYPE_DATA_L, + ITEM_L2TPV2_TYPE_DATA_S, + ITEM_L2TPV2_TYPE_DATA_O, + ITEM_L2TPV2_TYPE_DATA_L_S, + ITEM_L2TPV2_TYPE_CTRL, + ZERO, +}; + +static const enum index item_l2tpv2_type_data[] = { + ITEM_L2TPV2_MSG_DATA_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_SESSION_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_l[] = { + ITEM_L2TPV2_MSG_DATA_L_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_SESSION_ID, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_s[] = { + ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_S_NS, + ITEM_L2TPV2_MSG_DATA_S_NR, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_o[] = { + ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_O_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_O_OFFSET, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_data_l_s[] = { + ITEM_L2TPV2_MSG_DATA_L_S_LENGTH, + ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID, + ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID, + ITEM_L2TPV2_MSG_DATA_L_S_NS, + ITEM_L2TPV2_MSG_DATA_L_S_NR, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_l2tpv2_type_ctrl[] = { + ITEM_L2TPV2_MSG_CTRL_LENGTH, + ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID, + ITEM_L2TPV2_MSG_CTRL_SESSION_ID, + ITEM_L2TPV2_MSG_CTRL_NS, + ITEM_L2TPV2_MSG_CTRL_NR, + ITEM_NEXT, + ZERO, +}; + +static const enum index item_ppp[] = { + ITEM_PPP_ADDR, + ITEM_PPP_CTRL, + ITEM_PPP_PROTO_ID, + ITEM_NEXT, + ZERO, +}; + static const enum index next_action[] = { ACTION_END, ACTION_VOID, @@ -1068,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, @@ -1111,6 +1864,14 @@ static const enum index next_action[] = { ACTION_SET_META, ACTION_SET_IPV4_DSCP, ACTION_SET_IPV6_DSCP, + ACTION_AGE, + ACTION_SAMPLE, + ACTION_INDIRECT, + ACTION_MODIFY_FIELD, + ACTION_CONNTRACK, + ACTION_CONNTRACK_UPDATE, + ACTION_PORT_REPRESENTOR, + ACTION_REPRESENTED_PORT, ZERO, }; @@ -1128,7 +1889,6 @@ static const enum index action_queue[] = { static const enum index action_count[] = { ACTION_COUNT_ID, - ACTION_COUNT_SHARED, ACTION_NEXT, ZERO, }; @@ -1171,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, @@ -1336,12 +2102,81 @@ static const enum index action_set_ipv6_dscp[] = { ZERO, }; +static const enum index action_age[] = { + ACTION_AGE, + ACTION_AGE_TIMEOUT, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_sample[] = { + ACTION_SAMPLE, + ACTION_SAMPLE_RATIO, + ACTION_SAMPLE_INDEX, + ACTION_NEXT, + ZERO, +}; + +static const enum index next_action_sample[] = { + ACTION_QUEUE, + ACTION_RSS, + ACTION_MARK, + ACTION_COUNT, + ACTION_PORT_ID, + ACTION_RAW_ENCAP, + ACTION_VXLAN_ENCAP, + ACTION_NVGRE_ENCAP, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_modify_field_dst[] = { + ACTION_MODIFY_FIELD_DST_LEVEL, + ACTION_MODIFY_FIELD_DST_OFFSET, + ACTION_MODIFY_FIELD_SRC_TYPE, + ZERO, +}; + +static const enum index action_modify_field_src[] = { + ACTION_MODIFY_FIELD_SRC_LEVEL, + ACTION_MODIFY_FIELD_SRC_OFFSET, + ACTION_MODIFY_FIELD_SRC_VALUE, + ACTION_MODIFY_FIELD_SRC_POINTER, + ACTION_MODIFY_FIELD_WIDTH, + ZERO, +}; + +static const enum index action_update_conntrack[] = { + ACTION_CONNTRACK_UPDATE_DIR, + ACTION_CONNTRACK_UPDATE_CTX, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_port_representor[] = { + ACTION_PORT_REPRESENTOR_PORT_ID, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_represented_port[] = { + ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID, + ACTION_NEXT, + ZERO, +}; + static int parse_set_raw_encap_decap(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_set_sample_action(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); static int parse_set_init(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int +parse_flex_handle(struct context *, const struct token *, + const char *, unsigned int, void *, unsigned int); static int parse_init(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1352,6 +2187,16 @@ static int parse_vc_spec(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); static int parse_vc_conf(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_vc_item_ecpri_type(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_vc_item_l2tpv2_type(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_vc_action_meter_color_type(struct context *, + const struct token *, + const char *, unsigned int, void *, + unsigned int); static int parse_vc_action_rss(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1401,15 +2246,38 @@ static int parse_vc_action_raw_decap_index(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); static int parse_vc_action_set_meta(struct context *ctx, + const struct token *token, const char *str, + unsigned int len, void *buf, + unsigned int size); +static int parse_vc_action_sample(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size); +static int +parse_vc_action_sample_index(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size); +static int +parse_vc_modify_field_op(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size); +static int +parse_vc_modify_field_id(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size); +static int +parse_vc_action_conntrack_update(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size); static int parse_destroy(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); static int parse_flush(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_dump(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); static int parse_query(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1419,14 +2287,54 @@ static int parse_action(struct context *, const struct token *, static int parse_list(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_aged(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); static int parse_isolate(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); -static int parse_int(struct context *, const struct token *, - const char *, unsigned int, - void *, unsigned int); -static int parse_prefix(struct context *, const struct token *, - const char *, unsigned int, +static int parse_configure(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_template(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_template_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_table(struct context *, const struct token *, + const char *, unsigned int, void *, unsigned int); +static int parse_table_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qo(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qo_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qia(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_qia_destroy(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_push(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_pull(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_tunnel(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_flex(struct context *, const struct token *, + const char *, unsigned int, void *, unsigned int); +static int parse_int(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_prefix(struct context *, const struct token *, + const char *, unsigned int, void *, unsigned int); static int parse_boolean(struct context *, const struct token *, const char *, unsigned int, @@ -1437,6 +2345,9 @@ static int parse_string(struct context *, const struct token *, static int parse_hex(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size); +static int parse_string0(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); static int parse_mac_addr(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1449,6 +2360,18 @@ static int parse_ipv6_addr(struct context *, const struct token *, static int parse_port(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_ia(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); +static int parse_ia_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size); +static int parse_ia_id2ptr(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size); +static int parse_mp(struct context *, const struct token *, + const char *, unsigned int, + void *, unsigned int); static int comp_none(struct context *, const struct token *, unsigned int, char *, unsigned int); static int comp_boolean(struct context *, const struct token *, @@ -1465,6 +2388,20 @@ static int comp_vc_action_rss_queue(struct context *, const struct token *, unsigned int, char *, unsigned int); static int comp_set_raw_index(struct context *, const struct token *, unsigned int, char *, unsigned int); +static int comp_set_sample_index(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_set_modify_field_op(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_set_modify_field_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_pattern_template_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_actions_template_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_table_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); +static int comp_queue_id(struct context *, const struct token *, + unsigned int, char *, unsigned int); /** Token definitions. */ static const struct token token_list[] = { @@ -1472,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 = "", @@ -1490,147 +2427,766 @@ 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, + }, + [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, }, + [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 - (VALIDATE, + (INFO, + CONFIGURE, + PATTERN_TEMPLATE, + ACTIONS_TEMPLATE, + TABLE, + INDIRECT_ACTION, + VALIDATE, CREATE, DESTROY, FLUSH, + DUMP, LIST, + AGED, QUERY, - ISOLATE)), + ISOLATE, + TUNNEL, + FLEX, + QUEUE, + PUSH, + PULL)), .call = parse_init, }, + /* Top-level command. */ + [INFO] = { + .name = "info", + .help = "get information about flow engine", + .next = NEXT(NEXT_ENTRY(END), + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_configure, + }, + /* Top-level command. */ + [CONFIGURE] = { + .name = "configure", + .help = "configure flow engine", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_configure, + }, + /* Configure arguments. */ + [CONFIG_QUEUES_NUMBER] = { + .name = "queues_number", + .help = "number of queues", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.nb_queue)), + }, + [CONFIG_QUEUES_SIZE] = { + .name = "queues_size", + .help = "number of elements in queues", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.queue_attr.size)), + }, + [CONFIG_COUNTERS_NUMBER] = { + .name = "counters_number", + .help = "number of counters", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.port_attr.nb_counters)), + }, + [CONFIG_AGING_OBJECTS_NUMBER] = { + .name = "aging_counters_number", + .help = "number of aging objects", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.port_attr.nb_aging_objects)), + }, + [CONFIG_METERS_NUMBER] = { + .name = "meters_number", + .help = "number of meters", + .next = NEXT(next_config_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.configure.port_attr.nb_meters)), + }, + /* Top-level command. */ + [PATTERN_TEMPLATE] = { + .name = "pattern_template", + .type = "{command} {port_id} [{arg} [...]]", + .help = "manage pattern templates", + .next = NEXT(next_pt_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_template, + }, + /* Sub-level commands. */ + [PATTERN_TEMPLATE_CREATE] = { + .name = "create", + .help = "create pattern template", + .next = NEXT(next_pt_attr), + .call = parse_template, + }, + [PATTERN_TEMPLATE_DESTROY] = { + .name = "destroy", + .help = "destroy pattern template", + .next = NEXT(NEXT_ENTRY(PATTERN_TEMPLATE_DESTROY_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_template_destroy, + }, + /* Pattern template arguments. */ + [PATTERN_TEMPLATE_CREATE_ID] = { + .name = "pattern_template_id", + .help = "specify a pattern template id to create", + .next = NEXT(next_pt_attr, + NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.pat_templ_id)), + }, + [PATTERN_TEMPLATE_DESTROY_ID] = { + .name = "pattern_template", + .help = "specify a pattern template id to destroy", + .next = NEXT(next_pt_destroy_attr, + NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.templ_destroy.template_id)), + .call = parse_template_destroy, + }, + [PATTERN_TEMPLATE_RELAXED_MATCHING] = { + .name = "relaxed", + .help = "is matching relaxed", + .next = NEXT(next_pt_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY_BF(struct buffer, + args.vc.attr.reserved, 1)), + }, + [PATTERN_TEMPLATE_INGRESS] = { + .name = "ingress", + .help = "attribute pattern to ingress", + .next = NEXT(next_pt_attr), + .call = parse_template, + }, + [PATTERN_TEMPLATE_EGRESS] = { + .name = "egress", + .help = "attribute pattern to egress", + .next = NEXT(next_pt_attr), + .call = parse_template, + }, + [PATTERN_TEMPLATE_TRANSFER] = { + .name = "transfer", + .help = "attribute pattern to transfer", + .next = NEXT(next_pt_attr), + .call = parse_template, + }, + [PATTERN_TEMPLATE_SPEC] = { + .name = "template", + .help = "specify item to create pattern template", + .next = NEXT(next_item), + }, + /* Top-level command. */ + [ACTIONS_TEMPLATE] = { + .name = "actions_template", + .type = "{command} {port_id} [{arg} [...]]", + .help = "manage actions templates", + .next = NEXT(next_at_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_template, + }, + /* Sub-level commands. */ + [ACTIONS_TEMPLATE_CREATE] = { + .name = "create", + .help = "create actions template", + .next = NEXT(next_at_attr), + .call = parse_template, + }, + [ACTIONS_TEMPLATE_DESTROY] = { + .name = "destroy", + .help = "destroy actions template", + .next = NEXT(NEXT_ENTRY(ACTIONS_TEMPLATE_DESTROY_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_template_destroy, + }, + /* Actions template arguments. */ + [ACTIONS_TEMPLATE_CREATE_ID] = { + .name = "actions_template_id", + .help = "specify an actions template id to create", + .next = NEXT(NEXT_ENTRY(ACTIONS_TEMPLATE_MASK), + NEXT_ENTRY(ACTIONS_TEMPLATE_SPEC), + NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.act_templ_id)), + }, + [ACTIONS_TEMPLATE_DESTROY_ID] = { + .name = "actions_template", + .help = "specify an actions template id to destroy", + .next = NEXT(next_at_destroy_attr, + NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.templ_destroy.template_id)), + .call = parse_template_destroy, + }, + [ACTIONS_TEMPLATE_INGRESS] = { + .name = "ingress", + .help = "attribute actions to ingress", + .next = NEXT(next_at_attr), + .call = parse_template, + }, + [ACTIONS_TEMPLATE_EGRESS] = { + .name = "egress", + .help = "attribute actions to egress", + .next = NEXT(next_at_attr), + .call = parse_template, + }, + [ACTIONS_TEMPLATE_TRANSFER] = { + .name = "transfer", + .help = "attribute actions to transfer", + .next = NEXT(next_at_attr), + .call = parse_template, + }, + [ACTIONS_TEMPLATE_SPEC] = { + .name = "template", + .help = "specify action to create actions template", + .next = NEXT(next_action), + .call = parse_template, + }, + [ACTIONS_TEMPLATE_MASK] = { + .name = "mask", + .help = "specify action mask to create actions template", + .next = NEXT(next_action), + .call = parse_template, + }, + /* Top-level command. */ + [TABLE] = { + .name = "template_table", + .type = "{command} {port_id} [{arg} [...]]", + .help = "manage template tables", + .next = NEXT(next_table_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_table, + }, + /* Sub-level commands. */ + [TABLE_CREATE] = { + .name = "create", + .help = "create template table", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_DESTROY] = { + .name = "destroy", + .help = "destroy template table", + .next = NEXT(NEXT_ENTRY(TABLE_DESTROY_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_table_destroy, + }, + /* Table arguments. */ + [TABLE_CREATE_ID] = { + .name = "table_id", + .help = "specify table id to create", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_TABLE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.table.id)), + }, + [TABLE_DESTROY_ID] = { + .name = "table", + .help = "specify table id to destroy", + .next = NEXT(next_table_destroy_attr, + NEXT_ENTRY(COMMON_TABLE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.table_destroy.table_id)), + .call = parse_table_destroy, + }, + [TABLE_GROUP] = { + .name = "group", + .help = "specify a group", + .next = NEXT(next_table_attr, NEXT_ENTRY(COMMON_GROUP_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.table.attr.flow_attr.group)), + }, + [TABLE_PRIORITY] = { + .name = "priority", + .help = "specify a priority level", + .next = NEXT(next_table_attr, NEXT_ENTRY(COMMON_PRIORITY_LEVEL)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.table.attr.flow_attr.priority)), + }, + [TABLE_EGRESS] = { + .name = "egress", + .help = "affect rule to egress", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_INGRESS] = { + .name = "ingress", + .help = "affect rule to ingress", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_TRANSFER] = { + .name = "transfer", + .help = "affect rule to transfer", + .next = NEXT(next_table_attr), + .call = parse_table, + }, + [TABLE_RULES_NUMBER] = { + .name = "rules_number", + .help = "number of rules in table", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.table.attr.nb_flows)), + }, + [TABLE_PATTERN_TEMPLATE] = { + .name = "pattern_template", + .help = "specify pattern template id", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_PATTERN_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.table.pat_templ_id)), + .call = parse_table, + }, + [TABLE_ACTIONS_TEMPLATE] = { + .name = "actions_template", + .help = "specify actions template id", + .next = NEXT(next_table_attr, + NEXT_ENTRY(COMMON_ACTIONS_TEMPLATE_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.table.act_templ_id)), + .call = parse_table, + }, + /* Top-level command. */ + [QUEUE] = { + .name = "queue", + .help = "queue a flow rule operation", + .next = NEXT(next_queue_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_qo, + }, + /* Sub-level commands. */ + [QUEUE_CREATE] = { + .name = "create", + .help = "create a flow rule", + .next = NEXT(NEXT_ENTRY(QUEUE_TEMPLATE_TABLE), + NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + .call = parse_qo, + }, + [QUEUE_DESTROY] = { + .name = "destroy", + .help = "destroy a flow rule", + .next = NEXT(NEXT_ENTRY(QUEUE_DESTROY_ID), + NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + .call = parse_qo_destroy, + }, + [QUEUE_INDIRECT_ACTION] = { + .name = "indirect_action", + .help = "queue indirect actions", + .next = NEXT(next_qia_subcmd, NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + .call = parse_qia, + }, + /* Queue arguments. */ + [QUEUE_TEMPLATE_TABLE] = { + .name = "template table", + .help = "specify table id", + .next = NEXT(NEXT_ENTRY(QUEUE_PATTERN_TEMPLATE), + NEXT_ENTRY(COMMON_TABLE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.vc.table_id)), + .call = parse_qo, + }, + [QUEUE_PATTERN_TEMPLATE] = { + .name = "pattern_template", + .help = "specify pattern template index", + .next = NEXT(NEXT_ENTRY(QUEUE_ACTIONS_TEMPLATE), + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.vc.pat_templ_id)), + .call = parse_qo, + }, + [QUEUE_ACTIONS_TEMPLATE] = { + .name = "actions_template", + .help = "specify actions template index", + .next = NEXT(NEXT_ENTRY(QUEUE_CREATE_POSTPONE), + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct buffer, + args.vc.act_templ_id)), + .call = parse_qo, + }, + [QUEUE_CREATE_POSTPONE] = { + .name = "postpone", + .help = "postpone create operation", + .next = NEXT(NEXT_ENTRY(ITEM_PATTERN), + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + .call = parse_qo, + }, + [QUEUE_DESTROY_POSTPONE] = { + .name = "postpone", + .help = "postpone destroy operation", + .next = NEXT(NEXT_ENTRY(QUEUE_DESTROY_ID), + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + .call = parse_qo_destroy, + }, + [QUEUE_DESTROY_ID] = { + .name = "rule", + .help = "specify rule id to destroy", + .next = NEXT(next_queue_destroy_attr, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.destroy.rule)), + .call = parse_qo_destroy, + }, + /* Queue indirect action arguments */ + [QUEUE_INDIRECT_ACTION_CREATE] = { + .name = "create", + .help = "create indirect action", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_UPDATE] = { + .name = "update", + .help = "update indirect action", + .next = NEXT(next_qia_update_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_DESTROY] = { + .name = "destroy", + .help = "destroy indirect action", + .next = NEXT(next_qia_destroy_attr), + .call = parse_qia_destroy, + }, + /* Indirect action destroy arguments. */ + [QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE] = { + .name = "postpone", + .help = "postpone destroy operation", + .next = NEXT(next_qia_destroy_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + }, + [QUEUE_INDIRECT_ACTION_DESTROY_ID] = { + .name = "action_id", + .help = "specify a indirect action id to destroy", + .next = NEXT(next_qia_destroy_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.ia_destroy.action_id)), + .call = parse_qia_destroy, + }, + /* Indirect action update arguments. */ + [QUEUE_INDIRECT_ACTION_UPDATE_POSTPONE] = { + .name = "postpone", + .help = "postpone update operation", + .next = NEXT(next_qia_update_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + }, + /* Indirect action create arguments. */ + [QUEUE_INDIRECT_ACTION_CREATE_ID] = { + .name = "action_id", + .help = "specify a indirect action id to create", + .next = NEXT(next_qia_create_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), + }, + [QUEUE_INDIRECT_ACTION_INGRESS] = { + .name = "ingress", + .help = "affect rule to ingress", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_EGRESS] = { + .name = "egress", + .help = "affect rule to egress", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_TRANSFER] = { + .name = "transfer", + .help = "affect rule to transfer", + .next = NEXT(next_qia_create_attr), + .call = parse_qia, + }, + [QUEUE_INDIRECT_ACTION_CREATE_POSTPONE] = { + .name = "postpone", + .help = "postpone create operation", + .next = NEXT(next_qia_create_attr, + NEXT_ENTRY(COMMON_BOOLEAN)), + .args = ARGS(ARGS_ENTRY(struct buffer, postpone)), + }, + [QUEUE_INDIRECT_ACTION_SPEC] = { + .name = "action", + .help = "specify action to create indirect handle", + .next = NEXT(next_action), + }, + /* Top-level command. */ + [PUSH] = { + .name = "push", + .help = "push enqueued operations", + .next = NEXT(NEXT_ENTRY(PUSH_QUEUE), NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_push, + }, + /* Sub-level commands. */ + [PUSH_QUEUE] = { + .name = "queue", + .help = "specify queue id", + .next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + }, + /* Top-level command. */ + [PULL] = { + .name = "pull", + .help = "pull flow operations results", + .next = NEXT(NEXT_ENTRY(PULL_QUEUE), NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_pull, + }, + /* Sub-level commands. */ + [PULL_QUEUE] = { + .name = "queue", + .help = "specify queue id", + .next = NEXT(NEXT_ENTRY(END), NEXT_ENTRY(COMMON_QUEUE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, queue)), + }, + /* Top-level command. */ + [INDIRECT_ACTION] = { + .name = "indirect_action", + .type = "{command} {port_id} [{arg} [...]]", + .help = "manage indirect actions", + .next = NEXT(next_ia_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_ia, + }, /* Sub-level commands. */ + [INDIRECT_ACTION_CREATE] = { + .name = "create", + .help = "create indirect action", + .next = NEXT(next_ia_create_attr), + .call = parse_ia, + }, + [INDIRECT_ACTION_UPDATE] = { + .name = "update", + .help = "update indirect action", + .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_SPEC), + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), + .call = parse_ia, + }, + [INDIRECT_ACTION_DESTROY] = { + .name = "destroy", + .help = "destroy indirect action", + .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_DESTROY_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_ia_destroy, + }, + [INDIRECT_ACTION_QUERY] = { + .name = "query", + .help = "query indirect action", + .next = NEXT(NEXT_ENTRY(END), + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.ia.action_id)), + .call = parse_ia, + }, [VALIDATE] = { .name = "validate", .help = "check whether a flow rule can be created", - .next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)), + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), .call = parse_vc, }, [CREATE] = { .name = "create", .help = "create a flow rule", - .next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)), + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), .call = parse_vc, }, [DESTROY] = { .name = "destroy", .help = "destroy specific flow rules", - .next = NEXT(NEXT_ENTRY(DESTROY_RULE), NEXT_ENTRY(PORT_ID)), + .next = NEXT(NEXT_ENTRY(DESTROY_RULE), + NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), .call = parse_destroy, }, [FLUSH] = { .name = "flush", .help = "destroy all flow rules", - .next = NEXT(NEXT_ENTRY(PORT_ID)), + .next = NEXT(NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), .call = parse_flush, }, + [DUMP] = { + .name = "dump", + .help = "dump single/all flow rules to file", + .next = NEXT(next_dump_subcmd, NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_dump, + }, [QUERY] = { .name = "query", .help = "query an existing flow rule", .next = NEXT(NEXT_ENTRY(QUERY_ACTION), - NEXT_ENTRY(RULE_ID), - NEXT_ENTRY(PORT_ID)), + NEXT_ENTRY(COMMON_RULE_ID), + NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, args.query.action.type), ARGS_ENTRY(struct buffer, args.query.rule), ARGS_ENTRY(struct buffer, port)), @@ -1639,27 +3195,130 @@ static const struct token token_list[] = { [LIST] = { .name = "list", .help = "list existing flow rules", - .next = NEXT(next_list_attr, NEXT_ENTRY(PORT_ID)), + .next = NEXT(next_list_attr, NEXT_ENTRY(COMMON_PORT_ID)), .args = ARGS(ARGS_ENTRY(struct buffer, port)), .call = parse_list, }, + [AGED] = { + .name = "aged", + .help = "list and destroy aged flows", + .next = NEXT(next_aged_attr, NEXT_ENTRY(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", + .next = NEXT(NEXT_ENTRY + (TUNNEL_CREATE, TUNNEL_LIST, TUNNEL_DESTROY)), + .call = parse_tunnel, + }, + /* Tunnel arguments. */ + [TUNNEL_CREATE] = { + .name = "create", + .help = "create new tunnel object", + .next = NEXT(NEXT_ENTRY(TUNNEL_CREATE_TYPE), + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_tunnel, + }, + [TUNNEL_CREATE_TYPE] = { + .name = "type", + .help = "create new tunnel", + .next = NEXT(NEXT_ENTRY(COMMON_FILE_PATH)), + .args = ARGS(ARGS_ENTRY(struct tunnel_ops, type)), + .call = parse_tunnel, + }, + [TUNNEL_DESTROY] = { + .name = "destroy", + .help = "destroy tunnel", + .next = NEXT(NEXT_ENTRY(TUNNEL_DESTROY_ID), + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_tunnel, + }, + [TUNNEL_DESTROY_ID] = { + .name = "id", + .help = "tunnel identifier to destroy", + .next = NEXT(NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)), + .call = parse_tunnel, + }, + [TUNNEL_LIST] = { + .name = "list", + .help = "list existing tunnels", + .next = NEXT(NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, port)), + .call = parse_tunnel, + }, /* Destroy arguments. */ [DESTROY_RULE] = { .name = "rule", .help = "specify a rule identifier", - .next = NEXT(next_destroy_attr, NEXT_ENTRY(RULE_ID)), + .next = NEXT(next_destroy_attr, NEXT_ENTRY(COMMON_RULE_ID)), .args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.destroy.rule)), .call = parse_destroy, }, + /* Dump arguments. */ + [DUMP_ALL] = { + .name = "all", + .help = "dump all", + .next = NEXT(next_dump_attr), + .args = ARGS(ARGS_ENTRY(struct buffer, args.dump.file)), + .call = parse_dump, + }, + [DUMP_ONE] = { + .name = "rule", + .help = "dump one rule", + .next = NEXT(next_dump_attr, NEXT_ENTRY(COMMON_RULE_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.dump.file), + ARGS_ENTRY(struct buffer, args.dump.rule)), + .call = parse_dump, + }, /* Query arguments. */ [QUERY_ACTION] = { .name = "{action}", @@ -1672,45 +3331,65 @@ 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, }, + [AGED_DESTROY] = { + .name = "destroy", + .help = "specify aged flows need be destroyed", + .call = parse_aged, + .comp = comp_none, + }, /* Validate/create attributes. */ - [GROUP] = { + [VC_GROUP] = { .name = "group", .help = "specify a group", - .next = NEXT(next_vc_attr, NEXT_ENTRY(GROUP_ID)), + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_GROUP_ID)), .args = ARGS(ARGS_ENTRY(struct rte_flow_attr, group)), .call = parse_vc, }, - [PRIORITY] = { + [VC_PRIORITY] = { .name = "priority", .help = "specify a priority level", - .next = NEXT(next_vc_attr, NEXT_ENTRY(PRIORITY_LEVEL)), + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_PRIORITY_LEVEL)), .args = ARGS(ARGS_ENTRY(struct rte_flow_attr, priority)), .call = parse_vc, }, - [INGRESS] = { + [VC_INGRESS] = { .name = "ingress", .help = "affect rule to ingress", .next = NEXT(next_vc_attr), .call = parse_vc, }, - [EGRESS] = { + [VC_EGRESS] = { .name = "egress", .help = "affect rule to egress", .next = NEXT(next_vc_attr), .call = parse_vc, }, - [TRANSFER] = { + [VC_TRANSFER] = { .name = "transfer", .help = "apply rule directly to endpoints found in pattern", .next = NEXT(next_vc_attr), .call = parse_vc, }, + [VC_TUNNEL_SET] = { + .name = "tunnel_set", + .help = "tunnel steer rule", + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)), + .call = parse_vc, + }, + [VC_TUNNEL_MATCH] = { + .name = "tunnel_match", + .help = "tunnel match rule", + .next = NEXT(next_vc_attr, NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)), + .call = parse_vc, + }, /* Validate/create pattern. */ - [PATTERN] = { + [ITEM_PATTERN] = { .name = "pattern", .help = "submit a list of pattern items", .next = NEXT(next_item), @@ -1750,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] = { @@ -1777,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] = { @@ -1797,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] = { @@ -1811,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] = { @@ -1825,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] = { @@ -1838,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] = { @@ -1851,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)), @@ -1897,21 +3592,28 @@ 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(COMMON_UNSIGNED), item_param), + .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_eth, + has_vlan, 1)), + }, [ITEM_VLAN] = { .name = "vlan", .help = "match 802.1Q/ad VLAN tag", @@ -1922,37 +3624,50 @@ 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(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_vlan, + has_more_vlan, 1)), + }, [ITEM_IPV4] = { .name = "ipv4", .help = "match IPv4 header", @@ -1960,38 +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(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4, + hdr.packet_id)), + }, + [ITEM_IPV4_FRAGMENT_OFFSET] = { + .name = "fragment_offset", + .help = "fragmentation flags and fragment offset", + .next = NEXT(item_ipv4, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4, + hdr.fragment_offset)), + }, [ITEM_IPV4_TTL] = { .name = "ttl", .help = "time to live", - .next = NEXT(item_ipv4, NEXT_ENTRY(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)), }, @@ -2005,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")), @@ -2013,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")), @@ -2021,31 +3767,43 @@ 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(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_ipv6, + has_frag_ext, 1)), + }, [ITEM_ICMP] = { .name = "icmp", .help = "match ICMP header", @@ -2056,17 +3814,35 @@ 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(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp, + hdr.icmp_ident)), + }, + [ITEM_ICMP_SEQ] = { + .name = "seq", + .help = "ICMP packet sequence number", + .next = NEXT(item_icmp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp, + hdr.icmp_seq_nb)), + }, [ITEM_UDP] = { .name = "udp", .help = "match UDP header", @@ -2077,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)), }, @@ -2098,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)), }, @@ -2126,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)), }, @@ -2161,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", @@ -2174,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")), @@ -2189,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] = { @@ -2202,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")), @@ -2210,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")), @@ -2218,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")), @@ -2233,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)), }, @@ -2243,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")), @@ -2258,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")), @@ -2266,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")), @@ -2282,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)), }, @@ -2293,10 +4092,23 @@ static const struct token token_list[] = { .next = NEXT(item_gtp), .call = parse_vc, }, + [ITEM_GTP_FLAGS] = { + .name = "v_pt_rsv_flags", + .help = "GTP flags", + .next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_gtp, + v_pt_rsv_flags)), + }, + [ITEM_GTP_MSG_TYPE] = { + .name = "msg_type", + .help = "GTP message type", + .next = NEXT(item_gtp, NEXT_ENTRY(COMMON_UNSIGNED), item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_gtp, msg_type)), + }, [ITEM_GTP_TEID] = { .name = "teid", .help = "tunnel endpoint identifier", - .next = NEXT(item_gtp, NEXT_ENTRY(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] = { @@ -2323,16 +4135,27 @@ 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(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_geneve, + ver_opt_len_o_c_rsvd0, + "\x3f\x00")), + }, [ITEM_VXLAN_GPE] = { .name = "vxlan-gpe", .help = "match VXLAN-GPE header", @@ -2344,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)), }, @@ -2359,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)), @@ -2367,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)), @@ -2375,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)), @@ -2383,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)), @@ -2399,10 +4223,43 @@ 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)), }, + [ITEM_IPV6_FRAG_EXT] = { + .name = "ipv6_frag_ext", + .help = "match presence of IPv6 fragment extension header", + .priv = PRIV_ITEM(IPV6_FRAG_EXT, + sizeof(struct rte_flow_item_ipv6_frag_ext)), + .next = NEXT(item_ipv6_frag_ext), + .call = parse_vc, + }, + [ITEM_IPV6_FRAG_EXT_NEXT_HDR] = { + .name = "next_hdr", + .help = "next header", + .next = NEXT(item_ipv6_frag_ext, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ipv6_frag_ext, + hdr.next_header)), + }, + [ITEM_IPV6_FRAG_EXT_FRAG_DATA] = { + .name = "frag_data", + .help = "fragment flags and offset", + .next = NEXT(item_ipv6_frag_ext, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6_frag_ext, + hdr.frag_data)), + }, + [ITEM_IPV6_FRAG_EXT_ID] = { + .name = "packet_id", + .help = "fragment packet id", + .next = NEXT(item_ipv6_frag_ext, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6_frag_ext, + hdr.id)), + }, [ITEM_ICMP6] = { .name = "icmp6", .help = "match any ICMPv6 header", @@ -2413,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)), }, @@ -2435,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)), @@ -2451,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)), @@ -2468,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)), @@ -2486,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)), }, @@ -2504,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)), }, @@ -2519,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")), }, @@ -2533,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", @@ -2547,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", @@ -2575,16 +4470,20 @@ 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)), }, [ITEM_PPPOE_PROTO_ID] = { - .name = "proto_id", + .name = "pppoe_proto_id", .help = "match PPPoE session protocol identifier", .priv = PRIV_ITEM(PPPOE_PROTO_ID, sizeof(struct rte_flow_item_pppoe_proto_id)), - .next = NEXT(item_pppoe_proto_id), + .next = NEXT(item_pppoe_proto_id, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON + (struct rte_flow_item_pppoe_proto_id, proto_id)), .call = parse_vc, }, [ITEM_HIGIG2] = { @@ -2598,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)), }, @@ -2619,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)), }, @@ -2640,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)), }, @@ -2654,10 +4556,514 @@ 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)), }, + [ITEM_AH] = { + .name = "ah", + .help = "match AH header", + .priv = PRIV_ITEM(AH, sizeof(struct rte_flow_item_ah)), + .next = NEXT(item_ah), + .call = parse_vc, + }, + [ITEM_AH_SPI] = { + .name = "spi", + .help = "security parameters index", + .next = NEXT(item_ah, NEXT_ENTRY(COMMON_UNSIGNED), item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ah, spi)), + }, + [ITEM_PFCP] = { + .name = "pfcp", + .help = "match pfcp header", + .priv = PRIV_ITEM(PFCP, sizeof(struct rte_flow_item_pfcp)), + .next = NEXT(item_pfcp), + .call = parse_vc, + }, + [ITEM_PFCP_S_FIELD] = { + .name = "s_field", + .help = "S field", + .next = NEXT(item_pfcp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_pfcp, + s_field)), + }, + [ITEM_PFCP_SEID] = { + .name = "seid", + .help = "session endpoint identifier", + .next = NEXT(item_pfcp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_pfcp, seid)), + }, + [ITEM_ECPRI] = { + .name = "ecpri", + .help = "match eCPRI header", + .priv = PRIV_ITEM(ECPRI, sizeof(struct rte_flow_item_ecpri)), + .next = NEXT(item_ecpri), + .call = parse_vc, + }, + [ITEM_ECPRI_COMMON] = { + .name = "common", + .help = "eCPRI common header", + .next = NEXT(item_ecpri_common), + }, + [ITEM_ECPRI_COMMON_TYPE] = { + .name = "type", + .help = "type of common header", + .next = NEXT(item_ecpri_common_type), + .args = ARGS(ARG_ENTRY_HTON(struct rte_flow_item_ecpri)), + }, + [ITEM_ECPRI_COMMON_TYPE_IQ_DATA] = { + .name = "iq_data", + .help = "Type #0: IQ Data", + .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_IQ_DATA_PCID, + ITEM_NEXT)), + .call = parse_vc_item_ecpri_type, + }, + [ITEM_ECPRI_MSG_IQ_DATA_PCID] = { + .name = "pc_id", + .help = "Physical Channel ID", + .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_IQ_DATA_PCID, + ITEM_ECPRI_COMMON, ITEM_NEXT), + NEXT_ENTRY(COMMON_UNSIGNED), item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri, + hdr.type0.pc_id)), + }, + [ITEM_ECPRI_COMMON_TYPE_RTC_CTRL] = { + .name = "rtc_ctrl", + .help = "Type #2: Real-Time Control Data", + .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_RTC_CTRL_RTCID, + ITEM_NEXT)), + .call = parse_vc_item_ecpri_type, + }, + [ITEM_ECPRI_MSG_RTC_CTRL_RTCID] = { + .name = "rtc_id", + .help = "Real-Time Control Data ID", + .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_RTC_CTRL_RTCID, + ITEM_ECPRI_COMMON, ITEM_NEXT), + NEXT_ENTRY(COMMON_UNSIGNED), item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri, + hdr.type2.rtc_id)), + }, + [ITEM_ECPRI_COMMON_TYPE_DLY_MSR] = { + .name = "delay_measure", + .help = "Type #5: One-Way Delay Measurement", + .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_DLY_MSR_MSRID, + ITEM_NEXT)), + .call = parse_vc_item_ecpri_type, + }, + [ITEM_ECPRI_MSG_DLY_MSR_MSRID] = { + .name = "msr_id", + .help = "Measurement ID", + .next = NEXT(NEXT_ENTRY(ITEM_ECPRI_MSG_DLY_MSR_MSRID, + ITEM_ECPRI_COMMON, ITEM_NEXT), + NEXT_ENTRY(COMMON_UNSIGNED), item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ecpri, + hdr.type5.msr_id)), + }, + [ITEM_GENEVE_OPT] = { + .name = "geneve-opt", + .help = "GENEVE header option", + .priv = PRIV_ITEM(GENEVE_OPT, + sizeof(struct rte_flow_item_geneve_opt) + + ITEM_GENEVE_OPT_DATA_SIZE), + .next = NEXT(item_geneve_opt), + .call = parse_vc, + }, + [ITEM_GENEVE_OPT_CLASS] = { + .name = "class", + .help = "GENEVE option class", + .next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_geneve_opt, + option_class)), + }, + [ITEM_GENEVE_OPT_TYPE] = { + .name = "type", + .help = "GENEVE option type", + .next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_geneve_opt, + option_type)), + }, + [ITEM_GENEVE_OPT_LENGTH] = { + .name = "length", + .help = "GENEVE option data length (in 32b words)", + .next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_BOUNDED( + struct rte_flow_item_geneve_opt, option_len, + 0, 31)), + }, + [ITEM_GENEVE_OPT_DATA] = { + .name = "data", + .help = "GENEVE option data pattern", + .next = NEXT(item_geneve_opt, NEXT_ENTRY(COMMON_HEX), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_geneve_opt, data), + ARGS_ENTRY_ARB(0, 0), + ARGS_ENTRY_ARB + (sizeof(struct rte_flow_item_geneve_opt), + ITEM_GENEVE_OPT_DATA_SIZE)), + }, + [ITEM_INTEGRITY] = { + .name = "integrity", + .help = "match packet integrity", + .priv = PRIV_ITEM(INTEGRITY, + sizeof(struct rte_flow_item_integrity)), + .next = NEXT(item_integrity), + .call = parse_vc, + }, + [ITEM_INTEGRITY_LEVEL] = { + .name = "level", + .help = "integrity level", + .next = NEXT(item_integrity_lv, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_integrity, level)), + }, + [ITEM_INTEGRITY_VALUE] = { + .name = "value", + .help = "integrity value", + .next = NEXT(item_integrity_lv, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_integrity, value)), + }, + [ITEM_CONNTRACK] = { + .name = "conntrack", + .help = "conntrack state", + .next = NEXT(NEXT_ENTRY(ITEM_NEXT), NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_conntrack, flags)), + }, + [ITEM_PORT_REPRESENTOR] = { + .name = "port_representor", + .help = "match traffic entering the embedded switch from the given ethdev", + .priv = PRIV_ITEM(PORT_REPRESENTOR, + sizeof(struct rte_flow_item_ethdev)), + .next = NEXT(item_port_representor), + .call = parse_vc, + }, + [ITEM_PORT_REPRESENTOR_PORT_ID] = { + .name = "port_id", + .help = "ethdev port ID", + .next = NEXT(item_port_representor, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)), + }, + [ITEM_REPRESENTED_PORT] = { + .name = "represented_port", + .help = "match traffic entering the embedded switch from the entity represented by the given ethdev", + .priv = PRIV_ITEM(REPRESENTED_PORT, + sizeof(struct rte_flow_item_ethdev)), + .next = NEXT(item_represented_port), + .call = parse_vc, + }, + [ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID] = { + .name = "ethdev_port_id", + .help = "ethdev port ID", + .next = NEXT(item_represented_port, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)), + }, + [ITEM_FLEX] = { + .name = "flex", + .help = "match flex header", + .priv = PRIV_ITEM(FLEX, sizeof(struct rte_flow_item_flex)), + .next = NEXT(item_flex), + .call = parse_vc, + }, + [ITEM_FLEX_ITEM_HANDLE] = { + .name = "item", + .help = "flex item handle", + .next = NEXT(item_flex, NEXT_ENTRY(COMMON_FLEX_HANDLE), + NEXT_ENTRY(ITEM_PARAM_IS)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_flex, handle)), + }, + [ITEM_FLEX_PATTERN_HANDLE] = { + .name = "pattern", + .help = "flex pattern handle", + .next = NEXT(item_flex, NEXT_ENTRY(COMMON_FLEX_HANDLE), + NEXT_ENTRY(ITEM_PARAM_IS)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_flex, pattern)), + }, + [ITEM_L2TPV2] = { + .name = "l2tpv2", + .help = "match L2TPv2 header", + .priv = PRIV_ITEM(L2TPV2, sizeof(struct rte_flow_item_l2tpv2)), + .next = NEXT(item_l2tpv2), + .call = parse_vc, + }, + [ITEM_L2TPV2_TYPE] = { + .name = "type", + .help = "type of l2tpv2", + .next = NEXT(item_l2tpv2_type), + .args = ARGS(ARG_ENTRY_HTON(struct rte_flow_item_l2tpv2)), + }, + [ITEM_L2TPV2_TYPE_DATA] = { + .name = "data", + .help = "Type #7: data message without any options", + .next = NEXT(item_l2tpv2_type_data), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type7.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type7.session_id)), + }, + [ITEM_L2TPV2_TYPE_DATA_L] = { + .name = "data_l", + .help = "Type #6: data message with length option", + .next = NEXT(item_l2tpv2_type_data_l), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_L_LENGTH] = { + .name = "length", + .help = "message length", + .next = NEXT(item_l2tpv2_type_data_l, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type6.length)), + }, + [ITEM_L2TPV2_MSG_DATA_L_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_l, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type6.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_L_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_l, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type6.session_id)), + }, + [ITEM_L2TPV2_TYPE_DATA_S] = { + .name = "data_s", + .help = "Type #5: data message with ns, nr option", + .next = NEXT(item_l2tpv2_type_data_s), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_S_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_S_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.session_id)), + }, + [ITEM_L2TPV2_MSG_DATA_S_NS] = { + .name = "ns", + .help = "sequence number for message", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.ns)), + }, + [ITEM_L2TPV2_MSG_DATA_S_NR] = { + .name = "nr", + .help = "sequence number for next receive message", + .next = NEXT(item_l2tpv2_type_data_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.nr)), + }, + [ITEM_L2TPV2_TYPE_DATA_O] = { + .name = "data_o", + .help = "Type #4: data message with offset option", + .next = NEXT(item_l2tpv2_type_data_o), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_O_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_o, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type4.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_O_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_o, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type5.session_id)), + }, + [ITEM_L2TPV2_MSG_DATA_O_OFFSET] = { + .name = "offset_size", + .help = "the size of offset padding", + .next = NEXT(item_l2tpv2_type_data_o, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type4.offset_size)), + }, + [ITEM_L2TPV2_TYPE_DATA_L_S] = { + .name = "data_l_s", + .help = "Type #3: data message contains length, ns, nr " + "options", + .next = NEXT(item_l2tpv2_type_data_l_s), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_DATA_L_S_LENGTH] = { + .name = "length", + .help = "message length", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.length)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.session_id)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_NS] = { + .name = "ns", + .help = "sequence number for message", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.ns)), + }, + [ITEM_L2TPV2_MSG_DATA_L_S_NR] = { + .name = "nr", + .help = "sequence number for next receive message", + .next = NEXT(item_l2tpv2_type_data_l_s, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.nr)), + }, + [ITEM_L2TPV2_TYPE_CTRL] = { + .name = "control", + .help = "Type #3: conrtol message contains length, ns, nr " + "options", + .next = NEXT(item_l2tpv2_type_ctrl), + .call = parse_vc_item_l2tpv2_type, + }, + [ITEM_L2TPV2_MSG_CTRL_LENGTH] = { + .name = "length", + .help = "message length", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.length)), + }, + [ITEM_L2TPV2_MSG_CTRL_TUNNEL_ID] = { + .name = "tunnel_id", + .help = "tunnel identifier", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.tunnel_id)), + }, + [ITEM_L2TPV2_MSG_CTRL_SESSION_ID] = { + .name = "session_id", + .help = "session identifier", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.session_id)), + }, + [ITEM_L2TPV2_MSG_CTRL_NS] = { + .name = "ns", + .help = "sequence number for message", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.ns)), + }, + [ITEM_L2TPV2_MSG_CTRL_NR] = { + .name = "nr", + .help = "sequence number for next receive message", + .next = NEXT(item_l2tpv2_type_ctrl, + NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_l2tpv2, + hdr.type3.nr)), + }, + [ITEM_PPP] = { + .name = "ppp", + .help = "match PPP header", + .priv = PRIV_ITEM(PPP, sizeof(struct rte_flow_item_ppp)), + .next = NEXT(item_ppp), + .call = parse_vc, + }, + [ITEM_PPP_ADDR] = { + .name = "addr", + .help = "PPP address", + .next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, hdr.addr)), + }, + [ITEM_PPP_CTRL] = { + .name = "ctrl", + .help = "PPP control", + .next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, hdr.ctrl)), + }, + [ITEM_PPP_PROTO_ID] = { + .name = "proto_id", + .help = "PPP protocol identifier", + .next = NEXT(item_ppp, NEXT_ENTRY(COMMON_UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ppp, + hdr.proto_id)), + }, /* Validate/create actions. */ [ACTIONS] = { .name = "actions", @@ -2700,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, }, @@ -2714,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, }, @@ -2736,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, }, @@ -2758,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", @@ -2809,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), @@ -2830,8 +5228,11 @@ static const struct token token_list[] = { [ACTION_RSS_KEY] = { .name = "key", .help = "RSS hash key", - .next = NEXT(action_rss, NEXT_ENTRY(HEX)), - .args = ARGS(ARGS_ENTRY_ARB(0, 0), + .next = NEXT(action_rss, NEXT_ENTRY(COMMON_HEX)), + .args = ARGS(ARGS_ENTRY_ARB + (offsetof(struct action_rss_data, conf) + + offsetof(struct rte_flow_action_rss, key), + sizeof(((struct rte_flow_action_rss *)0)->key)), ARGS_ENTRY_ARB (offsetof(struct action_rss_data, conf) + offsetof(struct rte_flow_action_rss, key_len), @@ -2842,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), @@ -2880,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, @@ -2888,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, }, @@ -2903,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, @@ -2911,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, @@ -2927,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, @@ -2935,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, }, @@ -2947,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, }, @@ -2966,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, @@ -2990,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, @@ -3035,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)), @@ -3053,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)), @@ -3071,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)), @@ -3088,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)), @@ -3106,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)), @@ -3214,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, @@ -3231,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, @@ -3248,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, @@ -3265,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, @@ -3282,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, @@ -3299,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, @@ -3330,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, @@ -3346,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, @@ -3362,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, @@ -3377,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, }, @@ -3391,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, }, @@ -3405,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, }, @@ -3419,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, }, @@ -3465,14 +5900,131 @@ static const struct token token_list[] = { .call = parse_vc_action_raw_decap_index, .comp = comp_set_raw_index, }, + [ACTION_MODIFY_FIELD] = { + .name = "modify_field", + .help = "modify destination field with data from source field", + .priv = PRIV_ACTION(MODIFY_FIELD, ACTION_MODIFY_SIZE), + .next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_OP)), + .call = parse_vc, + }, + [ACTION_MODIFY_FIELD_OP] = { + .name = "op", + .help = "operation type", + .next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_DST_TYPE), + NEXT_ENTRY(ACTION_MODIFY_FIELD_OP_VALUE)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_OP_VALUE] = { + .name = "{operation}", + .help = "operation type value", + .call = parse_vc_modify_field_op, + .comp = comp_set_modify_field_op, + }, + [ACTION_MODIFY_FIELD_DST_TYPE] = { + .name = "dst_type", + .help = "destination field type", + .next = NEXT(action_modify_field_dst, + NEXT_ENTRY(ACTION_MODIFY_FIELD_DST_TYPE_VALUE)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_DST_TYPE_VALUE] = { + .name = "{dst_type}", + .help = "destination field type value", + .call = parse_vc_modify_field_id, + .comp = comp_set_modify_field_id, + }, + [ACTION_MODIFY_FIELD_DST_LEVEL] = { + .name = "dst_level", + .help = "destination field level", + .next = NEXT(action_modify_field_dst, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + dst.level)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_DST_OFFSET] = { + .name = "dst_offset", + .help = "destination field bit offset", + .next = NEXT(action_modify_field_dst, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + dst.offset)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_SRC_TYPE] = { + .name = "src_type", + .help = "source field type", + .next = NEXT(action_modify_field_src, + NEXT_ENTRY(ACTION_MODIFY_FIELD_SRC_TYPE_VALUE)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_SRC_TYPE_VALUE] = { + .name = "{src_type}", + .help = "source field type value", + .call = parse_vc_modify_field_id, + .comp = comp_set_modify_field_id, + }, + [ACTION_MODIFY_FIELD_SRC_LEVEL] = { + .name = "src_level", + .help = "source field level", + .next = NEXT(action_modify_field_src, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + src.level)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_SRC_OFFSET] = { + .name = "src_offset", + .help = "source field bit offset", + .next = NEXT(action_modify_field_src, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + src.offset)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_SRC_VALUE] = { + .name = "src_value", + .help = "source immediate value", + .next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_WIDTH), + NEXT_ENTRY(COMMON_HEX)), + .args = ARGS(ARGS_ENTRY_ARB(0, 0), + ARGS_ENTRY_ARB(0, 0), + ARGS_ENTRY(struct rte_flow_action_modify_field, + src.value)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_SRC_POINTER] = { + .name = "src_ptr", + .help = "pointer to source immediate value", + .next = NEXT(NEXT_ENTRY(ACTION_MODIFY_FIELD_WIDTH), + NEXT_ENTRY(COMMON_HEX)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + src.pvalue), + ARGS_ENTRY_ARB(0, 0), + ARGS_ENTRY_ARB + (sizeof(struct rte_flow_action_modify_field), + ACTION_MODIFY_PATTERN_SIZE)), + .call = parse_vc_conf, + }, + [ACTION_MODIFY_FIELD_WIDTH] = { + .name = "width", + .help = "number of bits to copy", + .next = NEXT(NEXT_ENTRY(ACTION_NEXT), + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_modify_field, + width)), + .call = parse_vc_conf, + }, /* Top level command. */ [SET] = { .name = "set", - .help = "set raw encap/decap data", - .type = "set raw_encap|raw_decap ", + .help = "set raw encap/decap/sample data", + .type = "set raw_encap|raw_decap " + " or set sample_actions ", .next = NEXT(NEXT_ENTRY (SET_RAW_ENCAP, - SET_RAW_DECAP)), + SET_RAW_DECAP, + SET_SAMPLE_ACTIONS)), .call = parse_set_init, }, /* Sub-level commands. */ @@ -3498,11 +6050,28 @@ 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, }, + [SET_SAMPLE_INDEX] = { + .name = "{index}", + .type = "UNSIGNED", + .help = "index of sample actions", + .next = NEXT(next_action_sample), + .call = parse_port, + }, + [SET_SAMPLE_ACTIONS] = { + .name = "sample_actions", + .help = "set sample actions list", + .next = NEXT(NEXT_ENTRY(SET_SAMPLE_INDEX)), + .args = ARGS(ARGS_ENTRY_ARB_BOUNDED + (offsetof(struct buffer, port), + sizeof(((struct buffer *)0)->port), + 0, RAW_SAMPLE_CONFS_MAX_NUM - 1)), + .call = parse_set_sample_action, + }, [ACTION_SET_TAG] = { .name = "set_tag", .help = "set tag", @@ -3514,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, @@ -3529,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, @@ -3545,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, @@ -3553,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, @@ -3569,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, @@ -3585,11 +6154,225 @@ 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, }, + [ACTION_AGE] = { + .name = "age", + .help = "set a specific metadata header", + .next = NEXT(action_age), + .priv = PRIV_ACTION(AGE, + sizeof(struct rte_flow_action_age)), + .call = parse_vc, + }, + [ACTION_AGE_TIMEOUT] = { + .name = "timeout", + .help = "flow age timeout value", + .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_age, + timeout, 24)), + .next = NEXT(action_age, NEXT_ENTRY(COMMON_UNSIGNED)), + .call = parse_vc_conf, + }, + [ACTION_SAMPLE] = { + .name = "sample", + .help = "set a sample action", + .next = NEXT(action_sample), + .priv = PRIV_ACTION(SAMPLE, + sizeof(struct action_sample_data)), + .call = parse_vc_action_sample, + }, + [ACTION_SAMPLE_RATIO] = { + .name = "ratio", + .help = "flow sample ratio value", + .next = NEXT(action_sample, NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY_ARB + (offsetof(struct action_sample_data, conf) + + offsetof(struct rte_flow_action_sample, ratio), + sizeof(((struct rte_flow_action_sample *)0)-> + ratio))), + }, + [ACTION_SAMPLE_INDEX] = { + .name = "index", + .help = "the index of sample actions list", + .next = NEXT(NEXT_ENTRY(ACTION_SAMPLE_INDEX_VALUE)), + }, + [ACTION_SAMPLE_INDEX_VALUE] = { + .name = "{index}", + .type = "COMMON_UNSIGNED", + .help = "unsigned integer value", + .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + .call = parse_vc_action_sample_index, + .comp = comp_set_sample_index, + }, + [ACTION_CONNTRACK] = { + .name = "conntrack", + .help = "create a conntrack object", + .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + .priv = PRIV_ACTION(CONNTRACK, + sizeof(struct rte_flow_action_conntrack)), + .call = parse_vc, + }, + [ACTION_CONNTRACK_UPDATE] = { + .name = "conntrack_update", + .help = "update a conntrack object", + .next = NEXT(action_update_conntrack), + .priv = PRIV_ACTION(CONNTRACK, + sizeof(struct rte_flow_modify_conntrack)), + .call = parse_vc, + }, + [ACTION_CONNTRACK_UPDATE_DIR] = { + .name = "dir", + .help = "update a conntrack object direction", + .next = NEXT(action_update_conntrack), + .call = parse_vc_action_conntrack_update, + }, + [ACTION_CONNTRACK_UPDATE_CTX] = { + .name = "ctx", + .help = "update a conntrack object context", + .next = NEXT(action_update_conntrack), + .call = parse_vc_action_conntrack_update, + }, + [ACTION_PORT_REPRESENTOR] = { + .name = "port_representor", + .help = "at embedded switch level, send matching traffic to the given ethdev", + .priv = PRIV_ACTION(PORT_REPRESENTOR, + sizeof(struct rte_flow_action_ethdev)), + .next = NEXT(action_port_representor), + .call = parse_vc, + }, + [ACTION_PORT_REPRESENTOR_PORT_ID] = { + .name = "port_id", + .help = "ethdev port ID", + .next = NEXT(action_port_representor, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev, + port_id)), + .call = parse_vc_conf, + }, + [ACTION_REPRESENTED_PORT] = { + .name = "represented_port", + .help = "at embedded switch level, send matching traffic to the entity represented by the given ethdev", + .priv = PRIV_ACTION(REPRESENTED_PORT, + sizeof(struct rte_flow_action_ethdev)), + .next = NEXT(action_represented_port), + .call = parse_vc, + }, + [ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID] = { + .name = "ethdev_port_id", + .help = "ethdev port ID", + .next = NEXT(action_represented_port, + NEXT_ENTRY(COMMON_UNSIGNED)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev, + port_id)), + .call = parse_vc_conf, + }, + /* Indirect action destroy arguments. */ + [INDIRECT_ACTION_DESTROY_ID] = { + .name = "action_id", + .help = "specify a indirect action id to destroy", + .next = NEXT(next_ia_destroy_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY_PTR(struct buffer, + args.ia_destroy.action_id)), + .call = parse_ia_destroy, + }, + /* Indirect action create arguments. */ + [INDIRECT_ACTION_CREATE_ID] = { + .name = "action_id", + .help = "specify a indirect action id to create", + .next = NEXT(next_ia_create_attr, + NEXT_ENTRY(COMMON_INDIRECT_ACTION_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.vc.attr.group)), + }, + [ACTION_INDIRECT] = { + .name = "indirect", + .help = "apply indirect action by id", + .priv = PRIV_ACTION(INDIRECT, 0), + .next = NEXT(NEXT_ENTRY(INDIRECT_ACTION_ID2PTR)), + .args = ARGS(ARGS_ENTRY_ARB(0, sizeof(uint32_t))), + .call = parse_vc, + }, + [INDIRECT_ACTION_ID2PTR] = { + .name = "{action_id}", + .type = "INDIRECT_ACTION_ID", + .help = "indirect action id", + .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + .call = parse_ia_id2ptr, + .comp = comp_none, + }, + [INDIRECT_ACTION_INGRESS] = { + .name = "ingress", + .help = "affect rule to ingress", + .next = NEXT(next_ia_create_attr), + .call = parse_ia, + }, + [INDIRECT_ACTION_EGRESS] = { + .name = "egress", + .help = "affect rule to egress", + .next = NEXT(next_ia_create_attr), + .call = parse_ia, + }, + [INDIRECT_ACTION_TRANSFER] = { + .name = "transfer", + .help = "affect rule to transfer", + .next = NEXT(next_ia_create_attr), + .call = parse_ia, + }, + [INDIRECT_ACTION_SPEC] = { + .name = "action", + .help = "specify action to create indirect handle", + .next = NEXT(next_action), + }, + [ACTION_POL_G] = { + .name = "g_actions", + .help = "submit a list of associated actions for green", + .next = NEXT(next_action), + .call = parse_mp, + }, + [ACTION_POL_Y] = { + .name = "y_actions", + .help = "submit a list of associated actions for yellow", + .next = NEXT(next_action), + }, + [ACTION_POL_R] = { + .name = "r_actions", + .help = "submit a list of associated actions for red", + .next = NEXT(next_action), + }, + + /* Top-level command. */ + [ADD] = { + .name = "add", + .type = "port meter policy {port_id} {arg}", + .help = "add port meter policy", + .next = NEXT(NEXT_ENTRY(ITEM_POL_PORT)), + .call = parse_init, + }, + /* Sub-level commands. */ + [ITEM_POL_PORT] = { + .name = "port", + .help = "add port meter policy", + .next = NEXT(NEXT_ENTRY(ITEM_POL_METER)), + }, + [ITEM_POL_METER] = { + .name = "meter", + .help = "add port meter policy", + .next = NEXT(NEXT_ENTRY(ITEM_POL_POLICY)), + }, + [ITEM_POL_POLICY] = { + .name = "policy", + .help = "add port meter policy", + .next = NEXT(NEXT_ENTRY(ACTION_POL_R), + NEXT_ENTRY(ACTION_POL_Y), + NEXT_ENTRY(ACTION_POL_G), + NEXT_ENTRY(COMMON_POLICY_ID), + NEXT_ENTRY(COMMON_PORT_ID)), + .args = ARGS(ARGS_ENTRY(struct buffer, args.policy.policy_id), + ARGS_ENTRY(struct buffer, port)), + .call = parse_mp, + }, }; /** Remove and return last entry from argument stack. */ @@ -3774,9 +6557,248 @@ parse_init(struct context *ctx, const struct token *token, return len; } -/** Parse tokens for validate/create commands. */ +/** Parse tokens for indirect action commands. */ static int -parse_vc(struct context *ctx, const struct token *token, +parse_ia(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != INDIRECT_ACTION) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case INDIRECT_ACTION_CREATE: + case INDIRECT_ACTION_UPDATE: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + out->args.vc.attr.group = UINT32_MAX; + /* fallthrough */ + case INDIRECT_ACTION_QUERY: + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case INDIRECT_ACTION_EGRESS: + out->args.vc.attr.egress = 1; + return len; + case INDIRECT_ACTION_INGRESS: + out->args.vc.attr.ingress = 1; + return len; + case INDIRECT_ACTION_TRANSFER: + out->args.vc.attr.transfer = 1; + return len; + default: + return -1; + } +} + + +/** Parse tokens for indirect action destroy command. */ +static int +parse_ia_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *action_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command || out->command == INDIRECT_ACTION) { + if (ctx->curr != INDIRECT_ACTION_DESTROY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.ia_destroy.action_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + action_id = out->args.ia_destroy.action_id + + out->args.ia_destroy.action_id_n++; + if ((uint8_t *)action_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = action_id; + ctx->objmask = NULL; + return len; +} + +/** Parse tokens for indirect action commands. */ +static int +parse_qia(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != QUEUE) + return -1; + if (sizeof(*out) > size) + return -1; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case QUEUE_INDIRECT_ACTION: + return len; + case QUEUE_INDIRECT_ACTION_CREATE: + case QUEUE_INDIRECT_ACTION_UPDATE: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + out->args.vc.attr.group = UINT32_MAX; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case QUEUE_INDIRECT_ACTION_EGRESS: + out->args.vc.attr.egress = 1; + return len; + case QUEUE_INDIRECT_ACTION_INGRESS: + out->args.vc.attr.ingress = 1; + return len; + case QUEUE_INDIRECT_ACTION_TRANSFER: + out->args.vc.attr.transfer = 1; + return len; + case QUEUE_INDIRECT_ACTION_CREATE_POSTPONE: + return len; + default: + return -1; + } +} + +/** Parse tokens for indirect action destroy command. */ +static int +parse_qia_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *action_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command || out->command == QUEUE) { + if (ctx->curr != QUEUE_INDIRECT_ACTION_DESTROY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.ia_destroy.action_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + switch (ctx->curr) { + case QUEUE_INDIRECT_ACTION: + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case QUEUE_INDIRECT_ACTION_DESTROY_ID: + action_id = out->args.ia_destroy.action_id + + out->args.ia_destroy.action_id_n++; + if ((uint8_t *)action_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = action_id; + ctx->objmask = NULL; + return len; + case QUEUE_INDIRECT_ACTION_DESTROY_POSTPONE: + return len; + default: + return -1; + } +} + +/** Parse tokens for meter policy action commands. */ +static int +parse_mp(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != ITEM_POL_POLICY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case ACTION_POL_G: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + default: + return -1; + } +} + +/** Parse tokens for validate/create commands. */ +static int +parse_vc(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size) { @@ -3791,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; @@ -3803,28 +6827,52 @@ parse_vc(struct context *ctx, const struct token *token, return len; } ctx->objdata = 0; - ctx->object = &out->args.vc.attr; + switch (ctx->curr) { + default: + ctx->object = &out->args.vc.attr; + break; + case VC_TUNNEL_SET: + case VC_TUNNEL_MATCH: + ctx->object = &out->args.vc.tunnel_ops; + break; + } ctx->objmask = NULL; switch (ctx->curr) { - case GROUP: - case PRIORITY: + case VC_GROUP: + case VC_PRIORITY: + return len; + case VC_TUNNEL_SET: + out->args.vc.tunnel_ops.enabled = 1; + out->args.vc.tunnel_ops.actions = 1; + return len; + case VC_TUNNEL_MATCH: + out->args.vc.tunnel_ops.enabled = 1; + out->args.vc.tunnel_ops.items = 1; return len; - case 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) @@ -3899,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; @@ -3964,90 +7012,229 @@ parse_vc_conf(struct context *ctx, const struct token *token, return len; } -/** Parse RSS action. */ -static int -parse_vc_action_rss(struct context *ctx, const struct token *token, - const char *str, unsigned int len, - void *buf, unsigned int size) -{ - struct buffer *out = buf; - struct rte_flow_action *action; - struct action_rss_data *action_rss_data; - unsigned int i; - int ret; - - ret = parse_vc(ctx, token, str, len, buf, size); - if (ret < 0) - return ret; - /* Nothing else to do if there is no buffer. */ - if (!out) - return ret; - if (!out->args.vc.actions_n) - return -1; - action = &out->args.vc.actions[out->args.vc.actions_n - 1]; - /* Point to selected object. */ - ctx->object = out->args.vc.data; - ctx->objmask = NULL; - /* Set up default configuration. */ - action_rss_data = ctx->object; - *action_rss_data = (struct action_rss_data){ - .conf = (struct rte_flow_action_rss){ - .func = RTE_ETH_HASH_FUNCTION_DEFAULT, - .level = 0, - .types = rss_hf, - .key_len = sizeof(action_rss_data->key), - .queue_num = RTE_MIN(nb_rxq, ACTION_RSS_QUEUE_NUM), - .key = action_rss_data->key, - .queue = action_rss_data->queue, - }, - .key = "testpmd's default RSS hash key, " - "override it for better balancing", - .queue = { 0 }, - }; - for (i = 0; i < action_rss_data->conf.queue_num; ++i) - action_rss_data->queue[i] = i; - if (!port_id_is_invalid(ctx->port, DISABLED_WARN) && - ctx->port != (portid_t)RTE_PORT_ALL) { - struct rte_eth_dev_info info; - int ret2; - - ret2 = rte_eth_dev_info_get(ctx->port, &info); - if (ret2 != 0) - return ret2; - - action_rss_data->conf.key_len = - RTE_MIN(sizeof(action_rss_data->key), - info.hash_key_size); - } - action->conf = &action_rss_data->conf; - return ret; -} - -/** - * Parse func field for RSS action. - * - * The RTE_ETH_HASH_FUNCTION_* value to assign is derived from the - * ACTION_RSS_FUNC_* index that called this function. - */ +/** Parse eCPRI common header type field. */ static int -parse_vc_action_rss_func(struct context *ctx, const struct token *token, +parse_vc_item_ecpri_type(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size) { - struct action_rss_data *action_rss_data; - enum rte_eth_hash_function func; + struct rte_flow_item_ecpri *ecpri; + struct rte_flow_item_ecpri *ecpri_mask; + struct rte_flow_item *item; + uint32_t data_size; + uint8_t msg_type; + struct buffer *out = buf; + const struct arg *arg; - (void)buf; (void)size; /* Token name must match. */ if (parse_default(ctx, token, str, len, NULL, 0) < 0) return -1; switch (ctx->curr) { - case ACTION_RSS_FUNC_DEFAULT: - func = RTE_ETH_HASH_FUNCTION_DEFAULT; + case ITEM_ECPRI_COMMON_TYPE_IQ_DATA: + msg_type = RTE_ECPRI_MSG_TYPE_IQ_DATA; break; - case ACTION_RSS_FUNC_TOEPLITZ: - func = RTE_ETH_HASH_FUNCTION_TOEPLITZ; + case ITEM_ECPRI_COMMON_TYPE_RTC_CTRL: + msg_type = RTE_ECPRI_MSG_TYPE_RTC_CTRL; + break; + case ITEM_ECPRI_COMMON_TYPE_DLY_MSR: + msg_type = RTE_ECPRI_MSG_TYPE_DLY_MSR; + break; + default: + return -1; + } + if (!ctx->object) + return len; + arg = pop_args(ctx); + if (!arg) + return -1; + ecpri = (struct rte_flow_item_ecpri *)out->args.vc.data; + ecpri->hdr.common.type = msg_type; + data_size = ctx->objdata / 3; /* spec, last, mask */ + ecpri_mask = (struct rte_flow_item_ecpri *)(out->args.vc.data + + (data_size * 2)); + ecpri_mask->hdr.common.type = 0xFF; + if (arg->hton) { + ecpri->hdr.common.u32 = rte_cpu_to_be_32(ecpri->hdr.common.u32); + ecpri_mask->hdr.common.u32 = + rte_cpu_to_be_32(ecpri_mask->hdr.common.u32); + } + item = &out->args.vc.pattern[out->args.vc.pattern_n - 1]; + item->spec = ecpri; + item->mask = ecpri_mask; + return len; +} + +/** Parse L2TPv2 common header type field. */ +static int +parse_vc_item_l2tpv2_type(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct rte_flow_item_l2tpv2 *l2tpv2; + struct rte_flow_item_l2tpv2 *l2tpv2_mask; + struct rte_flow_item *item; + uint32_t data_size; + uint16_t msg_type = 0; + struct buffer *out = buf; + const struct arg *arg; + + (void)size; + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + switch (ctx->curr) { + case ITEM_L2TPV2_TYPE_DATA: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA; + break; + case ITEM_L2TPV2_TYPE_DATA_L: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_L; + break; + case ITEM_L2TPV2_TYPE_DATA_S: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_S; + break; + case ITEM_L2TPV2_TYPE_DATA_O: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_O; + break; + case ITEM_L2TPV2_TYPE_DATA_L_S: + msg_type |= RTE_L2TPV2_MSG_TYPE_DATA_L_S; + break; + case ITEM_L2TPV2_TYPE_CTRL: + msg_type |= RTE_L2TPV2_MSG_TYPE_CONTROL; + break; + default: + return -1; + } + if (!ctx->object) + return len; + arg = pop_args(ctx); + if (!arg) + return -1; + l2tpv2 = (struct rte_flow_item_l2tpv2 *)out->args.vc.data; + l2tpv2->hdr.common.flags_version |= msg_type; + data_size = ctx->objdata / 3; /* spec, last, mask */ + l2tpv2_mask = (struct rte_flow_item_l2tpv2 *)(out->args.vc.data + + (data_size * 2)); + l2tpv2_mask->hdr.common.flags_version = 0xFFFF; + if (arg->hton) { + l2tpv2->hdr.common.flags_version = + rte_cpu_to_be_16(l2tpv2->hdr.common.flags_version); + l2tpv2_mask->hdr.common.flags_version = + rte_cpu_to_be_16(l2tpv2_mask->hdr.common.flags_version); + } + item = &out->args.vc.pattern[out->args.vc.pattern_n - 1]; + item->spec = l2tpv2; + item->mask = l2tpv2_mask; + return len; +} + +/** Parse meter color action type. */ +static int +parse_vc_action_meter_color_type(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct rte_flow_action *action_data; + struct rte_flow_action_meter_color *conf; + enum rte_color color; + + (void)buf; + (void)size; + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + switch (ctx->curr) { + case ACTION_METER_COLOR_GREEN: + color = RTE_COLOR_GREEN; + break; + case ACTION_METER_COLOR_YELLOW: + color = RTE_COLOR_YELLOW; + break; + case ACTION_METER_COLOR_RED: + color = RTE_COLOR_RED; + break; + default: + return -1; + } + + if (!ctx->object) + return len; + action_data = ctx->object; + conf = (struct rte_flow_action_meter_color *) + (uintptr_t)(action_data->conf); + conf->color = color; + return len; +} + +/** Parse RSS action. */ +static int +parse_vc_action_rss(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + struct rte_flow_action *action; + struct action_rss_data *action_rss_data; + unsigned int i; + int ret; + + ret = parse_vc(ctx, token, str, len, buf, size); + if (ret < 0) + return ret; + /* Nothing else to do if there is no buffer. */ + if (!out) + return ret; + if (!out->args.vc.actions_n) + return -1; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + /* Point to selected object. */ + ctx->object = out->args.vc.data; + ctx->objmask = NULL; + /* Set up default configuration. */ + action_rss_data = ctx->object; + *action_rss_data = (struct action_rss_data){ + .conf = (struct rte_flow_action_rss){ + .func = RTE_ETH_HASH_FUNCTION_DEFAULT, + .level = 0, + .types = rss_hf, + .key_len = 0, + .queue_num = RTE_MIN(nb_rxq, ACTION_RSS_QUEUE_NUM), + .key = NULL, + .queue = action_rss_data->queue, + }, + .queue = { 0 }, + }; + for (i = 0; i < action_rss_data->conf.queue_num; ++i) + action_rss_data->queue[i] = i; + action->conf = &action_rss_data->conf; + return ret; +} + +/** + * Parse func field for RSS action. + * + * The RTE_ETH_HASH_FUNCTION_* value to assign is derived from the + * ACTION_RSS_FUNC_* index that called this function. + */ +static int +parse_vc_action_rss_func(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct action_rss_data *action_rss_data; + enum rte_eth_hash_function func; + + (void)buf; + (void)size; + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + switch (ctx->curr) { + case ACTION_RSS_FUNC_DEFAULT: + func = RTE_ETH_HASH_FUNCTION_DEFAULT; + break; + case ACTION_RSS_FUNC_TOEPLITZ: + func = RTE_ETH_HASH_FUNCTION_TOEPLITZ; break; case ACTION_RSS_FUNC_SIMPLE_XOR: func = RTE_ETH_HASH_FUNCTION_SIMPLE_XOR; @@ -4162,31 +7349,11 @@ end: return len; } -/** Parse VXLAN encap action. */ +/** Setup VXLAN encap configuration. */ static int -parse_vc_action_vxlan_encap(struct context *ctx, const struct token *token, - const char *str, unsigned int len, - void *buf, unsigned int size) +parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_data) { - struct buffer *out = buf; - struct rte_flow_action *action; - struct action_vxlan_encap_data *action_vxlan_encap_data; - int ret; - - ret = parse_vc(ctx, token, str, len, buf, size); - if (ret < 0) - return ret; - /* Nothing else to do if there is no buffer. */ - if (!out) - return ret; - if (!out->args.vc.actions_n) - return -1; - action = &out->args.vc.actions[out->args.vc.actions_n - 1]; - /* Point to selected object. */ - ctx->object = out->args.vc.data; - ctx->objmask = NULL; /* Set up default configuration. */ - action_vxlan_encap_data = ctx->object; *action_vxlan_encap_data = (struct action_vxlan_encap_data){ .conf = (struct rte_flow_action_vxlan_encap){ .definition = action_vxlan_encap_data->items, @@ -4290,19 +7457,18 @@ parse_vc_action_vxlan_encap(struct context *ctx, const struct token *token, } memcpy(action_vxlan_encap_data->item_vxlan.vni, vxlan_encap_conf.vni, RTE_DIM(vxlan_encap_conf.vni)); - action->conf = &action_vxlan_encap_data->conf; - return ret; + return 0; } -/** Parse NVGRE encap action. */ +/** Parse VXLAN encap action. */ static int -parse_vc_action_nvgre_encap(struct context *ctx, const struct token *token, +parse_vc_action_vxlan_encap(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size) { struct buffer *out = buf; struct rte_flow_action *action; - struct action_nvgre_encap_data *action_nvgre_encap_data; + struct action_vxlan_encap_data *action_vxlan_encap_data; int ret; ret = parse_vc(ctx, token, str, len, buf, size); @@ -4317,8 +7483,17 @@ parse_vc_action_nvgre_encap(struct context *ctx, const struct token *token, /* Point to selected object. */ ctx->object = out->args.vc.data; ctx->objmask = NULL; + action_vxlan_encap_data = ctx->object; + parse_setup_vxlan_encap_data(action_vxlan_encap_data); + action->conf = &action_vxlan_encap_data->conf; + return ret; +} + +/** Setup NVGRE encap configuration. */ +static int +parse_setup_nvgre_encap_data(struct action_nvgre_encap_data *action_nvgre_encap_data) +{ /* Set up default configuration. */ - action_nvgre_encap_data = ctx->object; *action_nvgre_encap_data = (struct action_nvgre_encap_data){ .conf = (struct rte_flow_action_nvgre_encap){ .definition = action_nvgre_encap_data->items, @@ -4357,6 +7532,8 @@ parse_vc_action_nvgre_encap(struct context *ctx, const struct token *token, .src_addr = nvgre_encap_conf.ipv4_src, .dst_addr = nvgre_encap_conf.ipv4_dst, }, + .item_nvgre.c_k_s_rsvd0_ver = RTE_BE16(0x2000), + .item_nvgre.protocol = RTE_BE16(RTE_ETHER_TYPE_TEB), .item_nvgre.flow_id = 0, }; memcpy(action_nvgre_encap_data->item_eth.dst.addr_bytes, @@ -4381,6 +7558,34 @@ parse_vc_action_nvgre_encap(struct context *ctx, const struct token *token, RTE_FLOW_ITEM_TYPE_VOID; memcpy(action_nvgre_encap_data->item_nvgre.tni, nvgre_encap_conf.tni, RTE_DIM(nvgre_encap_conf.tni)); + return 0; +} + +/** Parse NVGRE encap action. */ +static int +parse_vc_action_nvgre_encap(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + struct rte_flow_action *action; + struct action_nvgre_encap_data *action_nvgre_encap_data; + int ret; + + ret = parse_vc(ctx, token, str, len, buf, size); + if (ret < 0) + return ret; + /* Nothing else to do if there is no buffer. */ + if (!out) + return ret; + if (!out->args.vc.actions_n) + return -1; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + /* Point to selected object. */ + ctx->object = out->args.vc.data; + ctx->objmask = NULL; + action_nvgre_encap_data = ctx->object; + parse_setup_nvgre_encap_data(action_nvgre_encap_data); action->conf = &action_nvgre_encap_data->conf; return ret; } @@ -4535,7 +7740,9 @@ parse_vc_action_mplsogre_encap(struct context *ctx, const struct token *token, struct rte_flow_item_gre gre = { .protocol = rte_cpu_to_be_16(ETHER_TYPE_MPLS_UNICAST), }; - struct rte_flow_item_mpls mpls; + struct rte_flow_item_mpls mpls = { + .ttl = 0, + }; uint8_t *header; int ret; @@ -4986,72 +8193,818 @@ parse_vc_action_raw_encap(struct context *ctx, const struct token *token, return ret; if (!out->args.vc.actions_n) return -1; - action = &out->args.vc.actions[out->args.vc.actions_n - 1]; - /* Point to selected object. */ - ctx->object = out->args.vc.data; - ctx->objmask = NULL; - /* Copy the headers to the buffer. */ - action_raw_encap_data = ctx->object; - action_raw_encap_data->conf.data = raw_encap_confs[0].data; - action_raw_encap_data->conf.preserve = NULL; - action_raw_encap_data->conf.size = raw_encap_confs[0].size; - action->conf = &action_raw_encap_data->conf; - return ret; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + /* Point to selected object. */ + ctx->object = out->args.vc.data; + ctx->objmask = NULL; + /* Copy the headers to the buffer. */ + action_raw_encap_data = ctx->object; + action_raw_encap_data->conf.data = raw_encap_confs[0].data; + action_raw_encap_data->conf.preserve = NULL; + action_raw_encap_data->conf.size = raw_encap_confs[0].size; + action->conf = &action_raw_encap_data->conf; + return ret; +} + +static int +parse_vc_action_raw_decap(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct buffer *out = buf; + struct rte_flow_action *action; + struct action_raw_decap_data *action_raw_decap_data = NULL; + int ret; + + ret = parse_vc(ctx, token, str, len, buf, size); + if (ret < 0) + return ret; + /* Nothing else to do if there is no buffer. */ + if (!out) + return ret; + if (!out->args.vc.actions_n) + return -1; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + /* Point to selected object. */ + ctx->object = out->args.vc.data; + ctx->objmask = NULL; + /* Copy the headers to the buffer. */ + action_raw_decap_data = ctx->object; + action_raw_decap_data->conf.data = raw_decap_confs[0].data; + action_raw_decap_data->conf.size = raw_decap_confs[0].size; + action->conf = &action_raw_decap_data->conf; + return ret; +} + +static int +parse_vc_action_set_meta(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + int ret; + + ret = parse_vc(ctx, token, str, len, buf, size); + if (ret < 0) + return ret; + ret = rte_flow_dynf_metadata_register(); + if (ret < 0) + return -1; + return len; +} + +static int +parse_vc_action_sample(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct buffer *out = buf; + struct rte_flow_action *action; + struct action_sample_data *action_sample_data = NULL; + static struct rte_flow_action end_action = { + RTE_FLOW_ACTION_TYPE_END, 0 + }; + int ret; + + ret = parse_vc(ctx, token, str, len, buf, size); + if (ret < 0) + return ret; + /* Nothing else to do if there is no buffer. */ + if (!out) + return ret; + if (!out->args.vc.actions_n) + return -1; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + /* Point to selected object. */ + ctx->object = out->args.vc.data; + ctx->objmask = NULL; + /* Copy the headers to the buffer. */ + action_sample_data = ctx->object; + action_sample_data->conf.actions = &end_action; + action->conf = &action_sample_data->conf; + return ret; +} + +static int +parse_vc_action_sample_index(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct action_sample_data *action_sample_data; + struct rte_flow_action *action; + const struct arg *arg; + struct buffer *out = buf; + int ret; + uint16_t idx; + + RTE_SET_USED(token); + RTE_SET_USED(buf); + RTE_SET_USED(size); + if (ctx->curr != ACTION_SAMPLE_INDEX_VALUE) + return -1; + arg = ARGS_ENTRY_ARB_BOUNDED + (offsetof(struct action_sample_data, idx), + sizeof(((struct action_sample_data *)0)->idx), + 0, RAW_SAMPLE_CONFS_MAX_NUM - 1); + if (push_args(ctx, arg)) + return -1; + ret = parse_int(ctx, token, str, len, NULL, 0); + if (ret < 0) { + pop_args(ctx); + return -1; + } + if (!ctx->object) + return len; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + action_sample_data = ctx->object; + idx = action_sample_data->idx; + action_sample_data->conf.actions = raw_sample_confs[idx].data; + action->conf = &action_sample_data->conf; + return len; +} + +/** Parse operation for modify_field command. */ +static int +parse_vc_modify_field_op(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct rte_flow_action_modify_field *action_modify_field; + unsigned int i; + + (void)token; + (void)buf; + (void)size; + if (ctx->curr != ACTION_MODIFY_FIELD_OP_VALUE) + return -1; + for (i = 0; modify_field_ops[i]; ++i) + if (!strcmp_partial(modify_field_ops[i], str, len)) + break; + if (!modify_field_ops[i]) + return -1; + if (!ctx->object) + return len; + action_modify_field = ctx->object; + action_modify_field->operation = (enum rte_flow_modify_op)i; + return len; +} + +/** Parse id for modify_field command. */ +static int +parse_vc_modify_field_id(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct rte_flow_action_modify_field *action_modify_field; + unsigned int i; + + (void)token; + (void)buf; + (void)size; + if (ctx->curr != ACTION_MODIFY_FIELD_DST_TYPE_VALUE && + ctx->curr != ACTION_MODIFY_FIELD_SRC_TYPE_VALUE) + return -1; + for (i = 0; modify_field_ids[i]; ++i) + if (!strcmp_partial(modify_field_ids[i], str, len)) + break; + if (!modify_field_ids[i]) + return -1; + if (!ctx->object) + return len; + action_modify_field = ctx->object; + if (ctx->curr == ACTION_MODIFY_FIELD_DST_TYPE_VALUE) + action_modify_field->dst.field = (enum rte_flow_field_id)i; + else + action_modify_field->src.field = (enum rte_flow_field_id)i; + return len; +} + +/** Parse the conntrack update, not a rte_flow_action. */ +static int +parse_vc_action_conntrack_update(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct buffer *out = buf; + struct rte_flow_modify_conntrack *ct_modify = NULL; + + (void)size; + if (ctx->curr != ACTION_CONNTRACK_UPDATE_CTX && + ctx->curr != ACTION_CONNTRACK_UPDATE_DIR) + return -1; + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + ct_modify = (struct rte_flow_modify_conntrack *)out->args.vc.data; + if (ctx->curr == ACTION_CONNTRACK_UPDATE_DIR) { + ct_modify->new_ct.is_original_dir = + conntrack_context.is_original_dir; + ct_modify->direction = 1; + } else { + uint32_t old_dir; + + old_dir = ct_modify->new_ct.is_original_dir; + memcpy(&ct_modify->new_ct, &conntrack_context, + sizeof(conntrack_context)); + ct_modify->new_ct.is_original_dir = old_dir; + ct_modify->state = 1; + } + return len; +} + +/** Parse tokens for destroy command. */ +static int +parse_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != DESTROY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.destroy.rule = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + if (((uint8_t *)(out->args.destroy.rule + out->args.destroy.rule_n) + + sizeof(*out->args.destroy.rule)) > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = out->args.destroy.rule + out->args.destroy.rule_n++; + ctx->objmask = NULL; + return len; +} + +/** Parse tokens for flush command. */ +static int +parse_flush(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != FLUSH) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + return len; +} + +/** Parse tokens for dump command. */ +static int +parse_dump(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != DUMP) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + } + switch (ctx->curr) { + case DUMP_ALL: + case DUMP_ONE: + out->args.dump.mode = (ctx->curr == DUMP_ALL) ? true : false; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + default: + return -1; + } +} + +/** Parse tokens for query command. */ +static int +parse_query(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != QUERY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + return len; +} + +/** Parse action names. */ +static int +parse_action(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + const struct arg *arg = pop_args(ctx); + unsigned int i; + + (void)size; + /* Argument is expected. */ + if (!arg) + return -1; + /* Parse action name. */ + for (i = 0; next_action[i]; ++i) { + const struct parse_action_priv *priv; + + token = &token_list[next_action[i]]; + if (strcmp_partial(token->name, str, len)) + continue; + priv = token->priv; + if (!priv) + goto error; + if (out) + memcpy((uint8_t *)ctx->object + arg->offset, + &priv->type, + arg->size); + return len; + } +error: + push_args(ctx, arg); + return -1; +} + +/** Parse tokens for list command. */ +static int +parse_list(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != LIST) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.list.group = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + if (((uint8_t *)(out->args.list.group + out->args.list.group_n) + + sizeof(*out->args.list.group)) > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = out->args.list.group + out->args.list.group_n++; + ctx->objmask = NULL; + return len; +} + +/** Parse tokens for list all aged flows command. */ +static int +parse_aged(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != AGED) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + if (ctx->curr == AGED_DESTROY) + out->args.aged.destroy = 1; + return len; +} + +/** Parse tokens for isolate command. */ +static int +parse_isolate(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != ISOLATE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + return len; +} + +/** Parse tokens for info/configure command. */ +static int +parse_configure(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != INFO && ctx->curr != CONFIGURE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + } + return len; +} + +/** Parse tokens for template create command. */ +static int +parse_template(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != PATTERN_TEMPLATE && + ctx->curr != ACTIONS_TEMPLATE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; + return len; + } + switch (ctx->curr) { + case PATTERN_TEMPLATE_CREATE: + out->args.vc.pattern = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + out->args.vc.pat_templ_id = UINT32_MAX; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case PATTERN_TEMPLATE_EGRESS: + out->args.vc.attr.egress = 1; + return len; + case PATTERN_TEMPLATE_INGRESS: + out->args.vc.attr.ingress = 1; + return len; + case PATTERN_TEMPLATE_TRANSFER: + out->args.vc.attr.transfer = 1; + return len; + case ACTIONS_TEMPLATE_CREATE: + out->args.vc.act_templ_id = UINT32_MAX; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + case ACTIONS_TEMPLATE_SPEC: + out->args.vc.actions = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + ctx->object = out->args.vc.actions; + ctx->objmask = NULL; + return len; + case ACTIONS_TEMPLATE_MASK: + out->args.vc.masks = + (void *)RTE_ALIGN_CEIL((uintptr_t) + (out->args.vc.actions + + out->args.vc.actions_n), + sizeof(double)); + ctx->object = out->args.vc.masks; + ctx->objmask = NULL; + return len; + case ACTIONS_TEMPLATE_EGRESS: + out->args.vc.attr.egress = 1; + return len; + case ACTIONS_TEMPLATE_INGRESS: + out->args.vc.attr.ingress = 1; + return len; + case ACTIONS_TEMPLATE_TRANSFER: + out->args.vc.attr.transfer = 1; + return len; + default: + return -1; + } +} + +/** Parse tokens for template destroy command. */ +static int +parse_template_destroy(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *template_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command || + out->command == PATTERN_TEMPLATE || + out->command == ACTIONS_TEMPLATE) { + if (ctx->curr != PATTERN_TEMPLATE_DESTROY && + ctx->curr != ACTIONS_TEMPLATE_DESTROY) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.templ_destroy.template_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; + } + template_id = out->args.templ_destroy.template_id + + out->args.templ_destroy.template_id_n++; + if ((uint8_t *)template_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = template_id; + ctx->objmask = NULL; + return len; +} + +/** Parse tokens for table create command. */ +static int +parse_table(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + uint32_t *template_id; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + if (!out->command) { + if (ctx->curr != TABLE) + return -1; + if (sizeof(*out) > size) + return -1; + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + return len; + } + switch (ctx->curr) { + case TABLE_CREATE: + out->command = ctx->curr; + ctx->objdata = 0; + ctx->object = out; + ctx->objmask = NULL; + out->args.table.id = UINT32_MAX; + return len; + case TABLE_PATTERN_TEMPLATE: + out->args.table.pat_templ_id = + (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + template_id = out->args.table.pat_templ_id + + out->args.table.pat_templ_id_n++; + if ((uint8_t *)template_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = template_id; + ctx->objmask = NULL; + return len; + case TABLE_ACTIONS_TEMPLATE: + out->args.table.act_templ_id = + (void *)RTE_ALIGN_CEIL((uintptr_t) + (out->args.table.pat_templ_id + + out->args.table.pat_templ_id_n), + sizeof(double)); + template_id = out->args.table.act_templ_id + + out->args.table.act_templ_id_n++; + if ((uint8_t *)template_id > (uint8_t *)out + size) + return -1; + ctx->objdata = 0; + ctx->object = template_id; + ctx->objmask = NULL; + return len; + case TABLE_INGRESS: + out->args.table.attr.flow_attr.ingress = 1; + return len; + case TABLE_EGRESS: + out->args.table.attr.flow_attr.egress = 1; + return len; + case TABLE_TRANSFER: + out->args.table.attr.flow_attr.transfer = 1; + return len; + default: + return -1; + } } +/** Parse tokens for table destroy command. */ static int -parse_vc_action_raw_decap(struct context *ctx, const struct token *token, - const char *str, unsigned int len, void *buf, - unsigned int size) +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; - struct rte_flow_action *action; - struct action_raw_decap_data *action_raw_decap_data = NULL; - int ret; + uint32_t *table_id; - ret = parse_vc(ctx, token, str, len, buf, size); - if (ret < 0) - return ret; + /* 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 ret; - if (!out->args.vc.actions_n) + 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; - action = &out->args.vc.actions[out->args.vc.actions_n - 1]; - /* Point to selected object. */ - ctx->object = out->args.vc.data; + ctx->objdata = 0; + ctx->object = table_id; ctx->objmask = NULL; - /* Copy the headers to the buffer. */ - action_raw_decap_data = ctx->object; - action_raw_decap_data->conf.data = raw_decap_confs[0].data; - action_raw_decap_data->conf.size = raw_decap_confs[0].size; - action->conf = &action_raw_decap_data->conf; - return ret; + return len; } +/** Parse tokens for queue create commands. */ static int -parse_vc_action_set_meta(struct context *ctx, const struct token *token, - const char *str, unsigned int len, void *buf, - unsigned int size) +parse_qo(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) { - int ret; + struct buffer *out = buf; - ret = parse_vc(ctx, token, str, len, buf, size); - if (ret < 0) - return ret; - ret = rte_flow_dynf_metadata_register(); - if (ret < 0) + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) return -1; - return len; + /* 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 destroy command. */ +/** Parse tokens for queue destroy command. */ static int -parse_destroy(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) @@ -5059,8 +9012,8 @@ parse_destroy(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 != DESTROY) + if (!out->command || out->command == QUEUE) { + if (ctx->curr != QUEUE_DESTROY) return -1; if (sizeof(*out) > size) return -1; @@ -5073,20 +9026,28 @@ parse_destroy(struct context *ctx, const struct token *token, sizeof(double)); return len; } - if (((uint8_t *)(out->args.destroy.rule + out->args.destroy.rule_n) + - sizeof(*out->args.destroy.rule)) > (uint8_t *)out + size) + 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; - ctx->objdata = 0; - ctx->object = out->args.destroy.rule + out->args.destroy.rule_n++; - ctx->objmask = NULL; - return len; + } } -/** Parse tokens for flush command. */ +/** Parse tokens for push queue command. */ static int -parse_flush(struct context *ctx, const struct token *token, - const char *str, unsigned int len, - void *buf, unsigned int size) +parse_push(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) { struct buffer *out = buf; @@ -5097,7 +9058,7 @@ parse_flush(struct context *ctx, const struct token *token, if (!out) return len; if (!out->command) { - if (ctx->curr != FLUSH) + if (ctx->curr != PUSH) return -1; if (sizeof(*out) > size) return -1; @@ -5105,15 +9066,16 @@ parse_flush(struct context *ctx, const struct token *token, ctx->objdata = 0; ctx->object = out; ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; } return len; } -/** Parse tokens for query command. */ +/** Parse tokens for pull command. */ static int -parse_query(struct context *ctx, const struct token *token, - const char *str, unsigned int len, - void *buf, unsigned int size) +parse_pull(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) { struct buffer *out = buf; @@ -5124,7 +9086,7 @@ parse_query(struct context *ctx, const struct token *token, if (!out) return len; if (!out->command) { - if (ctx->curr != QUERY) + if (ctx->curr != PULL) return -1; if (sizeof(*out) > size) return -1; @@ -5132,52 +9094,17 @@ parse_query(struct context *ctx, const struct token *token, ctx->objdata = 0; ctx->object = out; ctx->objmask = NULL; + out->args.vc.data = (uint8_t *)out + size; } return len; } -/** Parse action names. */ static int -parse_action(struct context *ctx, const struct token *token, +parse_flex(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) @@ -5185,8 +9112,8 @@ parse_list(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 != LIST) + if (out->command == ZERO) { + if (ctx->curr != FLEX) return -1; if (sizeof(*out) > size) return -1; @@ -5194,25 +9121,25 @@ 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; + } else { + switch (ctx->curr) { + default: + break; + case FLEX_ITEM_INIT: + case FLEX_ITEM_CREATE: + case FLEX_ITEM_DESTROY: + out->command = ctx->curr; + break; + } } - 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 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_tunnel(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) { struct buffer *out = buf; @@ -5223,7 +9150,7 @@ parse_isolate(struct context *ctx, const struct token *token, if (!out) return len; if (!out->command) { - if (ctx->curr != ISOLATE) + if (ctx->curr != TUNNEL) return -1; if (sizeof(*out) > size) return -1; @@ -5231,7 +9158,22 @@ 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 TUNNEL_CREATE: + case TUNNEL_DESTROY: + case TUNNEL_LIST: + out->command = ctx->curr; + break; + case TUNNEL_CREATE_TYPE: + case TUNNEL_DESTROY_ID: + ctx->object = &out->args.vc.tunnel_ops; + break; + } } + return len; } @@ -5394,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; } @@ -5462,19 +9405,25 @@ 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) goto error; - push_args(ctx, arg_len); - ret = parse_int(ctx, token, tmp, ret, NULL, 0); - if (ret < 0) { - pop_args(ctx); - goto error; + /* Save length if requested. */ + if (arg_len->size) { + push_args(ctx, arg_len); + ret = parse_int(ctx, token, tmp, ret, NULL, 0); + if (ret < 0) { + pop_args(ctx); + goto error; + } } buf = (uint8_t *)ctx->object + arg_data->offset; /* Output buffer is not necessarily NUL-terminated. */ @@ -5503,7 +9452,36 @@ error: push_args(ctx, arg_len); push_args(ctx, arg_data); return -1; - + +} + +/** + * Parse a zero-ended string. + */ +static int +parse_string0(struct context *ctx, const struct token *token __rte_unused, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + const struct arg *arg_data = pop_args(ctx); + + /* Arguments are expected. */ + if (!arg_data) + return -1; + size = arg_data->size; + /* Bit-mask fill is not supported. */ + if (arg_data->mask || size < len + 1) + goto error; + if (!ctx->object) + return len; + buf = (uint8_t *)ctx->object + arg_data->offset; + strncpy(buf, str, len); + if (ctx->objmask) + memset((uint8_t *)ctx->objmask + arg_data->offset, 0xff, len); + return len; +error: + push_args(ctx, arg_data); + return -1; } /** @@ -5701,6 +9679,32 @@ parse_port(struct context *ctx, const struct token *token, return ret; } +static int +parse_ia_id2ptr(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct rte_flow_action *action = ctx->object; + uint32_t id; + int ret; + + (void)buf; + (void)size; + ctx->objdata = 0; + ctx->object = &id; + ctx->objmask = NULL; + ret = parse_int(ctx, token, str, len, ctx->object, sizeof(id)); + ctx->object = action; + if (ret != (int)len) + return ret; + /* set indirect action */ + if (action) { + action->conf = port_action_handle_get_by_id(ctx->port, id); + ret = (action->conf) ? ret : -1; + } + return ret; +} + /** Parse set command, initialize output buffer for subsequent tokens. */ static int parse_set_raw_encap_decap(struct context *ctx, const struct token *token, @@ -5724,6 +9728,38 @@ parse_set_raw_encap_decap(struct context *ctx, const struct token *token, if (!out->command) return -1; out->command = ctx->curr; + /* For encap/decap we need is pattern */ + out->args.vc.pattern = (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); + return len; +} + +/** Parse set command, initialize output buffer for subsequent tokens. */ +static int +parse_set_sample_action(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct buffer *out = buf; + + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + /* Make sure buffer is large enough. */ + if (size < sizeof(*out)) + return -1; + ctx->objdata = 0; + ctx->objmask = NULL; + ctx->object = out; + if (!out->command) + return -1; + out->command = ctx->curr; + /* For sampler we need is actions */ + out->args.vc.actions = (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); return len; } @@ -5760,15 +9796,77 @@ parse_set_init(struct context *ctx, const struct token *token, return -1; out->command = ctx->curr; out->args.vc.data = (uint8_t *)out + size; - /* All we need is pattern */ - out->args.vc.pattern = - (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), - sizeof(double)); - ctx->object = out->args.vc.pattern; + ctx->object = (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1), + sizeof(double)); } return len; } +/* + * Replace testpmd handles in a flex flow item with real values. + */ +static int +parse_flex_handle(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct rte_flow_item_flex *spec, *mask; + const struct rte_flow_item_flex *src_spec, *src_mask; + const struct arg *arg = pop_args(ctx); + uint32_t offset; + uint16_t handle; + int ret; + + if (!arg) { + printf("Bad environment\n"); + return -1; + } + offset = arg->offset; + push_args(ctx, arg); + ret = parse_int(ctx, token, str, len, buf, size); + if (ret <= 0 || !ctx->object) + return ret; + if (ctx->port >= RTE_MAX_ETHPORTS) { + printf("Bad port\n"); + return -1; + } + if (offset == offsetof(struct rte_flow_item_flex, handle)) { + const struct flex_item *fp; + struct rte_flow_item_flex *item_flex = ctx->object; + handle = (uint16_t)(uintptr_t)item_flex->handle; + if (handle >= FLEX_MAX_PARSERS_NUM) { + printf("Bad flex item handle\n"); + return -1; + } + fp = flex_items[ctx->port][handle]; + if (!fp) { + printf("Bad flex item handle\n"); + return -1; + } + item_flex->handle = fp->flex_handle; + } else if (offset == offsetof(struct rte_flow_item_flex, pattern)) { + handle = (uint16_t)(uintptr_t) + ((struct rte_flow_item_flex *)ctx->object)->pattern; + if (handle >= FLEX_MAX_PATTERNS_NUM) { + printf("Bad pattern handle\n"); + return -1; + } + src_spec = &flex_patterns[handle].spec; + src_mask = &flex_patterns[handle].mask; + spec = ctx->object; + mask = spec + 2; /* spec, last, mask */ + /* fill flow rule spec and mask parameters */ + spec->length = src_spec->length; + spec->pattern = src_spec->pattern; + mask->length = src_mask->length; + mask->pattern = src_mask->pattern; + } else { + printf("Bad arguments - unknown flex item offset\n"); + return -1; + } + return ret; +} + /** No completion. */ static int comp_none(struct context *ctx, const struct token *token, @@ -5915,6 +10013,151 @@ comp_set_raw_index(struct context *ctx, const struct token *token, return nb; } +/** Complete index number for set raw_encap/raw_decap commands. */ +static int +comp_set_sample_index(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + uint16_t idx = 0; + uint16_t nb = 0; + + RTE_SET_USED(ctx); + RTE_SET_USED(token); + for (idx = 0; idx < RAW_SAMPLE_CONFS_MAX_NUM; ++idx) { + if (buf && idx == ent) + return snprintf(buf, size, "%u", idx); + ++nb; + } + return nb; +} + +/** Complete operation for modify_field command. */ +static int +comp_set_modify_field_op(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + RTE_SET_USED(ctx); + RTE_SET_USED(token); + if (!buf) + return RTE_DIM(modify_field_ops); + if (ent < RTE_DIM(modify_field_ops) - 1) + return strlcpy(buf, modify_field_ops[ent], size); + return -1; +} + +/** Complete field id for modify_field command. */ +static int +comp_set_modify_field_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + const char *name; + + RTE_SET_USED(token); + if (!buf) + return RTE_DIM(modify_field_ids); + if (ent >= RTE_DIM(modify_field_ids) - 1) + return -1; + name = modify_field_ids[ent]; + if (ctx->curr == ACTION_MODIFY_FIELD_SRC_TYPE || + (strcmp(name, "pointer") && strcmp(name, "value"))) + return strlcpy(buf, name, size); + return -1; +} + +/** Complete available pattern template IDs. */ +static int +comp_pattern_template_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + struct port_template *pt; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (pt = port->pattern_templ_list; pt != NULL; pt = pt->next) { + if (buf && i == ent) + return snprintf(buf, size, "%u", pt->id); + ++i; + } + if (buf) + return -1; + return i; +} + +/** Complete available actions template IDs. */ +static int +comp_actions_template_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + struct port_template *pt; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (pt = port->actions_templ_list; pt != NULL; pt = pt->next) { + if (buf && i == ent) + return snprintf(buf, size, "%u", pt->id); + ++i; + } + if (buf) + return -1; + return i; +} + +/** Complete available table IDs. */ +static int +comp_table_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + struct port_table *pt; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (pt = port->table_list; pt != NULL; pt = pt->next) { + if (buf && i == ent) + return snprintf(buf, size, "%u", pt->id); + ++i; + } + if (buf) + return -1; + return i; +} + +/** Complete available queue IDs. */ +static int +comp_queue_id(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + unsigned int i = 0; + struct rte_port *port; + + (void)token; + if (port_id_is_invalid(ctx->port, DISABLED_WARN) || + ctx->port == (portid_t)RTE_PORT_ALL) + return -1; + port = &ports[ctx->port]; + for (i = 0; i < port->queue_nb; i++) { + if (buf && i == ent) + return snprintf(buf, size, "%u", i); + } + if (buf) + return -1; + return i; +} + /** Internal context. */ static struct context cmd_flow_context; @@ -6016,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) @@ -6150,13 +10417,129 @@ static void cmd_flow_parsed(const struct buffer *in) { switch (in->command) { + case INFO: + port_flow_get_info(in->port); + break; + case CONFIGURE: + port_flow_configure(in->port, + &in->args.configure.port_attr, + in->args.configure.nb_queue, + &in->args.configure.queue_attr); + break; + case PATTERN_TEMPLATE_CREATE: + port_flow_pattern_template_create(in->port, + in->args.vc.pat_templ_id, + &((const struct rte_flow_pattern_template_attr) { + .relaxed_matching = in->args.vc.attr.reserved, + .ingress = in->args.vc.attr.ingress, + .egress = in->args.vc.attr.egress, + .transfer = in->args.vc.attr.transfer, + }), + in->args.vc.pattern); + break; + case PATTERN_TEMPLATE_DESTROY: + port_flow_pattern_template_destroy(in->port, + in->args.templ_destroy.template_id_n, + in->args.templ_destroy.template_id); + break; + case ACTIONS_TEMPLATE_CREATE: + port_flow_actions_template_create(in->port, + in->args.vc.act_templ_id, + &((const struct rte_flow_actions_template_attr) { + .ingress = in->args.vc.attr.ingress, + .egress = in->args.vc.attr.egress, + .transfer = in->args.vc.attr.transfer, + }), + in->args.vc.actions, + in->args.vc.masks); + break; + case ACTIONS_TEMPLATE_DESTROY: + port_flow_actions_template_destroy(in->port, + in->args.templ_destroy.template_id_n, + in->args.templ_destroy.template_id); + break; + case TABLE_CREATE: + port_flow_template_table_create(in->port, in->args.table.id, + &in->args.table.attr, in->args.table.pat_templ_id_n, + in->args.table.pat_templ_id, in->args.table.act_templ_id_n, + in->args.table.act_templ_id); + break; + case TABLE_DESTROY: + port_flow_template_table_destroy(in->port, + in->args.table_destroy.table_id_n, + in->args.table_destroy.table_id); + break; + case QUEUE_CREATE: + port_queue_flow_create(in->port, in->queue, in->postpone, + in->args.vc.table_id, in->args.vc.pat_templ_id, + in->args.vc.act_templ_id, in->args.vc.pattern, + in->args.vc.actions); + break; + case QUEUE_DESTROY: + port_queue_flow_destroy(in->port, in->queue, in->postpone, + in->args.destroy.rule_n, + in->args.destroy.rule); + break; + case PUSH: + port_queue_flow_push(in->port, in->queue); + break; + case PULL: + port_queue_flow_pull(in->port, in->queue); + break; + case QUEUE_INDIRECT_ACTION_CREATE: + port_queue_action_handle_create( + in->port, in->queue, in->postpone, + in->args.vc.attr.group, + &((const struct rte_flow_indir_action_conf) { + .ingress = in->args.vc.attr.ingress, + .egress = in->args.vc.attr.egress, + .transfer = in->args.vc.attr.transfer, + }), + in->args.vc.actions); + break; + case QUEUE_INDIRECT_ACTION_DESTROY: + port_queue_action_handle_destroy(in->port, + in->queue, in->postpone, + in->args.ia_destroy.action_id_n, + in->args.ia_destroy.action_id); + break; + case QUEUE_INDIRECT_ACTION_UPDATE: + port_queue_action_handle_update(in->port, + in->queue, in->postpone, + in->args.vc.attr.group, + in->args.vc.actions); + break; + case INDIRECT_ACTION_CREATE: + port_action_handle_create( + in->port, in->args.vc.attr.group, + &((const struct rte_flow_indir_action_conf) { + .ingress = in->args.vc.attr.ingress, + .egress = in->args.vc.attr.egress, + .transfer = in->args.vc.attr.transfer, + }), + in->args.vc.actions); + break; + case INDIRECT_ACTION_DESTROY: + port_action_handle_destroy(in->port, + in->args.ia_destroy.action_id_n, + in->args.ia_destroy.action_id); + break; + case INDIRECT_ACTION_UPDATE: + port_action_handle_update(in->port, in->args.vc.attr.group, + in->args.vc.actions); + break; + case INDIRECT_ACTION_QUERY: + port_action_handle_query(in->port, in->args.ia.action_id); + break; case VALIDATE: port_flow_validate(in->port, &in->args.vc.attr, - in->args.vc.pattern, in->args.vc.actions); + in->args.vc.pattern, in->args.vc.actions, + &in->args.vc.tunnel_ops); break; case CREATE: port_flow_create(in->port, &in->args.vc.attr, - in->args.vc.pattern, in->args.vc.actions); + in->args.vc.pattern, in->args.vc.actions, + &in->args.vc.tunnel_ops); break; case DESTROY: port_flow_destroy(in->port, in->args.destroy.rule_n, @@ -6165,6 +10548,11 @@ cmd_flow_parsed(const struct buffer *in) case FLUSH: port_flow_flush(in->port); break; + case DUMP_ONE: + case DUMP_ALL: + port_flow_dump(in->port, in->args.dump.mode, + in->args.dump.rule, in->args.dump.file); + break; case QUERY: port_flow_query(in->port, in->args.query.rule, &in->args.query.action); @@ -6176,6 +10564,29 @@ cmd_flow_parsed(const struct buffer *in) case ISOLATE: port_flow_isolate(in->port, in->args.isolate.set); break; + case AGED: + port_flow_aged(in->port, in->args.aged.destroy); + break; + case TUNNEL_CREATE: + port_flow_tunnel_create(in->port, &in->args.vc.tunnel_ops); + break; + case TUNNEL_DESTROY: + port_flow_tunnel_destroy(in->port, in->args.vc.tunnel_ops.id); + break; + case TUNNEL_LIST: + port_flow_tunnel_list(in->port); + break; + case ACTION_POL_G: + port_meter_policy_add(in->port, in->args.policy.policy_id, + in->args.vc.actions); + break; + case FLEX_ITEM_CREATE: + flex_item_create(in->port, in->args.flex.token, + in->args.flex.filename); + break; + case FLEX_ITEM_DESTROY: + flex_item_destroy(in->port, in->args.flex.token); + break; default: break; } @@ -6206,42 +10617,43 @@ cmdline_parse_inst_t cmd_flow = { static void update_fields(uint8_t *buf, struct rte_flow_item *item, uint16_t next_proto) { - struct rte_flow_item_ipv4 *ipv4; - struct rte_flow_item_eth *eth; - struct rte_flow_item_ipv6 *ipv6; - struct rte_flow_item_vxlan *vxlan; - struct rte_flow_item_vxlan_gpe *gpe; + struct rte_ipv4_hdr *ipv4; + struct rte_ether_hdr *eth; + struct rte_ipv6_hdr *ipv6; + struct rte_vxlan_hdr *vxlan; + struct rte_vxlan_gpe_hdr *gpe; struct rte_flow_item_nvgre *nvgre; uint32_t ipv6_vtc_flow; switch (item->type) { case RTE_FLOW_ITEM_TYPE_ETH: - eth = (struct rte_flow_item_eth *)buf; + eth = (struct rte_ether_hdr *)buf; if (next_proto) - eth->type = rte_cpu_to_be_16(next_proto); + eth->ether_type = rte_cpu_to_be_16(next_proto); break; case RTE_FLOW_ITEM_TYPE_IPV4: - ipv4 = (struct rte_flow_item_ipv4 *)buf; - ipv4->hdr.version_ihl = 0x45; - if (next_proto && ipv4->hdr.next_proto_id == 0) - ipv4->hdr.next_proto_id = (uint8_t)next_proto; + ipv4 = (struct rte_ipv4_hdr *)buf; + if (!ipv4->version_ihl) + ipv4->version_ihl = RTE_IPV4_VHL_DEF; + if (next_proto && ipv4->next_proto_id == 0) + ipv4->next_proto_id = (uint8_t)next_proto; break; case RTE_FLOW_ITEM_TYPE_IPV6: - ipv6 = (struct rte_flow_item_ipv6 *)buf; - if (next_proto && ipv6->hdr.proto == 0) - ipv6->hdr.proto = (uint8_t)next_proto; - ipv6_vtc_flow = rte_be_to_cpu_32(ipv6->hdr.vtc_flow); + ipv6 = (struct rte_ipv6_hdr *)buf; + if (next_proto && ipv6->proto == 0) + ipv6->proto = (uint8_t)next_proto; + ipv6_vtc_flow = rte_be_to_cpu_32(ipv6->vtc_flow); ipv6_vtc_flow &= 0x0FFFFFFF; /*< reset version bits. */ ipv6_vtc_flow |= 0x60000000; /*< set ipv6 version. */ - ipv6->hdr.vtc_flow = rte_cpu_to_be_32(ipv6_vtc_flow); + ipv6->vtc_flow = rte_cpu_to_be_32(ipv6_vtc_flow); break; case RTE_FLOW_ITEM_TYPE_VXLAN: - vxlan = (struct rte_flow_item_vxlan *)buf; - vxlan->flags = 0x08; + vxlan = (struct rte_vxlan_hdr *)buf; + vxlan->vx_flags = 0x08; break; case RTE_FLOW_ITEM_TYPE_VXLAN_GPE: - gpe = (struct rte_flow_item_vxlan_gpe *)buf; - gpe->flags = 0x0C; + gpe = (struct rte_vxlan_gpe_hdr *)buf; + gpe->vx_flags = 0x0C; break; case RTE_FLOW_ITEM_TYPE_NVGRE: nvgre = (struct rte_flow_item_nvgre *)buf; @@ -6333,6 +10745,9 @@ flow_item_default_mask(const struct rte_flow_item *item) case RTE_FLOW_ITEM_TYPE_GENEVE: mask = &rte_flow_item_geneve_mask; break; + case RTE_FLOW_ITEM_TYPE_GENEVE_OPT: + mask = &rte_flow_item_geneve_opt_mask; + break; case RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID: mask = &rte_flow_item_pppoe_proto_id_mask; break; @@ -6342,13 +10757,129 @@ flow_item_default_mask(const struct rte_flow_item *item) case RTE_FLOW_ITEM_TYPE_ESP: mask = &rte_flow_item_esp_mask; break; + case RTE_FLOW_ITEM_TYPE_AH: + mask = &rte_flow_item_ah_mask; + break; + case RTE_FLOW_ITEM_TYPE_PFCP: + mask = &rte_flow_item_pfcp_mask; + break; + case RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR: + case RTE_FLOW_ITEM_TYPE_REPRESENTED_PORT: + mask = &rte_flow_item_ethdev_mask; + break; + case RTE_FLOW_ITEM_TYPE_L2TPV2: + mask = &rte_flow_item_l2tpv2_mask; + break; + case RTE_FLOW_ITEM_TYPE_PPP: + mask = &rte_flow_item_ppp_mask; + break; default: break; } return mask; } - +/** Dispatch parsed buffer to function calls. */ +static void +cmd_set_raw_parsed_sample(const struct buffer *in) +{ + uint32_t n = in->args.vc.actions_n; + uint32_t i = 0; + struct rte_flow_action *action = NULL; + struct rte_flow_action *data = NULL; + const struct rte_flow_action_rss *rss = NULL; + size_t size = 0; + uint16_t idx = in->port; /* We borrow port field as index */ + uint32_t max_size = sizeof(struct rte_flow_action) * + ACTION_SAMPLE_ACTIONS_NUM; + + RTE_ASSERT(in->command == SET_SAMPLE_ACTIONS); + data = (struct rte_flow_action *)&raw_sample_confs[idx].data; + memset(data, 0x00, max_size); + for (; i <= n - 1; i++) { + action = in->args.vc.actions + i; + if (action->type == RTE_FLOW_ACTION_TYPE_END) + break; + switch (action->type) { + case RTE_FLOW_ACTION_TYPE_MARK: + size = sizeof(struct rte_flow_action_mark); + rte_memcpy(&sample_mark[idx], + (const void *)action->conf, size); + action->conf = &sample_mark[idx]; + break; + case RTE_FLOW_ACTION_TYPE_COUNT: + size = sizeof(struct rte_flow_action_count); + rte_memcpy(&sample_count[idx], + (const void *)action->conf, size); + action->conf = &sample_count[idx]; + break; + case RTE_FLOW_ACTION_TYPE_QUEUE: + size = sizeof(struct rte_flow_action_queue); + rte_memcpy(&sample_queue[idx], + (const void *)action->conf, size); + action->conf = &sample_queue[idx]; + break; + case RTE_FLOW_ACTION_TYPE_RSS: + size = sizeof(struct rte_flow_action_rss); + rss = action->conf; + rte_memcpy(&sample_rss_data[idx].conf, + (const void *)rss, size); + if (rss->key_len && rss->key) { + sample_rss_data[idx].conf.key = + sample_rss_data[idx].key; + rte_memcpy((void *)((uintptr_t) + sample_rss_data[idx].conf.key), + (const void *)rss->key, + sizeof(uint8_t) * rss->key_len); + } + if (rss->queue_num && rss->queue) { + sample_rss_data[idx].conf.queue = + sample_rss_data[idx].queue; + rte_memcpy((void *)((uintptr_t) + sample_rss_data[idx].conf.queue), + (const void *)rss->queue, + sizeof(uint16_t) * rss->queue_num); + } + action->conf = &sample_rss_data[idx].conf; + break; + case RTE_FLOW_ACTION_TYPE_RAW_ENCAP: + size = sizeof(struct rte_flow_action_raw_encap); + rte_memcpy(&sample_encap[idx], + (const void *)action->conf, size); + action->conf = &sample_encap[idx]; + break; + case RTE_FLOW_ACTION_TYPE_PORT_ID: + size = sizeof(struct rte_flow_action_port_id); + rte_memcpy(&sample_port_id[idx], + (const void *)action->conf, size); + action->conf = &sample_port_id[idx]; + break; + case RTE_FLOW_ACTION_TYPE_PF: + break; + case RTE_FLOW_ACTION_TYPE_VF: + size = sizeof(struct rte_flow_action_vf); + rte_memcpy(&sample_vf[idx], + (const void *)action->conf, size); + action->conf = &sample_vf[idx]; + break; + case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP: + size = sizeof(struct rte_flow_action_vxlan_encap); + parse_setup_vxlan_encap_data(&sample_vxlan_encap[idx]); + action->conf = &sample_vxlan_encap[idx].conf; + break; + case RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP: + size = sizeof(struct rte_flow_action_nvgre_encap); + parse_setup_nvgre_encap_data(&sample_nvgre_encap[idx]); + action->conf = &sample_nvgre_encap[idx]; + break; + default: + fprintf(stderr, "Error - Not supported action\n"); + return; + } + rte_memcpy(data, action, sizeof(struct rte_flow_action)); + data++; + } +} /** Dispatch parsed buffer to function calls. */ static void @@ -6364,7 +10895,10 @@ cmd_set_raw_parsed(const struct buffer *in) uint16_t upper_layer = 0; uint16_t proto = 0; uint16_t idx = in->port; /* We borrow port field as index */ + int gtp_psc = -1; /* GTP PSC option index. */ + if (in->command == SET_SAMPLE_ACTIONS) + return cmd_set_raw_parsed_sample(in); RTE_ASSERT(in->command == SET_RAW_ENCAP || in->command == SET_RAW_DECAP); if (in->command == SET_RAW_ENCAP) { @@ -6379,41 +10913,44 @@ cmd_set_raw_parsed(const struct buffer *in) /* process hdr from upper layer to low layer (L3/L4 -> L2). */ data_tail = data + ACTION_RAW_ENCAP_MAX_DATA; for (i = n - 1 ; i >= 0; --i) { + const struct rte_flow_item_gtp *gtp; + const struct rte_flow_item_geneve_opt *opt; + item = in->args.vc.pattern + i; if (item->spec == NULL) item->spec = flow_item_default_mask(item); switch (item->type) { case RTE_FLOW_ITEM_TYPE_ETH: - size = sizeof(struct rte_flow_item_eth); + size = sizeof(struct rte_ether_hdr); break; case RTE_FLOW_ITEM_TYPE_VLAN: - size = sizeof(struct rte_flow_item_vlan); + size = sizeof(struct rte_vlan_hdr); proto = RTE_ETHER_TYPE_VLAN; break; case RTE_FLOW_ITEM_TYPE_IPV4: - size = sizeof(struct rte_flow_item_ipv4); + size = sizeof(struct rte_ipv4_hdr); proto = RTE_ETHER_TYPE_IPV4; break; case RTE_FLOW_ITEM_TYPE_IPV6: - size = sizeof(struct rte_flow_item_ipv6); + size = sizeof(struct rte_ipv6_hdr); proto = RTE_ETHER_TYPE_IPV6; break; case RTE_FLOW_ITEM_TYPE_UDP: - size = sizeof(struct rte_flow_item_udp); + size = sizeof(struct rte_udp_hdr); proto = 0x11; break; case RTE_FLOW_ITEM_TYPE_TCP: - size = sizeof(struct rte_flow_item_tcp); + size = sizeof(struct rte_tcp_hdr); proto = 0x06; break; case RTE_FLOW_ITEM_TYPE_VXLAN: - size = sizeof(struct rte_flow_item_vxlan); + size = sizeof(struct rte_vxlan_hdr); break; case RTE_FLOW_ITEM_TYPE_VXLAN_GPE: - size = sizeof(struct rte_flow_item_vxlan_gpe); + size = sizeof(struct rte_vxlan_gpe_hdr); break; case RTE_FLOW_ITEM_TYPE_GRE: - size = sizeof(struct rte_flow_item_gre); + size = sizeof(struct rte_gre_hdr); proto = 0x2F; break; case RTE_FLOW_ITEM_TYPE_GRE_KEY: @@ -6421,7 +10958,7 @@ cmd_set_raw_parsed(const struct buffer *in) proto = 0x0; break; case RTE_FLOW_ITEM_TYPE_MPLS: - size = sizeof(struct rte_flow_item_mpls); + size = sizeof(struct rte_mpls_hdr); proto = 0x0; break; case RTE_FLOW_ITEM_TYPE_NVGRE: @@ -6429,21 +10966,124 @@ cmd_set_raw_parsed(const struct buffer *in) proto = 0x2F; break; case RTE_FLOW_ITEM_TYPE_GENEVE: - size = sizeof(struct rte_flow_item_geneve); + size = sizeof(struct rte_geneve_hdr); + break; + case RTE_FLOW_ITEM_TYPE_GENEVE_OPT: + opt = (const struct rte_flow_item_geneve_opt *) + item->spec; + size = offsetof(struct rte_flow_item_geneve_opt, + option_len) + sizeof(uint8_t); + if (opt->option_len && opt->data) { + *total_size += opt->option_len * + sizeof(uint32_t); + rte_memcpy(data_tail - (*total_size), + opt->data, + opt->option_len * sizeof(uint32_t)); + } break; case RTE_FLOW_ITEM_TYPE_L2TPV3OIP: - size = sizeof(struct rte_flow_item_l2tpv3oip); + size = sizeof(rte_be32_t); proto = 0x73; break; case RTE_FLOW_ITEM_TYPE_ESP: - size = sizeof(struct rte_flow_item_esp); + size = sizeof(struct rte_esp_hdr); proto = 0x32; break; + case RTE_FLOW_ITEM_TYPE_AH: + size = sizeof(struct rte_flow_item_ah); + proto = 0x33; + break; + case RTE_FLOW_ITEM_TYPE_GTP: + if (gtp_psc < 0) { + size = sizeof(struct rte_gtp_hdr); + break; + } + if (gtp_psc != i + 1) { + fprintf(stderr, + "Error - GTP PSC does not follow GTP\n"); + goto error; + } + gtp = item->spec; + if ((gtp->v_pt_rsv_flags & 0x07) != 0x04) { + /* Only E flag should be set. */ + fprintf(stderr, + "Error - GTP unsupported flags\n"); + goto error; + } else { + struct rte_gtp_hdr_ext_word ext_word = { + .next_ext = 0x85 + }; + + /* We have to add GTP header extra word. */ + *total_size += sizeof(ext_word); + rte_memcpy(data_tail - (*total_size), + &ext_word, sizeof(ext_word)); + } + size = sizeof(struct rte_gtp_hdr); + break; + case RTE_FLOW_ITEM_TYPE_GTP_PSC: + if (gtp_psc >= 0) { + fprintf(stderr, + "Error - Multiple GTP PSC items\n"); + goto error; + } else { + const struct rte_flow_item_gtp_psc + *opt = item->spec; + struct { + uint8_t len; + uint8_t pdu_type:4; + uint8_t qfi:6; + uint8_t next; + } psc; + psc.len = sizeof(psc) / 4; + psc.pdu_type = opt->hdr.type; + psc.qfi = opt->hdr.qfi; + psc.next = 0; + *total_size += sizeof(psc); + rte_memcpy(data_tail - (*total_size), + &psc, sizeof(psc)); + gtp_psc = i; + size = 0; + } + break; + case RTE_FLOW_ITEM_TYPE_PFCP: + size = sizeof(struct rte_flow_item_pfcp); + break; + case RTE_FLOW_ITEM_TYPE_FLEX: + size = item->spec ? + ((const struct rte_flow_item_flex *) + item->spec)->length : 0; + break; + case RTE_FLOW_ITEM_TYPE_GRE_OPTION: + size = 0; + if (item->spec) { + const struct rte_flow_item_gre_opt + *opt = item->spec; + if (opt->checksum_rsvd.checksum) { + *total_size += + sizeof(opt->checksum_rsvd); + rte_memcpy(data_tail - (*total_size), + &opt->checksum_rsvd, + sizeof(opt->checksum_rsvd)); + } + if (opt->key.key) { + *total_size += sizeof(opt->key.key); + rte_memcpy(data_tail - (*total_size), + &opt->key.key, + sizeof(opt->key.key)); + } + if (opt->sequence.sequence) { + *total_size += sizeof(opt->sequence.sequence); + rte_memcpy(data_tail - (*total_size), + &opt->sequence.sequence, + sizeof(opt->sequence.sequence)); + } + } + proto = 0x2F; + break; default: - printf("Error - Not supported item\n"); - *total_size = 0; - memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA); - return; + fprintf(stderr, "Error - Not supported item\n"); + goto error; } *total_size += size; rte_memcpy(data_tail - (*total_size), item->spec, size); @@ -6456,6 +11096,11 @@ cmd_set_raw_parsed(const struct buffer *in) printf("total data size is %zu\n", (*total_size)); RTE_ASSERT((*total_size) <= ACTION_RAW_ENCAP_MAX_DATA); memmove(data, (data_tail - (*total_size)), *total_size); + return; + +error: + *total_size = 0; + memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA); } /** Populate help strings for current token (cmdline API). */ @@ -6565,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 { @@ -6583,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, UINT16); -cmdline_parse_token_string_t cmd_show_set_raw_cmd_all = + cmd_index, RTE_UINT16); +static cmdline_parse_token_string_t cmd_show_set_raw_cmd_all = TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result, cmd_all, "all"); cmdline_parse_inst_t cmd_show_set_raw = {