From patchwork Tue Aug 22 01:13:06 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhang, Yuying" X-Patchwork-Id: 131804 X-Patchwork-Delegate: ferruh.yigit@amd.com 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 9965D42608; Thu, 21 Sep 2023 19:10:15 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 8C5924013F; Thu, 21 Sep 2023 19:10:13 +0200 (CEST) Received: from mgamail.intel.com (mgamail.intel.com [192.55.52.136]) by mails.dpdk.org (Postfix) with ESMTP id 7D262400D7; Thu, 21 Sep 2023 19:10:11 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1695316212; x=1726852212; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=e3ngruMce7NCIYAHMV0QUvzSjWwIdHuLBoU0IXgv+1A=; b=cynTs/UPccxvL6xDCSoBQU4M1q0YOJ3KJyMjhB1/h5yfRoYtCMgNT1Td Qne3LBr0GtHXqSzOgOTOZEUciVIFDDTSmreQfeNZaQgOH61UZs4d3/n+f Z/FIwwK7XzDN/WowwhWqTEfjLtRm+VMR7wRNvCm86TTLPc6gaehKIFTBH jDEohfe/f2THbEzQDkKZ3FnD900W9zTU9DXDYcN4SaLxUGBTs3267+ZPq OT+G4jqB6VLgS4ZNXmrhlLYMTk50+UggopUN72Fg0+QdVmvyG3ywhs7vQ Bye33EnIjkhS08+xGBIbI+EoHNYrsd9zy0cD1wR7LF5UOWXPZ5SDdKnDh w==; X-IronPort-AV: E=McAfee;i="6600,9927,10840"; a="359975104" X-IronPort-AV: E=Sophos;i="6.03,166,1694761200"; d="scan'208";a="359975104" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Sep 2023 10:09:30 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10840"; a="870902114" X-IronPort-AV: E=Sophos;i="6.03,166,1694761200"; d="scan'208";a="870902114" Received: from dpdk-pengyuan-mev.sh.intel.com ([10.67.119.128]) by orsmga004.jf.intel.com with ESMTP; 21 Sep 2023 10:09:28 -0700 From: "Zhang, Yuying" To: yuying.zhang@intel.com, dev@dpdk.org, orika@nvidia.com, aman.deep.singh@intel.com Cc: stable@dpdk.org Subject: [PATCH v1] app/testpmd: refine encap content Date: Tue, 22 Aug 2023 01:13:06 +0000 Message-Id: <20230822011306.19616-1-yuying.zhang@intel.com> X-Mailer: git-send-email 2.25.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 From: Yuying Zhang Refine vxlan encap content of all protocol headers. Fixes: 1960be7d32f8 ("app/testpmd: add VXLAN encap/decap") Cc: stable@dpdk.org Signed-off-by: Yuying Zhang --- app/test-pmd/cmdline_flow.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 95c0a19beb..a488864e2b 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -8523,7 +8523,7 @@ parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_ .type = RTE_FLOW_ITEM_TYPE_END, }, }, - .item_eth.hdr.ether_type = 0, + .item_eth.hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4), .item_vlan = { .hdr.vlan_tci = vxlan_encap_conf.vlan_tci, .hdr.eth_proto = 0, @@ -8531,24 +8531,32 @@ parse_setup_vxlan_encap_data(struct action_vxlan_encap_data *action_vxlan_encap_ .item_ipv4.hdr = { .src_addr = vxlan_encap_conf.ipv4_src, .dst_addr = vxlan_encap_conf.ipv4_dst, + .version_ihl = RTE_IPV4_VHL_DEF, + .next_proto_id = IPPROTO_UDP, + .time_to_live = IPDEFTTL, + .hdr_checksum = rte_cpu_to_be_16(1), }, .item_udp.hdr = { .src_port = vxlan_encap_conf.udp_src, .dst_port = vxlan_encap_conf.udp_dst, + .dgram_cksum = RTE_BE16(0x01), }, - .item_vxlan.hdr.flags = 0, + .item_vxlan.hdr.flags = 0x08, }; memcpy(action_vxlan_encap_data->item_eth.hdr.dst_addr.addr_bytes, vxlan_encap_conf.eth_dst, RTE_ETHER_ADDR_LEN); memcpy(action_vxlan_encap_data->item_eth.hdr.src_addr.addr_bytes, vxlan_encap_conf.eth_src, RTE_ETHER_ADDR_LEN); if (!vxlan_encap_conf.select_ipv4) { + action_vxlan_encap_data->item_eth.type = RTE_BE16(RTE_ETHER_TYPE_IPV6); memcpy(&action_vxlan_encap_data->item_ipv6.hdr.src_addr, &vxlan_encap_conf.ipv6_src, sizeof(vxlan_encap_conf.ipv6_src)); memcpy(&action_vxlan_encap_data->item_ipv6.hdr.dst_addr, &vxlan_encap_conf.ipv6_dst, sizeof(vxlan_encap_conf.ipv6_dst)); + action_vxlan_encap_data->item_ipv6.hdr.proto = IPPROTO_UDP; + action_vxlan_encap_data->item_ipv6.hdr.hop_limits = IPDEFTTL; action_vxlan_encap_data->items[2] = (struct rte_flow_item){ .type = RTE_FLOW_ITEM_TYPE_IPV6, .spec = &action_vxlan_encap_data->item_ipv6, From patchwork Sat Oct 7 10:47:30 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Qi Zhang X-Patchwork-Id: 132370 X-Patchwork-Delegate: ferruh.yigit@amd.com 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 9704F426D6; Sat, 7 Oct 2023 04:27:37 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6C605402BF; Sat, 7 Oct 2023 04:27:37 +0200 (CEST) Received: from mgamail.intel.com (mgamail.intel.com [192.55.52.43]) by mails.dpdk.org (Postfix) with ESMTP id B4BCC402A7 for ; Sat, 7 Oct 2023 04:27:34 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1696645655; x=1728181655; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=r1CxDF4QLU0eOArrl0mxLb4fLNdNK0Z1R051NeKAVY8=; b=m0ks4kNd69qpiQKhfMKT+g5T3+2jedLCKka35DBPywrDkvWedeBaXpw1 HprP3pmqwpdbFGXHEDS3PAWY108htuxMe69D1AuL9xyvi8dmcoI+vaLJT Q4hj26JNOiquhr+9Prbx0oLNCZk/0eNKNMRHp75yjbAygAOPhOJSGnKQi /cspmLu31kso08gqjtZ1jlUTnymmzK513lofKMvsAbyC11VrhBe3bPqSg NTqbhK2n70s/9zNhisyL1/Z5KKKi7QHo67KnFI1q1bsZUO3ozY7EVlgTx xZN+nxUVKgxo6+YzssDCW8CL4OLYdbXeTGUElpVg8P2crUqzfherivOaz Q==; X-IronPort-AV: E=McAfee;i="6600,9927,10855"; a="470147564" X-IronPort-AV: E=Sophos;i="6.03,204,1694761200"; d="scan'208";a="470147564" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Oct 2023 19:27:14 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10855"; a="752381200" X-IronPort-AV: E=Sophos;i="6.03,204,1694761200"; d="scan'208";a="752381200" Received: from dpdk-qzhan15-test02.sh.intel.com ([10.67.115.37]) by orsmga002.jf.intel.com with ESMTP; 06 Oct 2023 19:27:10 -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 v4] app/testpmd: enable cli for programmable action Date: Sat, 7 Oct 2023 06:47:30 -0400 Message-Id: <20231007104730.441719-1-qi.z.zhang@intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20231005100246.242970-1-qi.z.zhang@intel.com> References: <20231005100246.242970-1-qi.z.zhang@intel.com> 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 Acked-by: Cristian Dumitrescu --- v4: - be more generous on the max size of name and value. v3: - refine struct action_prog_data - enlarge the max size v2: - fix title - minor coding style refine. app/test-pmd/cmdline_flow.c | 232 ++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index 21828c144c..ae5556e704 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,23 @@ struct action_rss_data { uint16_t queue[ACTION_RSS_QUEUE_NUM]; }; +#define ACTION_PROG_NAME_SIZE_MAX 256 +#define ACTION_PROG_ARG_NUM_MAX 16 +#define ACTION_PROG_ARG_VALUE_SIZE_MAX 64 + +/** Storage for struct rte_flow_action_prog including external data. */ +struct action_prog_data { + struct rte_flow_action_prog conf; + struct { + char name[ACTION_PROG_NAME_SIZE_MAX]; + struct rte_flow_action_prog_argument args[ACTION_PROG_ARG_NUM_MAX]; + struct { + char names[ACTION_PROG_NAME_SIZE_MAX]; + uint8_t value[ACTION_PROG_ARG_VALUE_SIZE_MAX]; + } arg_data[ACTION_PROG_ARG_NUM_MAX]; + } data; +}; + /** 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 +2193,7 @@ static const enum index next_action[] = { ACTION_QUOTA_QU, ACTION_IPV6_EXT_REMOVE, ACTION_IPV6_EXT_PUSH, + ACTION_PROG, ZERO, }; @@ -2510,6 +2535,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 +2818,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 +7562,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, 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 +11761,152 @@ 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; + + 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->data.name, + .args = action_prog_data->data.args, + }, + }; + + for (i = 0; i < ACTION_PROG_ARG_NUM_MAX; ++i) + action_prog_data->data.args[i].name = action_prog_data->data.arg_data[i].names; + 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, + data.arg_data[i].names), + 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, + data.args[i].value), + sizeof(action_prog_data->data.args[i].value)); + + arg_size = ARGS_ENTRY_ARB(offsetof(struct action_prog_data, + data.args[i].size), + sizeof(action_prog_data->data.args[i].size)); + + arg_data = ARGS_ENTRY_ARB(offsetof(struct action_prog_data, + data.arg_data[i].value), + 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,