From patchwork Mon Apr 19 17:51:30 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bing Zhao X-Patchwork-Id: 91782 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 9E08AA0524; Mon, 19 Apr 2021 19:51:45 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 8B8E34142E; Mon, 19 Apr 2021 19:51:45 +0200 (CEST) Received: from mellanox.co.il (mail-il-dmz.mellanox.com [193.47.165.129]) by mails.dpdk.org (Postfix) with ESMTP id 59D3F4142E for ; Mon, 19 Apr 2021 19:51:44 +0200 (CEST) Received: from Internal Mail-Server by MTLPINE1 (envelope-from bingz@nvidia.com) with SMTP; 19 Apr 2021 20:51:40 +0300 Received: from nvidia.com (mtbc-r640-01.mtbc.labs.mlnx [10.75.70.6]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id 13JHpZVf007797; Mon, 19 Apr 2021 20:51:38 +0300 From: Bing Zhao To: orika@nvidia.com, thomas@monjalon.net, ferruh.yigit@intel.com, andrew.rybchenko@oktetlabs.ru Cc: dev@dpdk.org, ajit.khaparde@broadcom.com, xiaoyun.li@intel.com Date: Tue, 20 Apr 2021 01:51:30 +0800 Message-Id: <1618854691-370765-2-git-send-email-bingz@nvidia.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1618854691-370765-1-git-send-email-bingz@nvidia.com> References: <1618062393-205611-1-git-send-email-bingz@nvidia.com> <1618854691-370765-1-git-send-email-bingz@nvidia.com> Subject: [dpdk-dev] [PATCH v5 1/2] ethdev: introduce conntrack flow action and item 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 Sender: "dev" This commit introduces the conntrack action and item. Usually the HW offloading is stateless. For some stateful offloading like a TCP connection, HW module will help provide the ability of a full offloading w/o SW participation after the connection was established. The basic usage is that in the first flow rule the application should add the conntrack action and jump to the next flow table. In the following flow rule(s) of the next table, the application should use the conntrack item to match on the result. A TCP connection has two directions traffic. To set a conntrack action context correctly, the information of packets from both directions are required. The conntrack action should be created on one ethdev port and supply the peer ethdev port as a parameter to the action. After context created, it could only be used between these two ethdev ports (dual-port mode) or a single port. The application should modify the action via the API "rte_action_handle_update" only when before using it to create a flow rule with conntrack for the opposite direction. This will help the driver to recognize the direction of the flow to be created, especially in the single-port mode, in which case the traffic from both directions will go through the same ethdev port if the application works as an "forwarding engine" but not an end point. There is no need to call the update interface if the subsequent flow rules have nothing to be changed. Query will be supported via "rte_action_handle_query" interface, about the current packets information and connection status. The fields query capabilities depends on the HW. For the packets received during the conntrack setup, it is suggested to re-inject the packets in order to make sure the conntrack module works correctly without missing any packet. Only the valid packets should pass the conntrack, packets with invalid TCP information, like out of window, or with invalid header, like malformed, should not pass. Naming and definition: https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/ netfilter/nf_conntrack_tcp.h https://elixir.bootlin.com/linux/latest/source/net/netfilter/ nf_conntrack_proto_tcp.c Other reference: https://www.usenix.org/legacy/events/sec01/invitedtalks/rooij.pdf Signed-off-by: Bing Zhao Acked-by: Ori Kam Acked-by: Thomas Monjalon --- doc/guides/prog_guide/rte_flow.rst | 118 ++++++++++++++ doc/guides/rel_notes/release_21_05.rst | 4 + lib/librte_ethdev/rte_flow.c | 2 + lib/librte_ethdev/rte_flow.h | 212 +++++++++++++++++++++++++ 4 files changed, 336 insertions(+) diff --git a/doc/guides/prog_guide/rte_flow.rst b/doc/guides/prog_guide/rte_flow.rst index 4b54588995..5f6129f799 100644 --- a/doc/guides/prog_guide/rte_flow.rst +++ b/doc/guides/prog_guide/rte_flow.rst @@ -1398,6 +1398,14 @@ Matches a eCPRI header. - ``hdr``: eCPRI header definition (``rte_ecpri.h``). - Default ``mask`` matches nothing, for all eCPRI messages. +Item: ``CONNTRACK`` +^^^^^^^^^^^^^^^^^^^ + +Matches a conntrack state after conntrack action. + +- ``flags``: conntrack packet state flags. +- Default ``mask`` matches all state bits. + Actions ~~~~~~~ @@ -2842,6 +2850,116 @@ for ``RTE_FLOW_FIELD_VALUE`` and ``RTE_FLOW_FIELD_POINTER`` respectively. | ``value`` | immediate value or a pointer to this value | +---------------+----------------------------------------------------------+ +Action: ``CONNTRACK`` +^^^^^^^^^^^^^^^^^^^^^ + +Create a conntrack (connection tracking) context with the provided information. + +In stateful session like TCP, the conntrack action provides the ability to +examine every packet of this connection and associate the state to every +packet. It will help to realize the stateful offload of connections with little +software participation. For example, the packets with invalid state may be +handled by the software. The control packets could be handled in the hardware. +The software just need to query the state of a connection when needed, and then +decide how to handle the flow rules and conntrack context. + +A conntrack context should be created via ``rte_flow_action_handle_create()`` +before using. Then the handle with ``INDIRECT`` type is used for a flow rule +creation. If a flow rule with an opposite direction needs to be created, the +``rte_flow_action_handle_update()`` should be used to modify the direction. + +Not all the fields of the ``struct rte_flow_action_conntrack`` will be used +for a conntrack context creating, depending on the HW, and they should be +in host byte order. PMD should convert them into network byte order when +needed by the HW. + +The ``struct rte_flow_modify_conntrack`` should be used for an updating. + +The current conntrack context information could be queried via the +``rte_flow_action_handle_query()`` interface. + +.. _table_rte_flow_action_conntrack: + +.. table:: CONNTRACK + + +--------------------------+-------------------------------------------------------------+ + | Field | Value | + +==========================+=============================================================+ + | ``peer_port`` | peer port number | + +--------------------------+-------------------------------------------------------------+ + | ``is_original_dir`` | direction of this connection for creating flow rule | + +--------------------------+-------------------------------------------------------------+ + | ``enable`` | enable the conntrack context | + +--------------------------+-------------------------------------------------------------+ + | ``live_connection`` | one ack was seen for this connection | + +--------------------------+-------------------------------------------------------------+ + | ``selective_ack`` | SACK enabled | + +--------------------------+-------------------------------------------------------------+ + | ``challenge_ack_passed`` | a challenge ack has passed | + +--------------------------+-------------------------------------------------------------+ + | ``last_direction`` | direction of the last passed packet | + +--------------------------+-------------------------------------------------------------+ + | ``liberal_mode`` | only report state change | + +--------------------------+-------------------------------------------------------------+ + | ``state`` | current state | + +--------------------------+-------------------------------------------------------------+ + | ``max_ack_window`` | maximal window scaling factor | + +--------------------------+-------------------------------------------------------------+ + | ``retransmission_limit`` | maximal retransmission times | + +--------------------------+-------------------------------------------------------------+ + | ``original_dir`` | TCP parameters of the original direction | + +--------------------------+-------------------------------------------------------------+ + | ``reply_dir`` | TCP parameters of the reply direction | + +--------------------------+-------------------------------------------------------------+ + | ``last_window`` | window size of the last passed packet | + +--------------------------+-------------------------------------------------------------+ + | ``last_seq`` | sequence number of the last passed packet | + +--------------------------+-------------------------------------------------------------+ + | ``last_ack`` | acknowledgment number the last passed packet | + +--------------------------+-------------------------------------------------------------+ + | ``last_end`` | sum of ack number and length of the last passed packet | + +--------------------------+-------------------------------------------------------------+ + +.. _table_rte_flow_tcp_dir_param: + +.. table:: configuration parameters for each direction + + +---------------------+---------------------------------------------------------+ + | Field | Value | + +=====================+=========================================================+ + | ``scale`` | TCP window scaling factor | + +---------------------+---------------------------------------------------------+ + | ``close_initiated`` | FIN sent from this direction | + +---------------------+---------------------------------------------------------+ + | ``last_ack_seen`` | an ACK packet received | + +---------------------+---------------------------------------------------------+ + | ``data_unacked`` | unacknowledged data for packets from this direction | + +---------------------+---------------------------------------------------------+ + | ``sent_end`` | max{seq + len} seen in sent packets | + +---------------------+---------------------------------------------------------+ + | ``reply_end`` | max{sack + max{win, 1}} seen in reply packets | + +---------------------+---------------------------------------------------------+ + | ``max_win`` | max{max{win, 1}} + {sack - ack} seen in sent packets | + +---------------------+---------------------------------------------------------+ + | ``max_ack`` | max{ack} + seen in sent packets | + +---------------------+---------------------------------------------------------+ + +.. _table_rte_flow_modify_conntrack: + +.. table:: update a conntrack context + + +----------------+-------------------------------------------------+ + | Field | Value | + +================+=================================================+ + | ``new_ct`` | new conntrack information | + +----------------+-------------------------------------------------+ + | ``direction`` | direction will be updated | + +----------------+-------------------------------------------------+ + | ``state`` | other fields except direction will be updated | + +----------------+-------------------------------------------------+ + | ``reserved`` | reserved bits | + +----------------+-------------------------------------------------+ + Negative types ~~~~~~~~~~~~~~ diff --git a/doc/guides/rel_notes/release_21_05.rst b/doc/guides/rel_notes/release_21_05.rst index 8913dd4f9c..a5e2a8e503 100644 --- a/doc/guides/rel_notes/release_21_05.rst +++ b/doc/guides/rel_notes/release_21_05.rst @@ -87,6 +87,10 @@ New Features to support metering traffic by packet per second (PPS), in addition to the initial bytes per second (BPS) mode (value 0). +* **Added TCP connection tracking offload in flow API.** + + * Added conntrack item and action for stateful connection offload. + * **Updated Arkville PMD driver.** Updated Arkville net driver with new features and improvements, including: diff --git a/lib/librte_ethdev/rte_flow.c b/lib/librte_ethdev/rte_flow.c index 0d2610b7c4..c7c7108933 100644 --- a/lib/librte_ethdev/rte_flow.c +++ b/lib/librte_ethdev/rte_flow.c @@ -98,6 +98,7 @@ static const struct rte_flow_desc_data rte_flow_desc_item[] = { MK_FLOW_ITEM(PFCP, sizeof(struct rte_flow_item_pfcp)), MK_FLOW_ITEM(ECPRI, sizeof(struct rte_flow_item_ecpri)), MK_FLOW_ITEM(GENEVE_OPT, sizeof(struct rte_flow_item_geneve_opt)), + MK_FLOW_ITEM(CONNTRACK, sizeof(uint32_t)), }; /** Generate flow_action[] entry. */ @@ -186,6 +187,7 @@ static const struct rte_flow_desc_data rte_flow_desc_action[] = { * indirect action handle. */ MK_FLOW_ACTION(INDIRECT, 0), + MK_FLOW_ACTION(CONNTRACK, sizeof(struct rte_flow_action_conntrack)), }; int diff --git a/lib/librte_ethdev/rte_flow.h b/lib/librte_ethdev/rte_flow.h index 0447d36002..dae16b3433 100644 --- a/lib/librte_ethdev/rte_flow.h +++ b/lib/librte_ethdev/rte_flow.h @@ -30,6 +30,7 @@ #include #include #include +#include #include #include @@ -551,6 +552,15 @@ enum rte_flow_item_type { * See struct rte_flow_item_geneve_opt */ RTE_FLOW_ITEM_TYPE_GENEVE_OPT, + + /** + * [META] + * + * Matches conntrack state. + * + * @see struct rte_flow_item_conntrack. + */ + RTE_FLOW_ITEM_TYPE_CONNTRACK, }; /** @@ -1685,6 +1695,51 @@ rte_flow_item_geneve_opt_mask = { }; #endif +/** + * The packet is valid after conntrack checking. + */ +#define RTE_FLOW_CONNTRACK_PKT_STATE_VALID RTE_BIT32(0) +/** + * The state of the connection is changed. + */ +#define RTE_FLOW_CONNTRACK_PKT_STATE_CHANGED RTE_BIT32(1) +/** + * Error is detected on this packet for this connection and + * an invalid state is set. + */ +#define RTE_FLOW_CONNTRACK_PKT_STATE_INVALID RTE_BIT32(2) +/** + * The HW connection tracking module is disabled. + * It can be due to application command or an invalid state. + */ +#define RTE_FLOW_CONNTRACK_PKT_STATE_DISABLED RTE_BIT32(3) +/** + * The packet contains some bad field(s) and cannot continue + * with the conntrack module checking. + */ +#define RTE_FLOW_CONNTRACK_PKT_STATE_BAD RTE_BIT32(4) + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ITEM_TYPE_CONNTRACK + * + * Matches the state of a packet after it passed the connection tracking + * examination. The state is a bitmap of one RTE_FLOW_CONNTRACK_PKT_STATE* + * or a reasonable combination of these bits. + */ +struct rte_flow_item_conntrack { + uint32_t flags; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_CONNTRACK. */ +#ifndef __cplusplus +static const struct rte_flow_item_conntrack rte_flow_item_conntrack_mask = { + .flags = 0xffffffff, +}; +#endif + /** * Matching pattern item definition. * @@ -2278,6 +2333,15 @@ enum rte_flow_action_type { * or different ethdev ports. */ RTE_FLOW_ACTION_TYPE_INDIRECT, + + /** + * [META] + * + * Enable tracking a TCP connection state. + * + * @see struct rte_flow_action_conntrack. + */ + RTE_FLOW_ACTION_TYPE_CONNTRACK, }; /** @@ -2876,6 +2940,154 @@ struct rte_flow_action_set_dscp { */ struct rte_flow_action_handle; +/** + * The state of a TCP connection. + */ +enum rte_flow_conntrack_state { + /** SYN-ACK packet was seen. */ + RTE_FLOW_CONNTRACK_STATE_SYN_RECV, + /** 3-way handshake was done. */ + RTE_FLOW_CONNTRACK_STATE_ESTABLISHED, + /** First FIN packet was received to close the connection. */ + RTE_FLOW_CONNTRACK_STATE_FIN_WAIT, + /** First FIN was ACKed. */ + RTE_FLOW_CONNTRACK_STATE_CLOSE_WAIT, + /** Second FIN was received, waiting for the last ACK. */ + RTE_FLOW_CONNTRACK_STATE_LAST_ACK, + /** Second FIN was ACKed, connection was closed. */ + RTE_FLOW_CONNTRACK_STATE_TIME_WAIT, +}; + +/** + * The last passed TCP packet flags of a connection. + */ +enum rte_flow_conntrack_tcp_last_index { + RTE_FLOW_CONNTRACK_FLAG_NONE = 0, /**< No Flag. */ + RTE_FLOW_CONNTRACK_FLAG_SYN = RTE_BIT32(0), /**< With SYN flag. */ + RTE_FLOW_CONNTRACK_FLAG_SYNACK = RTE_BIT32(1), /**< With SYNACK flag. */ + RTE_FLOW_CONNTRACK_FLAG_FIN = RTE_BIT32(2), /**< With FIN flag. */ + RTE_FLOW_CONNTRACK_FLAG_ACK = RTE_BIT32(3), /**< With ACK flag. */ + RTE_FLOW_CONNTRACK_FLAG_RST = RTE_BIT32(4), /**< With RST flag. */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * Configuration parameters for each direction of a TCP connection. + * All fields should be in host byte order. + * If needed, driver should convert all fields to network byte order + * if HW needs them in that way. + */ +struct rte_flow_tcp_dir_param { + /** TCP window scaling factor, 0xF to disable. */ + uint32_t scale:4; + /** The FIN was sent by this direction. */ + uint32_t close_initiated:1; + /** An ACK packet has been received by this side. */ + uint32_t last_ack_seen:1; + /** + * If set, it indicates that there is unacknowledged data for the + * packets sent from this direction. + */ + uint32_t data_unacked:1; + /** + * Maximal value of sequence + payload length in sent + * packets (next ACK from the opposite direction). + */ + uint32_t sent_end; + /** + * Maximal value of (ACK + window size) in received packet + length + * over sent packet (maximal sequence could be sent). + */ + uint32_t reply_end; + /** Maximal value of actual window size in sent packets. */ + uint32_t max_win; + /** Maximal value of ACK in sent packets. */ + uint32_t max_ack; +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_CONNTRACK + * + * Configuration and initial state for the connection tracking module. + * This structure could be used for both setting and query. + * All fields should be in host byte order. + */ +struct rte_flow_action_conntrack { + /** The peer port number, can be the same port. */ + uint16_t peer_port; + /** + * Direction of this connection when creating a flow rule, the + * value only affects the creation of subsequent flow rules. + */ + uint32_t is_original_dir:1; + /** + * Enable / disable the conntrack HW module. When disabled, the + * result will always be RTE_FLOW_CONNTRACK_FLAG_DISABLED. + * In this state the HW will act as passthrough. + * It only affects this conntrack object in the HW without any effect + * to the other objects. + */ + uint32_t enable:1; + /** At least one ack was seen after the connection was established. */ + uint32_t live_connection:1; + /** Enable selective ACK on this connection. */ + uint32_t selective_ack:1; + /** A challenge ack has passed. */ + uint32_t challenge_ack_passed:1; + /** + * 1: The last packet is seen from the original direction. + * 0: The last packet is seen from the reply direction. + */ + uint32_t last_direction:1; + /** No TCP check will be done except the state change. */ + uint32_t liberal_mode:1; + /** X-Patchwork-Id: 91783 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 3DD79A0524; Mon, 19 Apr 2021 19:51:51 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id D1FD741435; Mon, 19 Apr 2021 19:51:46 +0200 (CEST) Received: from mellanox.co.il (mail-il-dmz.mellanox.com [193.47.165.129]) by mails.dpdk.org (Postfix) with ESMTP id 5C2394142F for ; Mon, 19 Apr 2021 19:51:44 +0200 (CEST) Received: from Internal Mail-Server by MTLPINE1 (envelope-from bingz@nvidia.com) with SMTP; 19 Apr 2021 20:51:42 +0300 Received: from nvidia.com (mtbc-r640-01.mtbc.labs.mlnx [10.75.70.6]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id 13JHpZVg007797; Mon, 19 Apr 2021 20:51:41 +0300 From: Bing Zhao To: orika@nvidia.com, thomas@monjalon.net, ferruh.yigit@intel.com, andrew.rybchenko@oktetlabs.ru Cc: dev@dpdk.org, ajit.khaparde@broadcom.com, xiaoyun.li@intel.com Date: Tue, 20 Apr 2021 01:51:31 +0800 Message-Id: <1618854691-370765-3-git-send-email-bingz@nvidia.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1618854691-370765-1-git-send-email-bingz@nvidia.com> References: <1618062393-205611-1-git-send-email-bingz@nvidia.com> <1618854691-370765-1-git-send-email-bingz@nvidia.com> Subject: [dpdk-dev] [PATCH v5 2/2] app/testpmd: add CLI for conntrack 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 Sender: "dev" The command line for testing connection tracking is added. To create a conntrack object, 3 parts are needed. set conntrack com peer ... set conntrack orig scale ... set conntrack rply scale ... This will create a full conntrack action structure for the indirect action. After the indirect action handle of "conntrack" created, it could be used in the flow creation. Before updating, the same structure is also needed together with the update command "conntrack_update" to update the "dir" or "ctx". After the flow with conntrack action created, the packet should jump to the next flow for the result checking with conntrack item. The state is defined with bits and a valid combination could be supported. Signed-off-by: Bing Zhao Acked-by: Ori Kam --- app/test-pmd/cmdline.c | 355 ++++++++++++++++++++ app/test-pmd/cmdline_flow.c | 92 +++++ app/test-pmd/config.c | 65 +++- app/test-pmd/testpmd.h | 2 + doc/guides/rel_notes/release_21_05.rst | 3 + doc/guides/testpmd_app_ug/testpmd_funcs.rst | 35 ++ 6 files changed, 551 insertions(+), 1 deletion(-) diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 4d9e038ce8..d282c7cad6 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -13621,6 +13621,359 @@ cmdline_parse_inst_t cmd_set_mplsoudp_decap_with_vlan = { }, }; +/** Set connection tracking object common details */ +struct cmd_set_conntrack_common_result { + cmdline_fixed_string_t set; + cmdline_fixed_string_t conntrack; + cmdline_fixed_string_t common; + cmdline_fixed_string_t peer; + cmdline_fixed_string_t is_orig; + cmdline_fixed_string_t enable; + cmdline_fixed_string_t live; + cmdline_fixed_string_t sack; + cmdline_fixed_string_t cack; + cmdline_fixed_string_t last_dir; + cmdline_fixed_string_t liberal; + cmdline_fixed_string_t state; + cmdline_fixed_string_t max_ack_win; + cmdline_fixed_string_t retrans; + cmdline_fixed_string_t last_win; + cmdline_fixed_string_t last_seq; + cmdline_fixed_string_t last_ack; + cmdline_fixed_string_t last_end; + cmdline_fixed_string_t last_index; + uint8_t stat; + uint8_t factor; + uint16_t peer_port; + uint32_t is_original; + uint32_t en; + uint32_t is_live; + uint32_t s_ack; + uint32_t c_ack; + uint32_t ld; + uint32_t lb; + uint8_t re_num; + uint8_t li; + uint16_t lw; + uint32_t ls; + uint32_t la; + uint32_t le; +}; + +cmdline_parse_token_string_t cmd_set_conntrack_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + set, "set"); +cmdline_parse_token_string_t cmd_set_conntrack_conntrack = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + conntrack, "conntrack"); +cmdline_parse_token_string_t cmd_set_conntrack_common_com = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + common, "com"); +cmdline_parse_token_string_t cmd_set_conntrack_common_peer = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + peer, "peer"); +cmdline_parse_token_num_t cmd_set_conntrack_common_peer_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + peer_port, RTE_UINT16); +cmdline_parse_token_string_t cmd_set_conntrack_common_is_orig = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + is_orig, "is_orig"); +cmdline_parse_token_num_t cmd_set_conntrack_common_is_orig_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + is_original, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_enable = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + enable, "enable"); +cmdline_parse_token_num_t cmd_set_conntrack_common_enable_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + en, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_live = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + live, "live"); +cmdline_parse_token_num_t cmd_set_conntrack_common_live_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + is_live, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_sack = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + sack, "sack"); +cmdline_parse_token_num_t cmd_set_conntrack_common_sack_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + s_ack, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_cack = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + cack, "cack"); +cmdline_parse_token_num_t cmd_set_conntrack_common_cack_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + c_ack, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_last_dir = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + last_dir, "last_dir"); +cmdline_parse_token_num_t cmd_set_conntrack_common_last_dir_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + ld, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_liberal = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + liberal, "liberal"); +cmdline_parse_token_num_t cmd_set_conntrack_common_liberal_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + lb, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_state = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + state, "state"); +cmdline_parse_token_num_t cmd_set_conntrack_common_state_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + stat, RTE_UINT8); +cmdline_parse_token_string_t cmd_set_conntrack_common_max_ackwin = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + max_ack_win, "max_ack_win"); +cmdline_parse_token_num_t cmd_set_conntrack_common_max_ackwin_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + factor, RTE_UINT8); +cmdline_parse_token_string_t cmd_set_conntrack_common_retrans = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + retrans, "r_lim"); +cmdline_parse_token_num_t cmd_set_conntrack_common_retrans_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + re_num, RTE_UINT8); +cmdline_parse_token_string_t cmd_set_conntrack_common_last_win = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + last_win, "last_win"); +cmdline_parse_token_num_t cmd_set_conntrack_common_last_win_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + lw, RTE_UINT16); +cmdline_parse_token_string_t cmd_set_conntrack_common_last_seq = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + last_seq, "last_seq"); +cmdline_parse_token_num_t cmd_set_conntrack_common_last_seq_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + ls, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_last_ack = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + last_ack, "last_ack"); +cmdline_parse_token_num_t cmd_set_conntrack_common_last_ack_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + la, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_last_end = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + last_end, "last_end"); +cmdline_parse_token_num_t cmd_set_conntrack_common_last_end_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + le, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_common_last_index = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result, + last_index, "last_index"); +cmdline_parse_token_num_t cmd_set_conntrack_common_last_index_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result, + li, RTE_UINT8); + +static void cmd_set_conntrack_common_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_conntrack_common_result *res = parsed_result; + + /* No need to swap to big endian. */ + conntrack_context.peer_port = res->peer_port; + conntrack_context.is_original_dir = res->is_original; + conntrack_context.enable = res->en; + conntrack_context.live_connection = res->is_live; + conntrack_context.selective_ack = res->s_ack; + conntrack_context.challenge_ack_passed = res->c_ack; + conntrack_context.last_direction = res->ld; + conntrack_context.liberal_mode = res->lb; + conntrack_context.state = (enum rte_flow_conntrack_state)res->stat; + conntrack_context.max_ack_window = res->factor; + conntrack_context.retransmission_limit = res->re_num; + conntrack_context.last_window = res->lw; + conntrack_context.last_index = + (enum rte_flow_conntrack_tcp_last_index)res->li; + conntrack_context.last_seq = res->ls; + conntrack_context.last_ack = res->la; + conntrack_context.last_end = res->le; +} + +cmdline_parse_inst_t cmd_set_conntrack_common = { + .f = cmd_set_conntrack_common_parsed, + .data = NULL, + .help_str = "set conntrack com peer is_orig enable " + " live sack cack last_dir " + " liberal state max_ack_win r_lim " + " last_win last_seq last_ack last_end " + " last_index ", + .tokens = { + (void *)&cmd_set_conntrack_set, + (void *)&cmd_set_conntrack_conntrack, + (void *)&cmd_set_conntrack_common_com, + (void *)&cmd_set_conntrack_common_peer, + (void *)&cmd_set_conntrack_common_peer_value, + (void *)&cmd_set_conntrack_common_is_orig, + (void *)&cmd_set_conntrack_common_is_orig_value, + (void *)&cmd_set_conntrack_common_enable, + (void *)&cmd_set_conntrack_common_enable_value, + (void *)&cmd_set_conntrack_common_live, + (void *)&cmd_set_conntrack_common_live_value, + (void *)&cmd_set_conntrack_common_sack, + (void *)&cmd_set_conntrack_common_sack_value, + (void *)&cmd_set_conntrack_common_cack, + (void *)&cmd_set_conntrack_common_cack_value, + (void *)&cmd_set_conntrack_common_last_dir, + (void *)&cmd_set_conntrack_common_last_dir_value, + (void *)&cmd_set_conntrack_common_liberal, + (void *)&cmd_set_conntrack_common_liberal_value, + (void *)&cmd_set_conntrack_common_state, + (void *)&cmd_set_conntrack_common_state_value, + (void *)&cmd_set_conntrack_common_max_ackwin, + (void *)&cmd_set_conntrack_common_max_ackwin_value, + (void *)&cmd_set_conntrack_common_retrans, + (void *)&cmd_set_conntrack_common_retrans_value, + (void *)&cmd_set_conntrack_common_last_win, + (void *)&cmd_set_conntrack_common_last_win_value, + (void *)&cmd_set_conntrack_common_last_seq, + (void *)&cmd_set_conntrack_common_last_seq_value, + (void *)&cmd_set_conntrack_common_last_ack, + (void *)&cmd_set_conntrack_common_last_ack_value, + (void *)&cmd_set_conntrack_common_last_end, + (void *)&cmd_set_conntrack_common_last_end_value, + (void *)&cmd_set_conntrack_common_last_index, + (void *)&cmd_set_conntrack_common_last_index_value, + NULL, + }, +}; + +/** Set connection tracking object both directions' details */ +struct cmd_set_conntrack_dir_result { + cmdline_fixed_string_t set; + cmdline_fixed_string_t conntrack; + cmdline_fixed_string_t dir; + cmdline_fixed_string_t scale; + cmdline_fixed_string_t fin; + cmdline_fixed_string_t ack_seen; + cmdline_fixed_string_t unack; + cmdline_fixed_string_t sent_end; + cmdline_fixed_string_t reply_end; + cmdline_fixed_string_t max_win; + cmdline_fixed_string_t max_ack; + uint32_t factor; + uint32_t f; + uint32_t as; + uint32_t un; + uint32_t se; + uint32_t re; + uint32_t mw; + uint32_t ma; +}; + +cmdline_parse_token_string_t cmd_set_conntrack_dir_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + set, "set"); +cmdline_parse_token_string_t cmd_set_conntrack_dir_conntrack = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + conntrack, "conntrack"); +cmdline_parse_token_string_t cmd_set_conntrack_dir_dir = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + dir, "orig#rply"); +cmdline_parse_token_string_t cmd_set_conntrack_dir_scale = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + scale, "scale"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_scale_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + factor, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_dir_fin = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + fin, "fin"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_fin_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + f, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_dir_ack = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + ack_seen, "acked"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_ack_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + as, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_dir_unack_data = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + unack, "unack_data"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_unack_data_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + un, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_dir_sent_end = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + sent_end, "sent_end"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_sent_end_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + se, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_dir_reply_end = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + reply_end, "reply_end"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_reply_end_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + re, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_dir_max_win = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + max_win, "max_win"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_max_win_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + mw, RTE_UINT32); +cmdline_parse_token_string_t cmd_set_conntrack_dir_max_ack = + TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result, + max_ack, "max_ack"); +cmdline_parse_token_num_t cmd_set_conntrack_dir_max_ack_value = + TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result, + ma, RTE_UINT32); + +static void cmd_set_conntrack_dir_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_conntrack_dir_result *res = parsed_result; + struct rte_flow_tcp_dir_param *dir = NULL; + + if (strcmp(res->dir, "orig") == 0) + dir = &conntrack_context.original_dir; + else if (strcmp(res->dir, "rply") == 0) + dir = &conntrack_context.reply_dir; + else + return; + dir->scale = res->factor; + dir->close_initiated = res->f; + dir->last_ack_seen = res->as; + dir->data_unacked = res->un; + dir->sent_end = res->se; + dir->reply_end = res->re; + dir->max_ack = res->ma; + dir->max_win = res->mw; +} + +cmdline_parse_inst_t cmd_set_conntrack_dir = { + .f = cmd_set_conntrack_dir_parsed, + .data = NULL, + .help_str = "set conntrack orig|rply scale fin " + " acked unack_data sent_end " + " reply_end max_win max_ack ", + .tokens = { + (void *)&cmd_set_conntrack_set, + (void *)&cmd_set_conntrack_conntrack, + (void *)&cmd_set_conntrack_dir_dir, + (void *)&cmd_set_conntrack_dir_scale, + (void *)&cmd_set_conntrack_dir_scale_value, + (void *)&cmd_set_conntrack_dir_fin, + (void *)&cmd_set_conntrack_dir_fin_value, + (void *)&cmd_set_conntrack_dir_ack, + (void *)&cmd_set_conntrack_dir_ack_value, + (void *)&cmd_set_conntrack_dir_unack_data, + (void *)&cmd_set_conntrack_dir_unack_data_value, + (void *)&cmd_set_conntrack_dir_sent_end, + (void *)&cmd_set_conntrack_dir_sent_end_value, + (void *)&cmd_set_conntrack_dir_reply_end, + (void *)&cmd_set_conntrack_dir_reply_end_value, + (void *)&cmd_set_conntrack_dir_max_win, + (void *)&cmd_set_conntrack_dir_max_win_value, + (void *)&cmd_set_conntrack_dir_max_ack, + (void *)&cmd_set_conntrack_dir_max_ack_value, + NULL, + }, +}; + /* Strict link priority scheduling mode setting */ static void cmd_strict_link_prio_parsed( @@ -17120,6 +17473,8 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_set_mplsoudp_encap_with_vlan, (cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap, (cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap_with_vlan, + (cmdline_parse_inst_t *)&cmd_set_conntrack_common, + (cmdline_parse_inst_t *)&cmd_set_conntrack_dir, (cmdline_parse_inst_t *)&cmd_ddp_add, (cmdline_parse_inst_t *)&cmd_ddp_del, (cmdline_parse_inst_t *)&cmd_ddp_get_list, diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c index c5381c638b..e2b09cf16d 100644 --- a/app/test-pmd/cmdline_flow.c +++ b/app/test-pmd/cmdline_flow.c @@ -293,6 +293,7 @@ enum index { ITEM_GENEVE_OPT_TYPE, ITEM_GENEVE_OPT_LENGTH, ITEM_GENEVE_OPT_DATA, + ITEM_CONNTRACK, /* Validate/create actions. */ ACTIONS, @@ -431,6 +432,10 @@ enum index { ACTION_MODIFY_FIELD_SRC_OFFSET, ACTION_MODIFY_FIELD_SRC_VALUE, ACTION_MODIFY_FIELD_WIDTH, + ACTION_CONNTRACK, + ACTION_CONNTRACK_UPDATE, + ACTION_CONNTRACK_UPDATE_DIR, + ACTION_CONNTRACK_UPDATE_CTX, }; /** Maximum size for pattern in struct rte_flow_item_raw. */ @@ -569,6 +574,8 @@ struct mplsoudp_encap_conf mplsoudp_encap_conf; struct mplsoudp_decap_conf mplsoudp_decap_conf; +struct rte_flow_action_conntrack conntrack_context; + #define ACTION_SAMPLE_ACTIONS_NUM 10 #define RAW_SAMPLE_CONFS_MAX_NUM 8 /** Storage for struct rte_flow_action_sample including external data. */ @@ -968,6 +975,7 @@ static const enum index next_item[] = { ITEM_PFCP, ITEM_ECPRI, ITEM_GENEVE_OPT, + ITEM_CONNTRACK, END_SET, ZERO, }; @@ -1382,6 +1390,8 @@ static const enum index next_action[] = { ACTION_SAMPLE, ACTION_INDIRECT, ACTION_MODIFY_FIELD, + ACTION_CONNTRACK, + ACTION_CONNTRACK_UPDATE, ZERO, }; @@ -1650,6 +1660,13 @@ static const enum index action_modify_field_src[] = { ZERO, }; +static const enum index action_update_conntrack[] = { + ACTION_CONNTRACK_UPDATE_DIR, + ACTION_CONNTRACK_UPDATE_CTX, + ACTION_NEXT, + ZERO, +}; + static int parse_set_raw_encap_decap(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -1740,6 +1757,10 @@ static int parse_vc_modify_field_id(struct context *ctx, const struct token *token, const char *str, unsigned int len, void *buf, unsigned int size); +static int +parse_vc_action_conntrack_update(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size); static int parse_destroy(struct context *, const struct token *, const char *, unsigned int, void *, unsigned int); @@ -3400,6 +3421,13 @@ static const struct token token_list[] = { (sizeof(struct rte_flow_item_geneve_opt), ITEM_GENEVE_OPT_DATA_SIZE)), }, + [ITEM_CONNTRACK] = { + .name = "conntrack", + .help = "conntrack state", + .next = NEXT(NEXT_ENTRY(ITEM_NEXT), NEXT_ENTRY(UNSIGNED), + item_param), + .args = ARGS(ARGS_ENTRY(struct rte_flow_item_conntrack, flags)), + }, /* Validate/create actions. */ [ACTIONS] = { .name = "actions", @@ -4498,6 +4526,34 @@ static const struct token token_list[] = { .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, + }, /* Indirect action destroy arguments. */ [INDIRECT_ACTION_DESTROY_ID] = { .name = "action_id", @@ -6304,6 +6360,42 @@ parse_vc_modify_field_id(struct context *ctx, const struct token *token, return len; } +/** Parse the conntrack update, not a rte_flow_action. */ +static int +parse_vc_action_conntrack_update(struct context *ctx, const struct token *token, + const char *str, unsigned int len, void *buf, + unsigned int size) +{ + struct buffer *out = buf; + struct rte_flow_modify_conntrack *ct_modify = NULL; + + (void)size; + if (ctx->curr != ACTION_CONNTRACK_UPDATE_CTX && + ctx->curr != ACTION_CONNTRACK_UPDATE_DIR) + return -1; + /* Token name must match. */ + if (parse_default(ctx, token, str, len, NULL, 0) < 0) + return -1; + ct_modify = (struct rte_flow_modify_conntrack *)out->args.vc.data; + /* Nothing else to do if there is no buffer. */ + if (!out) + return len; + 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, diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c index 868ff3469b..787d45afbd 100644 --- a/app/test-pmd/config.c +++ b/app/test-pmd/config.c @@ -1483,6 +1483,11 @@ port_action_handle_create(portid_t port_id, uint32_t id, pia->age_type = ACTION_AGE_CONTEXT_TYPE_INDIRECT_ACTION; age->context = &pia->age_type; + } else if (action->type == RTE_FLOW_ACTION_TYPE_CONNTRACK) { + struct rte_flow_action_conntrack *ct = + (struct rte_flow_action_conntrack *)(uintptr_t)(action->conf); + + memcpy(ct, &conntrack_context, sizeof(*ct)); } /* Poisoning to make sure PMDs update it in case of error. */ memset(&error, 0x22, sizeof(error)); @@ -1564,11 +1569,24 @@ port_action_handle_update(portid_t port_id, uint32_t id, { struct rte_flow_error error; struct rte_flow_action_handle *action_handle; + struct port_indirect_action *pia; + const void *update; action_handle = port_action_handle_get_by_id(port_id, id); if (!action_handle) return -EINVAL; - if (rte_flow_action_handle_update(port_id, action_handle, action, + pia = action_get_by_id(port_id, id); + if (!pia) + return -EINVAL; + switch (pia->type) { + case RTE_FLOW_ACTION_TYPE_CONNTRACK: + update = action->conf; + break; + default: + update = action; + break; + } + if (rte_flow_action_handle_update(port_id, action_handle, update, &error)) { return port_flow_complain(&error); } @@ -1621,6 +1639,51 @@ port_action_handle_query(portid_t port_id, uint32_t id) } data = NULL; break; + case RTE_FLOW_ACTION_TYPE_CONNTRACK: + if (!ret) { + struct rte_flow_action_conntrack *ct = data; + + printf("Conntrack Context:\n" + " Peer: %u, Flow dir: %s, Enable: %u\n" + " Live: %u, SACK: %u, CACK: %u\n" + " Packet dir: %s, Liberal: %u, State: %u\n" + " Factor: %u, Retrans: %u, TCP flags: %u\n" + " Last Seq: %u, Last ACK: %u\n" + " Last Win: %u, Last End: %u\n", + ct->peer_port, + ct->is_original_dir ? "Original" : "Reply", + ct->enable, ct->live_connection, + ct->selective_ack, ct->challenge_ack_passed, + ct->last_direction ? "Original" : "Reply", + ct->liberal_mode, ct->state, + ct->max_ack_window, ct->retransmission_limit, + ct->last_index, ct->last_seq, ct->last_ack, + ct->last_window, ct->last_end); + printf(" Original Dir:\n" + " scale: %u, fin: %u, ack seen: %u\n" + " unacked data: %u\n Sent end: %u," + " Reply end: %u, Max win: %u, Max ACK: %u\n", + ct->original_dir.scale, + ct->original_dir.close_initiated, + ct->original_dir.last_ack_seen, + ct->original_dir.data_unacked, + ct->original_dir.sent_end, + ct->original_dir.reply_end, + ct->original_dir.max_win, + ct->original_dir.max_ack); + printf(" Reply Dir:\n" + " scale: %u, fin: %u, ack seen: %u\n" + " unacked data: %u\n Sent end: %u," + " Reply end: %u, Max win: %u, Max ACK: %u\n", + ct->reply_dir.scale, + ct->reply_dir.close_initiated, + ct->reply_dir.last_ack_seen, + ct->reply_dir.data_unacked, + ct->reply_dir.sent_end, ct->reply_dir.reply_end, + ct->reply_dir.max_win, ct->reply_dir.max_ack); + } + data = NULL; + break; default: printf("Indirect action %u (type: %d) on port %u doesn't" " support query\n", id, pia->type, port_id); diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h index c314b30f2e..9530ec5fe0 100644 --- a/app/test-pmd/testpmd.h +++ b/app/test-pmd/testpmd.h @@ -630,6 +630,8 @@ extern struct mplsoudp_decap_conf mplsoudp_decap_conf; extern enum rte_eth_rx_mq_mode rx_mq_mode; +extern struct rte_flow_action_conntrack conntrack_context; + static inline unsigned int lcore_num(void) { diff --git a/doc/guides/rel_notes/release_21_05.rst b/doc/guides/rel_notes/release_21_05.rst index a5e2a8e503..d06ddb2074 100644 --- a/doc/guides/rel_notes/release_21_05.rst +++ b/doc/guides/rel_notes/release_21_05.rst @@ -215,6 +215,9 @@ New Features ``show port (port_id) rxq (queue_id) desc used count`` * Added command to dump internal representation information of single flow. ``flow dump (port_id) rule (rule_id)`` + * Added commands to construct conntrack context and relevant indirect + action handle creation, update for conntrack action as well as conntrack + item matching. * **Updated ipsec-secgw sample application.** diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst index 715e209fd2..efa32bb6ad 100644 --- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst +++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst @@ -3789,6 +3789,8 @@ This section lists supported pattern items and their attributes, if any. - ``s_field {unsigned}``: S field. - ``seid {unsigned}``: session endpoint identifier. +- ``conntrack``: match conntrack state. + Actions list ^^^^^^^^^^^^ @@ -4927,6 +4929,39 @@ NVGRE encapsulation header and sent to port id 0. testpmd> flow create 0 ingress transfer pattern eth / end actions sample ratio 1 index 0 / port_id id 2 / end +Sample conntrack rules +~~~~~~~~~~~~~~~~~~~~~~ + +Conntrack rules can be set by the following commands + +Need to construct the connection context with provided information. +In the first table, create a flow rule by using conntrack action and jump to +the next table. In the next table, create a rule to check the state. + +:: + + testpmd> set conntrack com peer 1 is_orig 1 enable 1 live 1 sack 1 cack 0 + last_dir 0 liberal 0 state 1 max_ack_win 7 r_lim 5 last_win 510 + last_seq 2632987379 last_ack 2532480967 last_end 2632987379 + last_index 0x8 + testpmd> set conntrack orig scale 7 fin 0 acked 1 unack_data 0 + sent_end 2632987379 reply_end 2633016339 max_win 28960 + max_ack 2632987379 + testpmd> set conntrack rply scale 7 fin 0 acked 1 unack_data 0 + sent_end 2532480967 reply_end 2532546247 max_win 65280 + max_ack 2532480967 + testpmd> flow indirect_action 0 create ingress action conntrack / end + testpmd> flow create 0 group 3 ingress pattern eth / ipv4 / tcp / end actions indirect 0 / jump group 5 / end + testpmd> flow create 0 group 5 ingress pattern eth / ipv4 / tcp / conntrack is 1 / end actions queue index 5 / end + +Construct the conntrack again with only "is_orig" set to 0 (other fields are +ignored), then use "update" interface to update the direction. Create flow +rules like above for the peer port. + +:: + + testpmd> flow indirect_action 0 update 0 action conntrack_update dir / end + BPF Functions --------------