From patchwork Thu Oct 5 10:02:46 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Qi Zhang X-Patchwork-Id: 132308 Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id B2A37426BA; Thu, 5 Oct 2023 03:50:33 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 387C14028A; Thu, 5 Oct 2023 03:50:33 +0200 (CEST) Received: from mgamail.intel.com (mgamail.intel.com [134.134.136.126]) by mails.dpdk.org (Postfix) with ESMTP id 79B4440283 for ; Thu, 5 Oct 2023 03:50:31 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1696470631; x=1728006631; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=kSLf6Cmrc5r/ydzx/db+N++tGYCaAWQQ0Mq3cKDM+2o=; b=VkEUO8mSpoutyWH0SKoBgWKQ0inkknmhhqXKT19tVz2wL+C/lUbKI9xh rMvX02bJPDNY0/IW819jVRjEOlwwMrY5NVx158BvkyzAMNwBmO1dAZIkq iW7/Xd42wv852HOzCCYxvrdtEuZSDMpAU458xE2Axfhq7Npvf3Z4jDpN6 eybIg3XZSBVDtUluK6w5fguTnoICNKSaBWLkPtte3qOa0q/OlzumVapOk 1YbwxQuxgDvQ4Y8j5TEq0Vw02plD+a0sphK1AYHGcPu8+CUbim7k0FAQk efb7dd97EgF2GEr4+7PJhfM+oqkC1ceOSQ+IbXJZdkaU0aYRtqHB/gks/ A==; X-IronPort-AV: E=McAfee;i="6600,9927,10853"; a="368432988" X-IronPort-AV: E=Sophos;i="6.03,201,1694761200"; d="scan'208";a="368432988" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 04 Oct 2023 18:42:32 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10853"; a="751591497" X-IronPort-AV: E=Sophos;i="6.03,201,1694761200"; d="scan'208";a="751591497" Received: from dpdk-qzhan15-test02.sh.intel.com ([10.67.115.37]) by orsmga002.jf.intel.com with ESMTP; 04 Oct 2023 18:42:29 -0700 From: Qi Zhang To: aman.deep.singh@intel.com, yuying.zhang@intel.com Cc: dev@dpdk.org, cristian.dumitrescu@intel.com, orika@nvidia.com, ferruh.yigit@amd.com, Qi Zhang Subject: [PATCH 1/2] app/testpmd: enable cli for programmable action Date: Thu, 5 Oct 2023 06:02:46 -0400 Message-Id: <20231005100246.242970-1-qi.z.zhang@intel.com> X-Mailer: git-send-email 2.31.1 MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Parsing command line for rte_flow_action_prog. Syntax: "prog name [arguments \ ... end]" Use parse_string0 to parse name string. Use parse_hex to parse hex string. Use struct action_prog_data to store parsed result. Example: Action with 2 arguments: "prog name action0 arguments field0 03FF field1 55AA end" Action without argument: "prog name action1" Signed-off-by: Qi Zhang --- app/test-pmd/cmdline_flow.c | 223 ++++++++++++++++++++++++++++++++++++ 1 file changed, 223 insertions(+) diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 21828c144c..028cff0150 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -719,6 +719,13 @@ enum index { ACTION_IPV6_EXT_PUSH, ACTION_IPV6_EXT_PUSH_INDEX, ACTION_IPV6_EXT_PUSH_INDEX_VALUE, + ACTION_PROG, + ACTION_PROG_NAME, + ACTION_PROG_NAME_STRING, + ACTION_PROG_ARGUMENTS, + ACTION_PROG_ARG_NAME, + ACTION_PROG_ARG_VALUE, + ACTION_PROG_ARG_END, }; /** Maximum size for pattern in struct rte_flow_item_raw. */ @@ -749,6 +756,19 @@ struct action_rss_data { uint16_t queue[ACTION_RSS_QUEUE_NUM]; }; +#define ACTION_PROG_NAME_SIZE_MAX 32 +#define ACTION_PROG_ARG_NUM_MAX 8 +#define ACTION_PROG_ARG_VALUE_SIZE_MAX 16 + +/** Storage for struct rte_flow_action_prog including external data. */ +struct action_prog_data { + struct rte_flow_action_prog conf; + char name[ACTION_PROG_NAME_SIZE_MAX]; + struct rte_flow_action_prog_argument args[ACTION_PROG_ARG_NUM_MAX]; + char arg_names[ACTION_PROG_ARG_NUM_MAX][ACTION_PROG_NAME_SIZE_MAX]; + uint8_t value[ACTION_PROG_ARG_NUM_MAX][ACTION_PROG_ARG_VALUE_SIZE_MAX]; +}; + /** Maximum data size in struct rte_flow_action_raw_encap. */ #define ACTION_RAW_ENCAP_MAX_DATA 512 #define RAW_ENCAP_CONFS_MAX_NUM 8 @@ -2169,6 +2189,7 @@ static const enum index next_action[] = { ACTION_QUOTA_QU, ACTION_IPV6_EXT_REMOVE, ACTION_IPV6_EXT_PUSH, + ACTION_PROG, ZERO, }; @@ -2510,6 +2531,13 @@ static const enum index action_represented_port[] = { ZERO, }; +static const enum index action_prog[] = { + ACTION_PROG_NAME, + ACTION_PROG_ARGUMENTS, + ACTION_NEXT, + ZERO, +}; + static int parse_set_raw_encap_decap(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -2786,6 +2814,18 @@ static int parse_qu_mode_name(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size); +static int +parse_vc_action_prog(struct context *, const struct token *, + const char *, unsigned int, void *, + unsigned int); +static int +parse_vc_action_prog_arg_name(struct context *, const struct token *, + const char *, unsigned int, void *, + unsigned int); +static int +parse_vc_action_prog_arg_value(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 *, @@ -7518,6 +7558,48 @@ static const struct token token_list[] = { .args = ARGS(ARGS_ENTRY(struct rte_flow_item_tx_queue, tx_queue)), }, + [ACTION_PROG] = { + .name = "prog", + .help = "match a programmable action", + .priv = PRIV_ACTION(PROG, sizeof(struct action_prog_data)), + .next = NEXT(action_prog), + .call = parse_vc_action_prog, + }, + [ACTION_PROG_NAME] = { + .name = "name", + .help = "programble action name", + .next = NEXT(action_prog, NEXT_ENTRY(ACTION_PROG_NAME_STRING)), + .args = ARGS(ARGS_ENTRY(struct action_prog_data, name)), + }, + [ACTION_PROG_NAME_STRING] = { + .name = "{string}", + .type = "STRING", + .help = "programmable action name string", + .call = parse_string0, + }, + [ACTION_PROG_ARGUMENTS] = { + .name = "arguments", + .help = "programmable action name", + .next = NEXT(action_prog, NEXT_ENTRY(ACTION_PROG_ARG_NAME)), + .call = parse_vc_conf, + }, + [ACTION_PROG_ARG_NAME] = { + .name = "{string}", + .help = "programmable action argument name", + .next = NEXT(NEXT_ENTRY(ACTION_PROG_ARG_VALUE)), + .call = parse_vc_action_prog_arg_name, + }, + [ACTION_PROG_ARG_VALUE] = { + .name = "{hex}", + .help = "programmable action argument value", + .next = NEXT(NEXT_ENTRY(ACTION_PROG_ARG_END, ACTION_PROG_ARG_NAME)), + .call = parse_vc_action_prog_arg_value, + }, + [ACTION_PROG_ARG_END] = { + .name = "end", + .help = "end of the programmable action arguments", + }, + }; /** Remove and return last entry from argument stack. */ @@ -11675,6 +11757,147 @@ parse_qu_mode_name(struct context *ctx, const struct token *token, (uint32_t *)&out->args.ia.qu_mode); } +/** Parse prog action. */ +static int +parse_vc_action_prog(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_prog_data *action_prog_data; + uint16_t 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]; + ctx->object = out->args.vc.data; + action_prog_data = ctx->object; + *action_prog_data = (struct action_prog_data) { + .conf = (struct rte_flow_action_prog) { + .args_num = 0, + .name = action_prog_data->name, + .args = action_prog_data->args, + }, + }; + for (i = 0; i < ACTION_PROG_ARG_NUM_MAX; ++i) + action_prog_data->args[i].name = action_prog_data->arg_names[i]; + action->conf = &action_prog_data->conf; + + return ret; +} + +static int +parse_vc_action_prog_arg_name(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct action_prog_data *action_prog_data; + struct buffer *out = buf; + const struct arg *arg; + uint32_t i; + int ret; + + (void)token; + (void)buf; + (void)size; + if (ctx->curr != ACTION_PROG_ARG_NAME) + return -1; + + if (!out) + return len; + + action_prog_data = (void *)out->args.vc.data; + i = action_prog_data->conf.args_num; + + if (i >= ACTION_PROG_ARG_NUM_MAX) + return -1; + + arg = ARGS_ENTRY_ARB(offsetof(struct action_prog_data, arg_names) + + i * ACTION_PROG_NAME_SIZE_MAX, + ACTION_PROG_NAME_SIZE_MAX); + + if (push_args(ctx, arg)) + return -1; + + ret = parse_string0(ctx, token, str, len, NULL, 0); + if (ret < 0) { + pop_args(ctx); + return -1; + } + + return len; +} + +static int +parse_vc_action_prog_arg_value(struct context *ctx, const struct token *token, + const char *str, unsigned int len, + void *buf, unsigned int size) +{ + struct action_prog_data *action_prog_data; + const struct arg *arg_addr; + const struct arg *arg_size; + const struct arg *arg_data; + struct buffer *out = buf; + uint32_t i; + int ret; + + (void)token; + (void)buf; + (void)size; + if (ctx->curr != ACTION_PROG_ARG_VALUE) + return -1; + + if (!out) + return len; + + action_prog_data = (void *)out->args.vc.data; + i = action_prog_data->conf.args_num; + + arg_addr = ARGS_ENTRY_ARB(offsetof(struct action_prog_data, args) + + i * sizeof(struct rte_flow_action_prog_argument) + + offsetof(struct rte_flow_action_prog_argument, value), + sizeof(action_prog_data->args[i].value)); + + arg_size = ARGS_ENTRY_ARB(offsetof(struct action_prog_data, args) + + i * sizeof(struct rte_flow_action_prog_argument) + + offsetof(struct rte_flow_action_prog_argument, size), + sizeof(action_prog_data->args[i].size)); + + arg_data = ARGS_ENTRY_ARB(offsetof(struct action_prog_data, value) + + i * ACTION_PROG_ARG_VALUE_SIZE_MAX, + ACTION_PROG_ARG_VALUE_SIZE_MAX); + + if (push_args(ctx, arg_addr)) + return -1; + if (push_args(ctx, arg_size)) { + pop_args(ctx); + return -1; + } + if (push_args(ctx, arg_data)) { + pop_args(ctx); + pop_args(ctx); + return -1; + } + + ret = parse_hex(ctx, token, str, len, NULL, 0); + if (ret < 0) { + pop_args(ctx); + pop_args(ctx); + pop_args(ctx); + return -1; + } + action_prog_data->conf.args_num++; + return len; +} + /** No completion. */ static int comp_none(struct context *ctx, const struct token *token,