X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline_flow.c;h=99dade7d8c2345e0b32a5c07b337d2790c2a7c15;hb=ea8483728e884454ed877e0b6b745d007a896b6a;hp=ddb49bc733126ae2a9ab30a6480618162ac70c97;hpb=226c6e60c35b3491f612de00a7438a2d8f75a0ad;p=dpdk.git diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index ddb49bc733..99dade7d8c 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -19,7 +19,10 @@ #include #include #include +#include +#include #include +#include #include "testpmd.h" @@ -51,6 +54,7 @@ enum index { /* Sub-leve commands. */ SET_RAW_ENCAP, SET_RAW_DECAP, + SET_RAW_INDEX, /* Top-level command. */ FLOW, @@ -203,6 +207,12 @@ enum index { ITEM_PPPOED, ITEM_PPPOE_SEID, ITEM_PPPOE_PROTO_ID, + ITEM_HIGIG2, + ITEM_HIGIG2_CLASSIFICATION, + ITEM_HIGIG2_VID, + ITEM_TAG, + ITEM_TAG_DATA, + ITEM_TAG_INDEX, /* Validate/create actions. */ ACTIONS, @@ -227,6 +237,7 @@ enum index { ACTION_RSS_FUNC_DEFAULT, ACTION_RSS_FUNC_TOEPLITZ, ACTION_RSS_FUNC_SIMPLE_XOR, + ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ, ACTION_RSS_TYPES, ACTION_RSS_TYPE, ACTION_RSS_KEY, @@ -304,6 +315,17 @@ enum index { ACTION_DEC_TCP_ACK_VALUE, ACTION_RAW_ENCAP, ACTION_RAW_DECAP, + ACTION_RAW_ENCAP_INDEX, + ACTION_RAW_ENCAP_INDEX_VALUE, + ACTION_RAW_DECAP_INDEX, + ACTION_RAW_DECAP_INDEX_VALUE, + ACTION_SET_TAG, + ACTION_SET_TAG_DATA, + ACTION_SET_TAG_INDEX, + ACTION_SET_TAG_MASK, + ACTION_SET_META, + ACTION_SET_META_DATA, + ACTION_SET_META_MASK, }; /** Maximum size for pattern in struct rte_flow_item_raw. */ @@ -314,7 +336,7 @@ enum index { (sizeof(struct rte_flow_item_raw) + ITEM_RAW_PATTERN_SIZE) /** Maximum number of queue indices in struct rte_flow_action_rss. */ -#define ACTION_RSS_QUEUE_NUM 32 +#define ACTION_RSS_QUEUE_NUM 128 /** Storage for struct rte_flow_action_rss including external data. */ struct action_rss_data { @@ -323,10 +345,9 @@ struct action_rss_data { uint16_t queue[ACTION_RSS_QUEUE_NUM]; }; -/** Maximum number of items in struct rte_flow_action_vxlan_encap. */ -#define ACTION_VXLAN_ENCAP_ITEMS_NUM 6 - +/** Maximum data size in struct rte_flow_action_raw_encap. */ #define ACTION_RAW_ENCAP_MAX_DATA 128 +#define RAW_ENCAP_CONFS_MAX_NUM 8 /** Storage for struct rte_flow_action_raw_encap. */ struct raw_encap_conf { @@ -335,7 +356,15 @@ struct raw_encap_conf { size_t size; }; -struct raw_encap_conf raw_encap_conf = {.size = 0}; +struct raw_encap_conf raw_encap_confs[RAW_ENCAP_CONFS_MAX_NUM]; + +/** Storage for struct rte_flow_action_raw_encap including external data. */ +struct action_raw_encap_data { + struct rte_flow_action_raw_encap conf; + uint8_t data[ACTION_RAW_ENCAP_MAX_DATA]; + uint8_t preserve[ACTION_RAW_ENCAP_MAX_DATA]; + uint16_t idx; +}; /** Storage for struct rte_flow_action_raw_decap. */ struct raw_decap_conf { @@ -343,7 +372,37 @@ struct raw_decap_conf { size_t size; }; -struct raw_decap_conf raw_decap_conf = {.size = 0}; +struct raw_decap_conf raw_decap_confs[RAW_ENCAP_CONFS_MAX_NUM]; + +/** Storage for struct rte_flow_action_raw_decap including external data. */ +struct action_raw_decap_data { + struct rte_flow_action_raw_decap conf; + uint8_t data[ACTION_RAW_ENCAP_MAX_DATA]; + uint16_t idx; +}; + +struct vxlan_encap_conf vxlan_encap_conf = { + .select_ipv4 = 1, + .select_vlan = 0, + .select_tos_ttl = 0, + .vni = "\x00\x00\x00", + .udp_src = 0, + .udp_dst = RTE_BE16(4789), + .ipv4_src = RTE_IPV4(127, 0, 0, 1), + .ipv4_dst = RTE_IPV4(255, 255, 255, 255), + .ipv6_src = "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x01", + .ipv6_dst = "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x11\x11", + .vlan_tci = 0, + .ip_tos = 0, + .ip_ttl = 255, + .eth_src = "\x00\x00\x00\x00\x00\x00", + .eth_dst = "\xff\xff\xff\xff\xff\xff", +}; + +/** Maximum number of items in struct rte_flow_action_vxlan_encap. */ +#define ACTION_VXLAN_ENCAP_ITEMS_NUM 6 /** Storage for struct rte_flow_action_vxlan_encap including external data. */ struct action_vxlan_encap_data { @@ -359,6 +418,21 @@ struct action_vxlan_encap_data { struct rte_flow_item_vxlan item_vxlan; }; +struct nvgre_encap_conf nvgre_encap_conf = { + .select_ipv4 = 1, + .select_vlan = 0, + .tni = "\x00\x00\x00", + .ipv4_src = RTE_IPV4(127, 0, 0, 1), + .ipv4_dst = RTE_IPV4(255, 255, 255, 255), + .ipv6_src = "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x01", + .ipv6_dst = "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x11\x11", + .vlan_tci = 0, + .eth_src = "\x00\x00\x00\x00\x00\x00", + .eth_dst = "\xff\xff\xff\xff\xff\xff", +}; + /** Maximum number of items in struct rte_flow_action_nvgre_encap. */ #define ACTION_NVGRE_ENCAP_ITEMS_NUM 5 @@ -375,21 +449,17 @@ struct action_nvgre_encap_data { struct rte_flow_item_nvgre item_nvgre; }; -/** Maximum data size in struct rte_flow_action_raw_encap. */ -#define ACTION_RAW_ENCAP_MAX_DATA 128 +struct l2_encap_conf l2_encap_conf; -/** Storage for struct rte_flow_action_raw_encap including external data. */ -struct action_raw_encap_data { - struct rte_flow_action_raw_encap conf; - uint8_t data[ACTION_RAW_ENCAP_MAX_DATA]; - uint8_t preserve[ACTION_RAW_ENCAP_MAX_DATA]; -}; +struct l2_decap_conf l2_decap_conf; -/** Storage for struct rte_flow_action_raw_decap including external data. */ -struct action_raw_decap_data { - struct rte_flow_action_raw_decap conf; - uint8_t data[ACTION_RAW_ENCAP_MAX_DATA]; -}; +struct mplsogre_encap_conf mplsogre_encap_conf; + +struct mplsogre_decap_conf mplsogre_decap_conf; + +struct mplsoudp_encap_conf mplsoudp_encap_conf; + +struct mplsoudp_decap_conf mplsoudp_decap_conf; /** Maximum number of subsequent tokens and arguments on the stack. */ #define CTX_STACK_SIZE 16 @@ -674,6 +744,8 @@ static const enum index next_item[] = { ITEM_PPPOES, ITEM_PPPOED, ITEM_PPPOE_PROTO_ID, + ITEM_HIGIG2, + ITEM_TAG, END_SET, ZERO, }; @@ -938,6 +1010,26 @@ static const enum index item_pppoe_proto_id[] = { ZERO, }; +static const enum index item_higig2[] = { + ITEM_HIGIG2_CLASSIFICATION, + ITEM_HIGIG2_VID, + ITEM_NEXT, + ZERO, +}; + +static const enum index next_set_raw[] = { + SET_RAW_INDEX, + ITEM_ETH, + ZERO, +}; + +static const enum index item_tag[] = { + ITEM_TAG_DATA, + ITEM_TAG_INDEX, + ITEM_NEXT, + ZERO, +}; + static const enum index next_action[] = { ACTION_END, ACTION_VOID, @@ -993,6 +1085,8 @@ static const enum index next_action[] = { ACTION_DEC_TCP_ACK, ACTION_RAW_ENCAP, ACTION_RAW_DECAP, + ACTION_SET_TAG, + ACTION_SET_META, ZERO, }; @@ -1179,6 +1273,33 @@ static const enum index action_dec_tcp_ack[] = { ZERO, }; +static const enum index action_raw_encap[] = { + ACTION_RAW_ENCAP_INDEX, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_raw_decap[] = { + ACTION_RAW_DECAP_INDEX, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_set_tag[] = { + ACTION_SET_TAG_DATA, + ACTION_SET_TAG_INDEX, + ACTION_SET_TAG_MASK, + ACTION_NEXT, + ZERO, +}; + +static const enum index action_set_meta[] = { + ACTION_SET_META_DATA, + ACTION_SET_META_MASK, + ACTION_NEXT, + ZERO, +}; + static int parse_set_raw_encap_decap(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1237,6 +1358,16 @@ static int parse_vc_action_raw_encap(struct context *, static int parse_vc_action_raw_decap(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); +static int parse_vc_action_raw_encap_index(struct context *, + const struct token *, const char *, + unsigned int, void *, unsigned int); +static int parse_vc_action_raw_decap_index(struct context *, + const struct token *, const char *, + unsigned int, void *, unsigned int); +static int parse_vc_action_set_meta(struct context *ctx, + const struct token *token, const char *str, + unsigned int len, void *buf, + unsigned int size); static int parse_destroy(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1296,6 +1427,8 @@ static int comp_vc_action_rss_type(struct context *, const struct token *, unsigned int, char *, unsigned int); static int comp_vc_action_rss_queue(struct context *, const struct token *, unsigned int, char *, unsigned int); +static int comp_set_raw_index(struct context *, const struct token *, + unsigned int, char *, unsigned int); /** Token definitions. */ static const struct token token_list[] = { @@ -2351,8 +2484,8 @@ static const struct token token_list[] = { .name = "data", .help = "metadata value", .next = NEXT(item_meta, NEXT_ENTRY(UNSIGNED), item_param), - .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_meta, - data, "\xff\xff\xff\xff")), + .args = ARGS(ARGS_ENTRY_MASK(struct rte_flow_item_meta, + data, "\xff\xff\xff\xff")), }, [ITEM_GRE_KEY] = { .name = "gre_key", @@ -2418,6 +2551,48 @@ static const struct token token_list[] = { .next = NEXT(item_pppoe_proto_id), .call = parse_vc, }, + [ITEM_HIGIG2] = { + .name = "higig2", + .help = "matches higig2 header", + .priv = PRIV_ITEM(HIGIG2, + sizeof(struct rte_flow_item_higig2_hdr)), + .next = NEXT(item_higig2), + .call = parse_vc, + }, + [ITEM_HIGIG2_CLASSIFICATION] = { + .name = "classification", + .help = "matches classification of higig2 header", + .next = NEXT(item_higig2, NEXT_ENTRY(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), + .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_higig2_hdr, + hdr.ppt1.vid)), + }, + [ITEM_TAG] = { + .name = "tag", + .help = "match tag value", + .priv = PRIV_ITEM(TAG, sizeof(struct rte_flow_item_tag)), + .next = NEXT(item_tag), + .call = parse_vc, + }, + [ITEM_TAG_DATA] = { + .name = "data", + .help = "tag value to match", + .next = NEXT(item_tag, NEXT_ENTRY(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_ENTRY(ITEM_PARAM_IS)), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_tag, index)), + }, /* Validate/create actions. */ [ACTIONS] = { .name = "actions", @@ -2543,7 +2718,8 @@ static const struct token token_list[] = { .next = NEXT(action_rss, NEXT_ENTRY(ACTION_RSS_FUNC_DEFAULT, ACTION_RSS_FUNC_TOEPLITZ, - ACTION_RSS_FUNC_SIMPLE_XOR)), + ACTION_RSS_FUNC_SIMPLE_XOR, + ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ)), }, [ACTION_RSS_FUNC_DEFAULT] = { .name = "default", @@ -2560,6 +2736,11 @@ static const struct token token_list[] = { .help = "simple XOR hash function", .call = parse_vc_action_rss_func, }, + [ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ] = { + .name = "symmetric_toeplitz", + .help = "Symmetric Toeplitz hash function", + .call = parse_vc_action_rss_func, + }, [ACTION_RSS_LEVEL] = { .name = "level", .help = "encapsulation level for \"types\"", @@ -3181,23 +3362,49 @@ static const struct token token_list[] = { .name = "raw_encap", .help = "encapsulation data, defined by set raw_encap", .priv = PRIV_ACTION(RAW_ENCAP, - sizeof(struct rte_flow_action_raw_encap)), - .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + sizeof(struct action_raw_encap_data)), + .next = NEXT(action_raw_encap), .call = parse_vc_action_raw_encap, }, + [ACTION_RAW_ENCAP_INDEX] = { + .name = "index", + .help = "the index of raw_encap_confs", + .next = NEXT(NEXT_ENTRY(ACTION_RAW_ENCAP_INDEX_VALUE)), + }, + [ACTION_RAW_ENCAP_INDEX_VALUE] = { + .name = "{index}", + .type = "UNSIGNED", + .help = "unsigned integer value", + .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + .call = parse_vc_action_raw_encap_index, + .comp = comp_set_raw_index, + }, [ACTION_RAW_DECAP] = { .name = "raw_decap", .help = "decapsulation data, defined by set raw_encap", .priv = PRIV_ACTION(RAW_DECAP, - sizeof(struct rte_flow_action_raw_decap)), - .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + sizeof(struct action_raw_decap_data)), + .next = NEXT(action_raw_decap), .call = parse_vc_action_raw_decap, }, + [ACTION_RAW_DECAP_INDEX] = { + .name = "index", + .help = "the index of raw_encap_confs", + .next = NEXT(NEXT_ENTRY(ACTION_RAW_DECAP_INDEX_VALUE)), + }, + [ACTION_RAW_DECAP_INDEX_VALUE] = { + .name = "{index}", + .type = "UNSIGNED", + .help = "unsigned integer value", + .next = NEXT(NEXT_ENTRY(ACTION_NEXT)), + .call = parse_vc_action_raw_decap_index, + .comp = comp_set_raw_index, + }, /* Top level command. */ [SET] = { .name = "set", .help = "set raw encap/decap data", - .type = "set raw_encap|raw_decap ", + .type = "set raw_encap|raw_decap ", .next = NEXT(NEXT_ENTRY (SET_RAW_ENCAP, SET_RAW_DECAP)), @@ -3207,15 +3414,85 @@ static const struct token token_list[] = { [SET_RAW_ENCAP] = { .name = "raw_encap", .help = "set raw encap data", - .next = NEXT(next_item), + .next = NEXT(next_set_raw), + .args = ARGS(ARGS_ENTRY_ARB_BOUNDED + (offsetof(struct buffer, port), + sizeof(((struct buffer *)0)->port), + 0, RAW_ENCAP_CONFS_MAX_NUM - 1)), .call = parse_set_raw_encap_decap, }, [SET_RAW_DECAP] = { .name = "raw_decap", .help = "set raw decap data", - .next = NEXT(next_item), + .next = NEXT(next_set_raw), + .args = ARGS(ARGS_ENTRY_ARB_BOUNDED + (offsetof(struct buffer, port), + sizeof(((struct buffer *)0)->port), + 0, RAW_ENCAP_CONFS_MAX_NUM - 1)), .call = parse_set_raw_encap_decap, - } + }, + [SET_RAW_INDEX] = { + .name = "{index}", + .type = "UNSIGNED", + .help = "index of raw_encap/raw_decap data", + .next = NEXT(next_item), + .call = parse_port, + }, + [ACTION_SET_TAG] = { + .name = "set_tag", + .help = "set tag", + .priv = PRIV_ACTION(SET_TAG, + sizeof(struct rte_flow_action_set_tag)), + .next = NEXT(action_set_tag), + .call = parse_vc, + }, + [ACTION_SET_TAG_INDEX] = { + .name = "index", + .help = "index of tag array", + .next = NEXT(action_set_tag, NEXT_ENTRY(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)), + .args = ARGS(ARGS_ENTRY + (struct rte_flow_action_set_tag, data)), + .call = parse_vc_conf, + }, + [ACTION_SET_TAG_MASK] = { + .name = "mask", + .help = "mask for tag value", + .next = NEXT(action_set_tag, NEXT_ENTRY(UNSIGNED)), + .args = ARGS(ARGS_ENTRY + (struct rte_flow_action_set_tag, mask)), + .call = parse_vc_conf, + }, + [ACTION_SET_META] = { + .name = "set_meta", + .help = "set metadata", + .priv = PRIV_ACTION(SET_META, + sizeof(struct rte_flow_action_set_meta)), + .next = NEXT(action_set_meta), + .call = parse_vc_action_set_meta, + }, + [ACTION_SET_META_DATA] = { + .name = "data", + .help = "metadata value", + .next = NEXT(action_set_meta, NEXT_ENTRY(UNSIGNED)), + .args = ARGS(ARGS_ENTRY + (struct rte_flow_action_set_meta, data)), + .call = parse_vc_conf, + }, + [ACTION_SET_META_MASK] = { + .name = "mask", + .help = "mask for metadata value", + .next = NEXT(action_set_meta, NEXT_ENTRY(UNSIGNED)), + .args = ARGS(ARGS_ENTRY + (struct rte_flow_action_set_meta, mask)), + .call = parse_vc_conf, + }, }; /** Remove and return last entry from argument stack. */ @@ -3678,6 +3955,9 @@ parse_vc_action_rss_func(struct context *ctx, const struct token *token, case ACTION_RSS_FUNC_SIMPLE_XOR: func = RTE_ETH_HASH_FUNCTION_SIMPLE_XOR; break; + case ACTION_RSS_FUNC_SYMMETRIC_TOEPLITZ: + func = RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ; + break; default: return -1; } @@ -4513,6 +4793,84 @@ parse_vc_action_mplsoudp_decap(struct context *ctx, const struct token *token, return ret; } +static int +parse_vc_action_raw_decap_index(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct action_raw_decap_data *action_raw_decap_data; + struct rte_flow_action *action; + const struct arg *arg; + struct buffer *out = buf; + int ret; + uint16_t idx; + + RTE_SET_USED(token); + RTE_SET_USED(buf); + RTE_SET_USED(size); + arg = ARGS_ENTRY_ARB_BOUNDED + (offsetof(struct action_raw_decap_data, idx), + sizeof(((struct action_raw_decap_data *)0)->idx), + 0, RAW_ENCAP_CONFS_MAX_NUM - 1); + if (push_args(ctx, arg)) + return -1; + ret = parse_int(ctx, token, str, len, NULL, 0); + if (ret < 0) { + pop_args(ctx); + return -1; + } + if (!ctx->object) + return len; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + action_raw_decap_data = ctx->object; + idx = action_raw_decap_data->idx; + action_raw_decap_data->conf.data = raw_decap_confs[idx].data; + action_raw_decap_data->conf.size = raw_decap_confs[idx].size; + action->conf = &action_raw_decap_data->conf; + return len; +} + + +static int +parse_vc_action_raw_encap_index(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct action_raw_encap_data *action_raw_encap_data; + struct rte_flow_action *action; + const struct arg *arg; + struct buffer *out = buf; + int ret; + uint16_t idx; + + RTE_SET_USED(token); + RTE_SET_USED(buf); + RTE_SET_USED(size); + if (ctx->curr != ACTION_RAW_ENCAP_INDEX_VALUE) + return -1; + arg = ARGS_ENTRY_ARB_BOUNDED + (offsetof(struct action_raw_encap_data, idx), + sizeof(((struct action_raw_encap_data *)0)->idx), + 0, RAW_ENCAP_CONFS_MAX_NUM - 1); + if (push_args(ctx, arg)) + return -1; + ret = parse_int(ctx, token, str, len, NULL, 0); + if (ret < 0) { + pop_args(ctx); + return -1; + } + if (!ctx->object) + return len; + action = &out->args.vc.actions[out->args.vc.actions_n - 1]; + action_raw_encap_data = ctx->object; + idx = action_raw_encap_data->idx; + action_raw_encap_data->conf.data = raw_encap_confs[idx].data; + action_raw_encap_data->conf.size = raw_encap_confs[idx].size; + action_raw_encap_data->conf.preserve = NULL; + action->conf = &action_raw_encap_data->conf; + return len; +} + static int parse_vc_action_raw_encap(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, @@ -4520,8 +4878,7 @@ parse_vc_action_raw_encap(struct context *ctx, const struct token *token, { struct buffer *out = buf; struct rte_flow_action *action; - struct rte_flow_action_raw_encap *action_raw_encap_conf = NULL; - uint8_t *data = NULL; + struct action_raw_encap_data *action_raw_encap_data = NULL; int ret; ret = parse_vc(ctx, token, str, len, buf, size); @@ -4537,14 +4894,11 @@ parse_vc_action_raw_encap(struct context *ctx, const struct token *token, ctx->object = out->args.vc.data; ctx->objmask = NULL; /* Copy the headers to the buffer. */ - action_raw_encap_conf = ctx->object; - /* data stored from tail of data buffer */ - data = (uint8_t *)&(raw_encap_conf.data) + - ACTION_RAW_ENCAP_MAX_DATA - raw_encap_conf.size; - action_raw_encap_conf->data = data; - action_raw_encap_conf->preserve = NULL; - action_raw_encap_conf->size = raw_encap_conf.size; - action->conf = action_raw_encap_conf; + 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; } @@ -4555,8 +4909,7 @@ parse_vc_action_raw_decap(struct context *ctx, const struct token *token, { struct buffer *out = buf; struct rte_flow_action *action; - struct rte_flow_action_raw_decap *action_raw_decap_conf = NULL; - uint8_t *data = NULL; + struct action_raw_decap_data *action_raw_decap_data = NULL; int ret; ret = parse_vc(ctx, token, str, len, buf, size); @@ -4572,16 +4925,29 @@ parse_vc_action_raw_decap(struct context *ctx, const struct token *token, ctx->object = out->args.vc.data; ctx->objmask = NULL; /* Copy the headers to the buffer. */ - action_raw_decap_conf = ctx->object; - /* data stored from tail of data buffer */ - data = (uint8_t *)&(raw_decap_conf.data) + - ACTION_RAW_ENCAP_MAX_DATA - raw_decap_conf.size; - action_raw_decap_conf->data = data; - action_raw_decap_conf->size = raw_decap_conf.size; - action->conf = action_raw_decap_conf; + 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; +} + /** Parse tokens for destroy command. */ static int parse_destroy(struct context *ctx, const struct token *token, @@ -5257,6 +5623,7 @@ parse_set_raw_encap_decap(struct context *ctx, const struct token *token, return -1; ctx->objdata = 0; ctx->objmask = NULL; + ctx->object = out; if (!out->command) return -1; out->command = ctx->curr; @@ -5433,6 +5800,24 @@ comp_vc_action_rss_queue(struct context *ctx, const struct token *token, return -1; } +/** Complete index number for set raw_encap/raw_decap commands. */ +static int +comp_set_raw_index(struct context *ctx, const struct token *token, + unsigned int ent, char *buf, unsigned int size) +{ + uint16_t idx = 0; + uint16_t nb = 0; + + RTE_SET_USED(ctx); + RTE_SET_USED(token); + for (idx = 0; idx < RAW_ENCAP_CONFS_MAX_NUM; ++idx) { + if (buf && idx == ent) + return snprintf(buf, size, "%u", idx); + ++nb; + } + return nb; +} + /** Internal context. */ static struct context cmd_flow_context; @@ -5741,11 +6126,13 @@ update_fields(uint8_t *buf, struct rte_flow_item *item, uint16_t next_proto) case RTE_FLOW_ITEM_TYPE_IPV4: ipv4 = (struct rte_flow_item_ipv4 *)buf; ipv4->hdr.version_ihl = 0x45; - ipv4->hdr.next_proto_id = (uint8_t)next_proto; + if (next_proto && ipv4->hdr.next_proto_id == 0) + ipv4->hdr.next_proto_id = (uint8_t)next_proto; break; case RTE_FLOW_ITEM_TYPE_IPV6: ipv6 = (struct rte_flow_item_ipv6 *)buf; - ipv6->hdr.proto = (uint8_t)next_proto; + 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_vtc_flow &= 0x0FFFFFFF; /*< reset version bits. */ ipv6_vtc_flow |= 0x60000000; /*< set ipv6 version. */ @@ -5872,15 +6259,16 @@ cmd_set_raw_parsed(const struct buffer *in) size_t *total_size = NULL; uint16_t upper_layer = 0; uint16_t proto = 0; + uint16_t idx = in->port; /* We borrow port field as index */ RTE_ASSERT(in->command == SET_RAW_ENCAP || in->command == SET_RAW_DECAP); if (in->command == SET_RAW_ENCAP) { - total_size = &raw_encap_conf.size; - data = (uint8_t *)&raw_encap_conf.data; + total_size = &raw_encap_confs[idx].size; + data = (uint8_t *)&raw_encap_confs[idx].data; } else { - total_size = &raw_decap_conf.size; - data = (uint8_t *)&raw_decap_conf.data; + total_size = &raw_decap_confs[idx].size; + data = (uint8_t *)&raw_decap_confs[idx].data; } *total_size = 0; memset(data, 0x00, ACTION_RAW_ENCAP_MAX_DATA); @@ -5926,14 +6314,19 @@ cmd_set_raw_parsed(const struct buffer *in) break; case RTE_FLOW_ITEM_TYPE_GRE_KEY: size = sizeof(rte_be32_t); + proto = 0x0; break; case RTE_FLOW_ITEM_TYPE_MPLS: size = sizeof(struct rte_flow_item_mpls); + proto = 0x0; break; case RTE_FLOW_ITEM_TYPE_NVGRE: size = sizeof(struct rte_flow_item_nvgre); proto = 0x2F; break; + case RTE_FLOW_ITEM_TYPE_GENEVE: + size = sizeof(struct rte_flow_item_geneve); + break; default: printf("Error - Not supported item\n"); *total_size = 0; @@ -5950,6 +6343,7 @@ cmd_set_raw_parsed(const struct buffer *in) if (verbose_level & 0x1) printf("total data size is %zu\n", (*total_size)); RTE_ASSERT((*total_size) <= ACTION_RAW_ENCAP_MAX_DATA); + memmove(data, (data_tail - (*total_size)), *total_size); } /** Populate help strings for current token (cmdline API). */ @@ -6034,3 +6428,80 @@ cmdline_parse_inst_t cmd_set_raw = { NULL, }, /**< Tokens are returned by cmd_flow_tok(). */ }; + +/* *** display raw_encap/raw_decap buf */ +struct cmd_show_set_raw_result { + cmdline_fixed_string_t cmd_show; + cmdline_fixed_string_t cmd_what; + cmdline_fixed_string_t cmd_all; + uint16_t cmd_index; +}; + +static void +cmd_show_set_raw_parsed(void *parsed_result, struct cmdline *cl, void *data) +{ + struct cmd_show_set_raw_result *res = parsed_result; + uint16_t index = res->cmd_index; + uint8_t all = 0; + uint8_t *raw_data = NULL; + size_t raw_size = 0; + char title[16] = {0}; + + RTE_SET_USED(cl); + RTE_SET_USED(data); + if (!strcmp(res->cmd_all, "all")) { + all = 1; + index = 0; + } else if (index >= RAW_ENCAP_CONFS_MAX_NUM) { + printf("index should be 0-%u\n", RAW_ENCAP_CONFS_MAX_NUM - 1); + return; + } + do { + if (!strcmp(res->cmd_what, "raw_encap")) { + raw_data = (uint8_t *)&raw_encap_confs[index].data; + raw_size = raw_encap_confs[index].size; + snprintf(title, 16, "\nindex: %u", index); + rte_hexdump(stdout, title, raw_data, raw_size); + } else { + raw_data = (uint8_t *)&raw_decap_confs[index].data; + raw_size = raw_decap_confs[index].size; + snprintf(title, 16, "\nindex: %u", index); + rte_hexdump(stdout, title, raw_data, raw_size); + } + } while (all && ++index < RAW_ENCAP_CONFS_MAX_NUM); +} + +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 = + 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 = + TOKEN_NUM_INITIALIZER(struct cmd_show_set_raw_result, + cmd_index, UINT16); +cmdline_parse_token_string_t cmd_show_set_raw_cmd_all = + TOKEN_STRING_INITIALIZER(struct cmd_show_set_raw_result, + cmd_all, "all"); +cmdline_parse_inst_t cmd_show_set_raw = { + .f = cmd_show_set_raw_parsed, + .data = NULL, + .help_str = "show ", + .tokens = { + (void *)&cmd_show_set_raw_cmd_show, + (void *)&cmd_show_set_raw_cmd_what, + (void *)&cmd_show_set_raw_cmd_index, + NULL, + }, +}; +cmdline_parse_inst_t cmd_show_set_raw_all = { + .f = cmd_show_set_raw_parsed, + .data = NULL, + .help_str = "show all", + .tokens = { + (void *)&cmd_show_set_raw_cmd_show, + (void *)&cmd_show_set_raw_cmd_what, + (void *)&cmd_show_set_raw_cmd_all, + NULL, + }, +};