From patchwork Thu Aug 4 13:44:25 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 114617 X-Patchwork-Delegate: andrew.rybchenko@oktetlabs.ru 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 9BF51A00C4; Thu, 4 Aug 2022 15:48:17 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 8D19742BE0; Thu, 4 Aug 2022 15:48:17 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 67BDB42BDB for ; Thu, 4 Aug 2022 15:48:15 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 274DK71p022469; Thu, 4 Aug 2022 06:45:56 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=86dMi328c1wORskrYYSXAZaImGrs680u3pBERDwspJo=; b=T3hd2IWzHsgN4pFKAyeMI+Tod7hdVBNxkD1GASuaEjLbpy49WQA/6EXYyTsECy5gv+vc AJLVBIay2HzQESU8E03lbfom0/bLt7gH3fa+Ztso0Fp/U9JSu2vegwCF678jtIeoLw4H VaJOTAx4cXZzxKjfUS8rxQWc/6ru1HwoIOoZoxQHSmW+Zs4Ugpm3dKd+uYbF7//zm4bQ FaH2DYyUrMeHn+lIs9x8jV8zV9MIzmk6Fn2tkSTfJZS72uvgTH1c0wN0tBL0UgDwWAaU 9xgIkz1cjlw+WuWXZf5Xp4fj9GFuEXfFcCuysr6KhUWb0WB4+fvd9HlxLK+nfw+0OPux 2Q== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3hqgf1xr24-3 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 04 Aug 2022 06:45:56 -0700 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Thu, 4 Aug 2022 06:45:52 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 4 Aug 2022 06:45:52 -0700 Received: from hyd1349.t110.caveonetworks.com.com (unknown [10.29.45.13]) by maili.marvell.com (Postfix) with ESMTP id 654783F7057; Thu, 4 Aug 2022 06:45:30 -0700 (PDT) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH 1/6] ethdev: add trace points Date: Thu, 4 Aug 2022 19:14:25 +0530 Message-ID: <20220804134430.6192-2-adwivedi@marvell.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20220804134430.6192-1-adwivedi@marvell.com> References: <20220804134430.6192-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: otxNh5ddflM8-Y0RLStbzFOEcMm6tKaK X-Proofpoint-ORIG-GUID: otxNh5ddflM8-Y0RLStbzFOEcMm6tKaK X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-04_03,2022-08-04_02,2022-06-22_01 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 Add trace points for ethdev functions. Signed-off-by: Ankur Dwivedi --- lib/ethdev/ethdev_private.c | 5 + lib/ethdev/ethdev_trace_points.c | 438 +++++++++++ lib/ethdev/rte_ethdev.c | 150 ++++ lib/ethdev/rte_ethdev_trace.h | 1182 ++++++++++++++++++++++++++++++ lib/ethdev/version.map | 147 ++++ 5 files changed, 1922 insertions(+) diff --git a/lib/ethdev/ethdev_private.c b/lib/ethdev/ethdev_private.c index 48090c879a..e483145816 100644 --- a/lib/ethdev/ethdev_private.c +++ b/lib/ethdev/ethdev_private.c @@ -5,6 +5,7 @@ #include #include "rte_ethdev.h" +#include "rte_ethdev_trace.h" #include "ethdev_driver.h" #include "ethdev_private.h" @@ -291,6 +292,8 @@ rte_eth_call_rx_callbacks(uint16_t port_id, uint16_t queue_id, { const struct rte_eth_rxtx_callback *cb = opaque; + rte_eth_trace_call_rx_callbacks(port_id, queue_id, rx_pkts, nb_rx, + nb_pkts, opaque); while (cb != NULL) { nb_rx = cb->fn.rx(port_id, queue_id, rx_pkts, nb_rx, nb_pkts, cb->param); @@ -306,6 +309,8 @@ rte_eth_call_tx_callbacks(uint16_t port_id, uint16_t queue_id, { const struct rte_eth_rxtx_callback *cb = opaque; + rte_eth_trace_call_tx_callbacks(port_id, queue_id, tx_pkts, nb_pkts, + opaque); while (cb != NULL) { nb_pkts = cb->fn.tx(port_id, queue_id, tx_pkts, nb_pkts, cb->param); diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index 2919409a15..2e80401771 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -29,3 +29,441 @@ RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_burst, RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_tx_burst, lib.ethdev.tx.burst) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_add_first_rx_callback, + lib.ethdev.add_first_rx_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_add_rx_callback, + lib.ethdev.add_rx_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_add_tx_callback, + lib.ethdev.add_tx_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_allmulticast_disable, + lib.ethdev.allmulticast_disable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_allmulticast_enable, + lib.ethdev.allmulticast_enable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_allmulticast_get, + lib.ethdev.allmulticast_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_call_rx_callbacks, + lib.ethdev.call_rx_callbacks) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_call_tx_callbacks, + lib.ethdev.call_tx_callbacks) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_mtu, + lib.ethdev.set_mtu) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_adjust_nb_rx_tx_desc, + lib.ethdev.adjust_nb_rx_tx_desc) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_callback_register, + lib.ethdev.callback_register) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_callback_unregister, + lib.ethdev.callback_unregister) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_default_mac_addr_set, + lib.ethdev.default_mac_addr_set) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_flow_ctrl_get, + lib.ethdev.flow_ctrl_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_flow_ctrl_set, + lib.ethdev.flow_ctrl_set) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_fw_version_get, + lib.ethdev.fw_version_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_dcb_info, + lib.ethdev.get_dcb_info) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_eeprom, + lib.ethdev.get_eeprom) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_eeprom_length, + lib.ethdev.get_eeprom_length) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_mtu, + lib.ethdev.get_mtu) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_count_avail, + lib.ethdev.count_avail) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_count_total, + lib.ethdev.count_total) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_name_by_port, + lib.ethdev.get_name_by_port) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_port_by_name, + lib.ethdev.get_port_by_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_reg_info, + lib.ethdev.get_reg_info) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_sec_ctx, + lib.ethdev.get_sec_ctx) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_supported_ptypes, + lib.ethdev.get_supported_ptypes) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_vlan_offload, + lib.ethdev.get_vlan_offload) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_info_get, + lib.ethdev.info_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_is_removed, + lib.ethdev.is_removed) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_is_valid_port, + lib.ethdev.is_valid_port) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_mac_addr_add, + lib.ethdev.mac_addr_add) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_mac_addr_remove, + lib.ethdev.mac_addr_remove) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_pool_ops_supported, + lib.ethdev.pool_ops_supported) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_priority_flow_ctrl_set, + lib.ethdev.priority_flow_ctrl_set) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_reset, + lib.ethdev.reset) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_hash_conf_get, + lib.ethdev.rss_hash_conf_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_hash_update, + lib.ethdev.rss_hash_update) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_reta_query, + lib.ethdev.rss_reta_query) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_reta_update, + lib.ethdev.rss_reta_update) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_ctl, + lib.ethdev.rx_intr_ctl) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_ctl_q, + lib.ethdev.rx_intr_ctl_q) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_ctl_q_get_fd, + lib.ethdev.rx_intr_ctl_q_get_fd) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_disable, + lib.ethdev.rx_intr_disable) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_enable, + lib.ethdev.rx_intr_enable) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_offload_name, + lib.ethdev.rx_offload_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_queue_start, + lib.ethdev.rx_queue_start) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_queue_stop, + lib.ethdev.rx_queue_stop) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_eeprom, + lib.ethdev.set_eeprom) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_link_down, + lib.ethdev.set_link_down) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_link_up, + lib.ethdev.set_link_up) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_mc_addr_list, + lib.ethdev.set_mc_addr_list) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_ptypes, + lib.ethdev.set_ptypes) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_rx_queue_stats_mapping, + lib.ethdev.set_rx_queue_stats_mapping) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_tx_queue_stats_mapping, + lib.ethdev.set_tx_queue_stats_mapping) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_ether_type, + lib.ethdev.set_vlan_ether_type) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_offload, + lib.ethdev.set_vlan_offload) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_pvid, + lib.ethdev.set_vlan_pvid) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_strip_on_queue, + lib.ethdev.set_vlan_strip_on_queue) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_socket_id, + lib.ethdev.socket_id) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_tx_offload_name, + lib.ethdev.tx_offload_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_tx_queue_start, + lib.ethdev.tx_queue_start) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_tx_queue_stop, + lib.ethdev.tx_queue_stop) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_uc_all_hash_table_set, + lib.ethdev.uc_all_hash_table_set) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_uc_hash_table_set, + lib.ethdev.uc_hash_table_set) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_udp_tunnel_port_add, + lib.ethdev.udp_tunnel_port_add) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_udp_tunnel_port_delete, + lib.ethdev.udp_tunnel_port_delete) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_vlan_filter, + lib.ethdev.vlan_filter) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_find_next, + lib.ethdev.find_next) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_find_next_of, + lib.ethdev.find_next_of) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_find_next_owned_by, + lib.ethdev.find_next_owned_by) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_find_next_sibling, + lib.ethdev.find_next_sibling) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_iterator_cleanup, + lib.ethdev.iterator_cleanup) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_iterator_init, + lib.ethdev.iterator_init) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_iterator_next, + lib.ethdev.iterator_next) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_led_off, + lib.ethdev.led_off) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_led_on, + lib.ethdev.led_on) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_link_get, + lib.ethdev.link_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_link_get_nowait, + lib.ethdev.link_get_nowait) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_macaddr_get, + lib.ethdev.macaddr_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_promiscuous_disable, + lib.ethdev.promiscuous_disable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_promiscuous_enable, + lib.ethdev.promiscuous_enable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_promiscuous_get, + lib.ethdev.promiscuous_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_remove_rx_callback, + lib.ethdev.remove_rx_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_remove_tx_callback, + lib.ethdev.remove_tx_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_burst_mode_get, + lib.ethdev.rx_burst_mode_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_queue_info_get, + lib.ethdev.rx_queue_info_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_queue_setup, + lib.ethdev.rx_queue_setup) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_set_queue_rate_limit, + lib.ethdev.set_queue_rate_limit) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_speed_bitflag, + lib.ethdev.speed_bitflag) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_stats_get, + lib.ethdev.stats_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_stats_reset, + lib.ethdev.stats_reset) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_adjust_time, + lib.ethdev.timesync_adjust_time) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_disable, + lib.ethdev.timesync_disable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_enable, + lib.ethdev.timesync_enable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_read_rx_timestamp, + lib.ethdev.timesync_read_rx_timestamp) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_read_time, + lib.ethdev.timesync_read_time) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_read_tx_timestamp, + lib.ethdev.timesync_read_tx_timestamp) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_write_time, + lib.ethdev.timesync_write_time) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_buffer_count_callback, + lib.ethdev.tx_buffer_count_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_buffer_drop_callback, + lib.ethdev.tx_buffer_drop_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_buffer_init, + lib.ethdev.tx_buffer_init) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_buffer_set_err_callback, + lib.ethdev.tx_buffer_set_err_callback) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_burst_mode_get, + lib.ethdev.tx_burst_mode_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_done_cleanup, + lib.ethdev.tx_done_cleanup) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_queue_info_get, + lib.ethdev.tx_queue_info_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_queue_setup, + lib.ethdev.tx_queue_setup) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_xstats_get, + lib.ethdev.xstats_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_xstats_get_by_id, + lib.ethdev.xstats_get_by_id) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_xstats_get_id_by_name, + lib.ethdev.xstats_get_id_by_name) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_xstats_get_names, + lib.ethdev.xstats_get_names) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_xstats_get_names_by_id, + lib.ethdev.xstats_get_names_by_id) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_xstats_reset, + lib.ethdev.xstats_reset) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_owner_delete, + lib.ethdev.owner_delete) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_owner_get, + lib.ethdev.owner_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_owner_new, + lib.ethdev.owner_new) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_owner_set, + lib.ethdev.owner_set) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_owner_unset, + lib.ethdev.owner_unset) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_module_eeprom, + lib.ethdev.get_module_eeprom) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_module_info, + lib.ethdev.get_module_info) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_read_clock, + lib.ethdev.read_clock) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_hairpin_capability_get, + lib.ethdev.hairpin_capability_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_hairpin_queue_setup, + lib.ethdev.rx.hairpin_queue_setup) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_hairpin_queue_setup, + lib.ethdev.tx.hairpin_queue_setup) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_hairpin_bind, + lib.ethdev.hairpin_bind) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_hairpin_get_peer_ports, + lib.ethdev.hairpin_get_peer_ports) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_hairpin_unbind, + lib.ethdev.hairpin_unbind) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_link_speed_to_str, + lib.ethdev.link_speed_to_str) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_link_to_str, + lib.ethdev.link_to_str) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_fec_get_capability, + lib.ethdev.fec_get_capability) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_fec_get, + lib.ethdev.fec_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_fec_set, + lib.ethdev.fec_set) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_get_monitor_addr, + lib.ethdev.get_monitor_addr) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_representor_info_get, + lib.ethdev.representor_info_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_capability_name, + lib.ethdev.capability_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_conf_get, + lib.ethdev.conf_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_macaddrs_get, + lib.ethdev.macaddrs_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_metadata_negotiate, + lib.ethdev.rx_metadata_negotiate) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_priority_flow_ctrl_queue_configure, + lib.ethdev.priority_flow_ctrl_queue_configure) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_priority_flow_ctrl_queue_info_get, + lib.ethdev.priority_flow_ctrl_queue_info_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_priv_dump, + lib.ethdev.priv_dump) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_ip_reassembly_capability_get, + lib.ethdev.ip_reassembly_capability_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_ip_reassembly_conf_get, + lib.ethdev.ip_reassembly_conf_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_ip_reassembly_conf_set, + lib.ethdev.ip_reassembly_conf_set) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_query, + lib.ethdev.rx_avail_thresh_query) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_set, + lib.ethdev.rx_avail_thresh_set) diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c index 1979dc0850..a6fb370b22 100644 --- a/lib/ethdev/rte_ethdev.c +++ b/lib/ethdev/rte_ethdev.c @@ -167,6 +167,7 @@ rte_eth_iterator_init(struct rte_dev_iterator *iter, const char *devargs_str) char *cls_str = NULL; int str_size; + rte_eth_trace_iterator_init(iter, devargs_str); if (iter == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot initialize NULL iterator\n"); return -EINVAL; @@ -273,6 +274,7 @@ rte_eth_iterator_init(struct rte_dev_iterator *iter, const char *devargs_str) uint16_t rte_eth_iterator_next(struct rte_dev_iterator *iter) { + rte_eth_trace_iterator_next(iter); if (iter == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot get next device from NULL iterator\n"); @@ -308,6 +310,7 @@ rte_eth_iterator_next(struct rte_dev_iterator *iter) void rte_eth_iterator_cleanup(struct rte_dev_iterator *iter) { + rte_eth_trace_iterator_cleanup(iter); if (iter == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot do clean up from NULL iterator\n"); return; @@ -323,6 +326,7 @@ rte_eth_iterator_cleanup(struct rte_dev_iterator *iter) uint16_t rte_eth_find_next(uint16_t port_id) { + rte_eth_trace_find_next(port_id); while (port_id < RTE_MAX_ETHPORTS && rte_eth_devices[port_id].state == RTE_ETH_DEV_UNUSED) port_id++; @@ -345,6 +349,7 @@ rte_eth_find_next(uint16_t port_id) uint16_t rte_eth_find_next_of(uint16_t port_id, const struct rte_device *parent) { + rte_eth_trace_find_next_of(port_id, parent); port_id = rte_eth_find_next(port_id); while (port_id < RTE_MAX_ETHPORTS && rte_eth_devices[port_id].device != parent) @@ -356,6 +361,7 @@ rte_eth_find_next_of(uint16_t port_id, const struct rte_device *parent) uint16_t rte_eth_find_next_sibling(uint16_t port_id, uint16_t ref_port_id) { + rte_eth_trace_find_next_sibling(port_id, ref_port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(ref_port_id, RTE_MAX_ETHPORTS); return rte_eth_find_next_of(port_id, rte_eth_devices[ref_port_id].device); @@ -370,6 +376,7 @@ eth_dev_is_allocated(const struct rte_eth_dev *ethdev) int rte_eth_dev_is_valid_port(uint16_t port_id) { + rte_ethdev_trace_is_valid_port(port_id); if (port_id >= RTE_MAX_ETHPORTS || (rte_eth_devices[port_id].state == RTE_ETH_DEV_UNUSED)) return 0; @@ -389,6 +396,7 @@ eth_is_valid_owner_id(uint64_t owner_id) uint64_t rte_eth_find_next_owned_by(uint16_t port_id, const uint64_t owner_id) { + rte_eth_trace_find_next_owned_by(port_id, owner_id); port_id = rte_eth_find_next(port_id); while (port_id < RTE_MAX_ETHPORTS && rte_eth_devices[port_id].data->owner.id != owner_id) @@ -412,6 +420,7 @@ rte_eth_dev_owner_new(uint64_t *owner_id) *owner_id = eth_dev_shared_data->next_owner_id++; rte_spinlock_unlock(ð_dev_shared_data->ownership_lock); + rte_ethdev_trace_owner_new(*owner_id); return 0; } @@ -468,6 +477,7 @@ rte_eth_dev_owner_set(const uint16_t port_id, { int ret; + rte_ethdev_trace_owner_set(port_id, owner); eth_dev_shared_data_prepare(); rte_spinlock_lock(ð_dev_shared_data->ownership_lock); @@ -485,6 +495,7 @@ rte_eth_dev_owner_unset(const uint16_t port_id, const uint64_t owner_id) {.id = RTE_ETH_DEV_NO_OWNER, .name = ""}; int ret; + rte_ethdev_trace_owner_unset(port_id, owner_id); eth_dev_shared_data_prepare(); rte_spinlock_lock(ð_dev_shared_data->ownership_lock); @@ -525,6 +536,7 @@ rte_eth_dev_owner_delete(const uint64_t owner_id) rte_spinlock_unlock(ð_dev_shared_data->ownership_lock); + rte_ethdev_trace_owner_delete(owner_id, ret); return ret; } @@ -554,12 +566,14 @@ rte_eth_dev_owner_get(const uint16_t port_id, struct rte_eth_dev_owner *owner) rte_memcpy(owner, ðdev->data->owner, sizeof(*owner)); rte_spinlock_unlock(ð_dev_shared_data->ownership_lock); + rte_ethdev_trace_owner_get(port_id, owner); return 0; } int rte_eth_dev_socket_id(uint16_t port_id) { + rte_ethdev_trace_socket_id(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1); return rte_eth_devices[port_id].data->numa_node; } @@ -567,6 +581,7 @@ rte_eth_dev_socket_id(uint16_t port_id) void * rte_eth_dev_get_sec_ctx(uint16_t port_id) { + rte_ethdev_trace_get_sec_ctx(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, NULL); return rte_eth_devices[port_id].security_ctx; } @@ -582,6 +597,7 @@ rte_eth_dev_count_avail(void) RTE_ETH_FOREACH_DEV(p) count++; + rte_ethdev_trace_count_avail(count); return count; } @@ -593,6 +609,7 @@ rte_eth_dev_count_total(void) RTE_ETH_FOREACH_VALID_DEV(port) count++; + rte_ethdev_trace_count_total(count); return count; } @@ -613,6 +630,7 @@ rte_eth_dev_get_name_by_port(uint16_t port_id, char *name) * because it might be overwritten by VDEV PMD */ tmp = eth_dev_shared_data->data[port_id].name; strcpy(name, tmp); + rte_ethdev_trace_get_name_by_port(port_id, name); return 0; } @@ -635,6 +653,7 @@ rte_eth_dev_get_port_by_name(const char *name, uint16_t *port_id) RTE_ETH_FOREACH_VALID_DEV(pid) if (!strcmp(name, eth_dev_shared_data->data[pid].name)) { *port_id = pid; + rte_ethdev_trace_get_port_by_name(name, *port_id); return 0; } @@ -705,6 +724,7 @@ rte_eth_dev_rx_queue_start(uint16_t port_id, uint16_t rx_queue_id) struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_rx_queue_start(port_id, rx_queue_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -744,6 +764,7 @@ rte_eth_dev_rx_queue_stop(uint16_t port_id, uint16_t rx_queue_id) struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_rx_queue_stop(port_id, rx_queue_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -776,6 +797,7 @@ rte_eth_dev_tx_queue_start(uint16_t port_id, uint16_t tx_queue_id) struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_tx_queue_start(port_id, tx_queue_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -815,6 +837,7 @@ rte_eth_dev_tx_queue_stop(uint16_t port_id, uint16_t tx_queue_id) struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_tx_queue_stop(port_id, tx_queue_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -844,6 +867,7 @@ rte_eth_dev_tx_queue_stop(uint16_t port_id, uint16_t tx_queue_id) uint32_t rte_eth_speed_bitflag(uint32_t speed, int duplex) { + rte_eth_trace_speed_bitflag(speed, duplex); switch (speed) { case RTE_ETH_SPEED_NUM_10M: return duplex ? RTE_ETH_LINK_SPEED_10M : RTE_ETH_LINK_SPEED_10M_HD; @@ -889,6 +913,7 @@ rte_eth_dev_rx_offload_name(uint64_t offload) } } + rte_ethdev_trace_rx_offload_name(offload, name); return name; } @@ -905,6 +930,7 @@ rte_eth_dev_tx_offload_name(uint64_t offload) } } + rte_ethdev_trace_tx_offload_name(offload, name); return name; } @@ -921,6 +947,7 @@ rte_eth_dev_capability_name(uint64_t capability) } } + rte_ethdev_trace_capability_name(capability, name); return name; } @@ -1538,6 +1565,7 @@ rte_eth_dev_set_link_up(uint16_t port_id) { struct rte_eth_dev *dev; + rte_ethdev_trace_set_link_up(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -1550,6 +1578,7 @@ rte_eth_dev_set_link_down(uint16_t port_id) { struct rte_eth_dev *dev; + rte_ethdev_trace_set_link_down(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -1596,6 +1625,7 @@ rte_eth_dev_reset(uint16_t port_id) struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_reset(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -1631,6 +1661,7 @@ rte_eth_dev_is_removed(uint16_t port_id) /* Device is physically removed. */ dev->state = RTE_ETH_DEV_REMOVED; + rte_ethdev_trace_is_removed(port_id, ret); return ret; } @@ -1910,6 +1941,8 @@ rte_eth_rx_hairpin_queue_setup(uint16_t port_id, uint16_t rx_queue_id, int i; int count; + rte_eth_trace_rx_hairpin_queue_setup(port_id, rx_queue_id, nb_rx_desc, + conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -1985,6 +2018,8 @@ rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id, RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; + rte_eth_trace_tx_queue_setup(port_id, tx_queue_id, nb_tx_desc, + socket_id, tx_conf); if (tx_queue_id >= dev->data->nb_tx_queues) { RTE_ETHDEV_LOG(ERR, "Invalid Tx queue_id=%u\n", tx_queue_id); return -EINVAL; @@ -2076,6 +2111,7 @@ rte_eth_tx_hairpin_queue_setup(uint16_t port_id, uint16_t tx_queue_id, int count; int ret; + rte_eth_trace_tx_hairpin_queue_setup(port_id, tx_queue_id, nb_tx_desc, conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2144,6 +2180,7 @@ rte_eth_hairpin_bind(uint16_t tx_port, uint16_t rx_port) struct rte_eth_dev *dev; int ret; + rte_eth_trace_hairpin_bind(tx_port, rx_port); RTE_ETH_VALID_PORTID_OR_ERR_RET(tx_port, -ENODEV); dev = &rte_eth_devices[tx_port]; @@ -2168,6 +2205,7 @@ rte_eth_hairpin_unbind(uint16_t tx_port, uint16_t rx_port) struct rte_eth_dev *dev; int ret; + rte_eth_trace_hairpin_unbind(tx_port, rx_port); RTE_ETH_VALID_PORTID_OR_ERR_RET(tx_port, -ENODEV); dev = &rte_eth_devices[tx_port]; @@ -2193,6 +2231,7 @@ rte_eth_hairpin_get_peer_ports(uint16_t port_id, uint16_t *peer_ports, struct rte_eth_dev *dev; int ret; + rte_eth_trace_hairpin_get_peer_ports(port_id, peer_ports, len, direction); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2226,6 +2265,7 @@ void rte_eth_tx_buffer_drop_callback(struct rte_mbuf **pkts, uint16_t unsent, void *userdata __rte_unused) { + rte_eth_trace_tx_buffer_drop_callback(pkts, unsent); rte_pktmbuf_free_bulk(pkts, unsent); } @@ -2237,12 +2277,14 @@ rte_eth_tx_buffer_count_callback(struct rte_mbuf **pkts, uint16_t unsent, rte_pktmbuf_free_bulk(pkts, unsent); *count += unsent; + rte_eth_trace_tx_buffer_count_callback(pkts, unsent, *count); } int rte_eth_tx_buffer_set_err_callback(struct rte_eth_dev_tx_buffer *buffer, buffer_tx_error_fn cbfn, void *userdata) { + rte_eth_trace_tx_buffer_set_err_callback(buffer, cbfn, userdata); if (buffer == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot set Tx buffer error callback to NULL buffer\n"); @@ -2259,6 +2301,7 @@ rte_eth_tx_buffer_init(struct rte_eth_dev_tx_buffer *buffer, uint16_t size) { int ret = 0; + rte_eth_trace_tx_buffer_init(buffer, size); if (buffer == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot initialize NULL buffer\n"); return -EINVAL; @@ -2279,6 +2322,7 @@ rte_eth_tx_done_cleanup(uint16_t port_id, uint16_t queue_id, uint32_t free_cnt) struct rte_eth_dev *dev; int ret; + rte_eth_trace_tx_done_cleanup(port_id, queue_id, free_cnt); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2296,6 +2340,7 @@ rte_eth_promiscuous_enable(uint16_t port_id) struct rte_eth_dev *dev; int diag = 0; + rte_eth_trace_promiscuous_enable(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2316,6 +2361,7 @@ rte_eth_promiscuous_disable(uint16_t port_id) struct rte_eth_dev *dev; int diag = 0; + rte_eth_trace_promiscuous_disable(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2337,6 +2383,7 @@ rte_eth_promiscuous_get(uint16_t port_id) { struct rte_eth_dev *dev; + rte_eth_trace_promiscuous_get(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2349,6 +2396,7 @@ rte_eth_allmulticast_enable(uint16_t port_id) struct rte_eth_dev *dev; int diag; + rte_eth_trace_allmulticast_enable(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2368,6 +2416,7 @@ rte_eth_allmulticast_disable(uint16_t port_id) struct rte_eth_dev *dev; int diag; + rte_eth_trace_allmulticast_disable(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2388,6 +2437,7 @@ rte_eth_allmulticast_get(uint16_t port_id) { struct rte_eth_dev *dev; + rte_eth_trace_allmulticast_get(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2416,6 +2466,7 @@ rte_eth_link_get(uint16_t port_id, struct rte_eth_link *eth_link) *eth_link = dev->data->dev_link; } + rte_eth_trace_link_get(port_id, eth_link); return 0; } @@ -2441,12 +2492,14 @@ rte_eth_link_get_nowait(uint16_t port_id, struct rte_eth_link *eth_link) *eth_link = dev->data->dev_link; } + rte_eth_trace_link_get_nowait(port_id, eth_link); return 0; } const char * rte_eth_link_speed_to_str(uint32_t link_speed) { + rte_eth_trace_link_speed_to_str(link_speed); switch (link_speed) { case RTE_ETH_SPEED_NUM_NONE: return "None"; case RTE_ETH_SPEED_NUM_10M: return "10 Mbps"; @@ -2470,6 +2523,7 @@ rte_eth_link_speed_to_str(uint32_t link_speed) int rte_eth_link_to_str(char *str, size_t len, const struct rte_eth_link *eth_link) { + rte_eth_trace_link_to_str(str, len, eth_link); if (str == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot convert link to NULL string\n"); return -EINVAL; @@ -2502,6 +2556,7 @@ rte_eth_stats_get(uint16_t port_id, struct rte_eth_stats *stats) { struct rte_eth_dev *dev; + rte_eth_trace_stats_get(port_id, stats); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2524,6 +2579,7 @@ rte_eth_stats_reset(uint16_t port_id) struct rte_eth_dev *dev; int ret; + rte_eth_trace_stats_reset(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2598,6 +2654,7 @@ rte_eth_xstats_get_id_by_name(uint16_t port_id, const char *xstat_name, return -ENOMEM; } + rte_eth_trace_xstats_get_id_by_name(port_id, xstat_name, id); /* Get count */ cnt_xstats = rte_eth_xstats_get_names_by_id(port_id, NULL, 0, NULL); if (cnt_xstats < 0) { @@ -2770,6 +2827,8 @@ rte_eth_xstats_get_names_by_id(uint16_t port_id, return -1; } xstats_names[i] = xstats_names_copy[ids[i]]; + rte_eth_trace_xstats_get_names_by_id(port_id, &xstats_names[i], + ids[i]); } free(xstats_names_copy); @@ -2809,6 +2868,7 @@ rte_eth_xstats_get_names(uint16_t port_id, cnt_used_entries += cnt_driver_entries; } + rte_eth_trace_xstats_get_names(port_id, xstats_names, size, cnt_used_entries); return cnt_used_entries; } @@ -2884,6 +2944,7 @@ rte_eth_xstats_get_by_id(uint16_t port_id, const uint64_t *ids, RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; + rte_eth_trace_xstats_get_by_id(port_id, ids, values, size); ret = eth_dev_get_xstats_count(port_id); if (ret < 0) return ret; @@ -3005,6 +3066,8 @@ rte_eth_xstats_get(uint16_t port_id, struct rte_eth_xstat *xstats, for ( ; i < count + xcount; i++) xstats[i].id += count; + for (i = 0; i < n; i++) + rte_eth_trace_xstats_get(port_id, xstats[i], i); return count + xcount; } @@ -3017,6 +3080,7 @@ rte_eth_xstats_reset(uint16_t port_id) RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; + rte_eth_trace_xstats_reset(port_id); /* implemented by the driver */ if (dev->dev_ops->xstats_reset != NULL) return eth_err(port_id, (*dev->dev_ops->xstats_reset)(dev)); @@ -3051,6 +3115,8 @@ int rte_eth_dev_set_tx_queue_stats_mapping(uint16_t port_id, uint16_t tx_queue_id, uint8_t stat_idx) { + rte_ethdev_trace_set_tx_queue_stats_mapping(port_id, tx_queue_id, + stat_idx); return eth_err(port_id, eth_dev_set_queue_stats_mapping(port_id, tx_queue_id, stat_idx, STAT_QMAP_TX)); @@ -3060,6 +3126,8 @@ int rte_eth_dev_set_rx_queue_stats_mapping(uint16_t port_id, uint16_t rx_queue_id, uint8_t stat_idx) { + rte_ethdev_trace_set_rx_queue_stats_mapping(port_id, rx_queue_id, + stat_idx); return eth_err(port_id, eth_dev_set_queue_stats_mapping(port_id, rx_queue_id, stat_idx, STAT_QMAP_RX)); @@ -3070,6 +3138,7 @@ rte_eth_dev_fw_version_get(uint16_t port_id, char *fw_version, size_t fw_size) { struct rte_eth_dev *dev; + rte_ethdev_trace_fw_version_get(port_id, fw_version, fw_size); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3141,6 +3210,7 @@ rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info *dev_info) dev_info->dev_flags = &dev->data->dev_flags; + rte_ethdev_trace_info_get(port_id, dev_info); return 0; } @@ -3149,6 +3219,7 @@ rte_eth_dev_conf_get(uint16_t port_id, struct rte_eth_conf *dev_conf) { struct rte_eth_dev *dev; + rte_ethdev_trace_conf_get(port_id, dev_conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3172,6 +3243,7 @@ rte_eth_dev_get_supported_ptypes(uint16_t port_id, uint32_t ptype_mask, struct rte_eth_dev *dev; const uint32_t *all_ptypes; + rte_ethdev_trace_get_supported_ptypes(port_id, ptype_mask, ptypes, num); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3217,6 +3289,7 @@ rte_eth_dev_set_ptypes(uint16_t port_id, uint32_t ptype_mask, unsigned int i, j; int ret; + rte_ethdev_trace_set_ptypes(port_id, ptype_mask, set_ptypes, num); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3296,6 +3369,7 @@ rte_eth_macaddrs_get(uint16_t port_id, struct rte_ether_addr *ma, struct rte_eth_dev *dev; struct rte_eth_dev_info dev_info; + rte_eth_trace_macaddrs_get(port_id, ma, num); if (ma == NULL) { RTE_ETHDEV_LOG(ERR, "%s: invalid parameters\n", __func__); return -EINVAL; @@ -3318,6 +3392,7 @@ rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr) { struct rte_eth_dev *dev; + rte_eth_trace_macaddr_get(port_id, mac_addr); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3348,6 +3423,7 @@ rte_eth_dev_get_mtu(uint16_t port_id, uint16_t *mtu) } *mtu = dev->data->mtu; + rte_ethdev_trace_get_mtu(port_id, *mtu); return 0; } @@ -3389,6 +3465,7 @@ rte_eth_dev_set_mtu(uint16_t port_id, uint16_t mtu) if (ret == 0) dev->data->mtu = mtu; + rte_ethdev_trace_set_mtu(port_id, mtu, ret); return eth_err(port_id, ret); } @@ -3398,6 +3475,7 @@ rte_eth_dev_vlan_filter(uint16_t port_id, uint16_t vlan_id, int on) struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_vlan_filter(port_id, vlan_id, on); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3440,6 +3518,7 @@ rte_eth_dev_set_vlan_strip_on_queue(uint16_t port_id, uint16_t rx_queue_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_set_vlan_strip_on_queue(port_id, rx_queue_id, on); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3461,6 +3540,7 @@ rte_eth_dev_set_vlan_ether_type(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_set_vlan_ether_type(port_id, vlan_type, tpid); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3481,6 +3561,7 @@ rte_eth_dev_set_vlan_offload(uint16_t port_id, int offload_mask) uint64_t dev_offloads; uint64_t new_offloads; + rte_ethdev_trace_set_vlan_offload(port_id, offload_mask); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3583,6 +3664,7 @@ rte_eth_dev_get_vlan_offload(uint16_t port_id) if (*dev_offloads & RTE_ETH_RX_OFFLOAD_QINQ_STRIP) ret |= RTE_ETH_QINQ_STRIP_OFFLOAD; + rte_ethdev_trace_get_vlan_offload(port_id, ret); return ret; } @@ -3591,6 +3673,7 @@ rte_eth_dev_set_vlan_pvid(uint16_t port_id, uint16_t pvid, int on) { struct rte_eth_dev *dev; + rte_ethdev_trace_set_vlan_pvid(port_id, pvid, on); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3603,6 +3686,7 @@ rte_eth_dev_flow_ctrl_get(uint16_t port_id, struct rte_eth_fc_conf *fc_conf) { struct rte_eth_dev *dev; + rte_ethdev_trace_flow_ctrl_get(port_id, fc_conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3623,6 +3707,7 @@ rte_eth_dev_flow_ctrl_set(uint16_t port_id, struct rte_eth_fc_conf *fc_conf) { struct rte_eth_dev *dev; + rte_ethdev_trace_flow_ctrl_set(port_id, fc_conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3648,6 +3733,7 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_priority_flow_ctrl_set(port_id, pfc_conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3735,6 +3821,7 @@ rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id, return -EINVAL; } + rte_ethdev_trace_priority_flow_ctrl_queue_info_get(port_id, pfc_queue_info); if (*dev->dev_ops->priority_flow_ctrl_queue_info_get) return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_queue_info_get) (dev, pfc_queue_info)); @@ -3750,6 +3837,8 @@ rte_eth_dev_priority_flow_ctrl_queue_configure(uint16_t port_id, struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_priority_flow_ctrl_queue_configure(port_id, + pfc_queue_conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3865,6 +3954,7 @@ rte_eth_dev_rss_reta_update(uint16_t port_id, struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_rss_reta_update(port_id, reta_conf, reta_size); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3912,6 +4002,7 @@ rte_eth_dev_rss_reta_query(uint16_t port_id, struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_rss_reta_query(port_id, reta_conf, reta_size); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3941,6 +4032,7 @@ rte_eth_dev_rss_hash_update(uint16_t port_id, enum rte_eth_rx_mq_mode mq_mode; int ret; + rte_ethdev_trace_rss_hash_update(port_id, rss_conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3982,6 +4074,7 @@ rte_eth_dev_rss_hash_conf_get(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_rss_hash_conf_get(port_id, rss_conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4003,6 +4096,7 @@ rte_eth_dev_udp_tunnel_port_add(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_udp_tunnel_port_add(port_id, udp_tunnel); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4029,6 +4123,7 @@ rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_udp_tunnel_port_delete(port_id, udp_tunnel); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4054,6 +4149,7 @@ rte_eth_led_on(uint16_t port_id) { struct rte_eth_dev *dev; + rte_eth_trace_led_on(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4066,6 +4162,7 @@ rte_eth_led_off(uint16_t port_id) { struct rte_eth_dev *dev; + rte_eth_trace_led_off(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4081,6 +4178,7 @@ rte_eth_fec_get_capability(uint16_t port_id, struct rte_eth_dev *dev; int ret; + rte_eth_trace_fec_get_capability(port_id, speed_fec_capa, num); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4102,6 +4200,7 @@ rte_eth_fec_get(uint16_t port_id, uint32_t *fec_capa) { struct rte_eth_dev *dev; + rte_eth_trace_fec_get(port_id, fec_capa); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4121,6 +4220,7 @@ rte_eth_fec_set(uint16_t port_id, uint32_t fec_capa) { struct rte_eth_dev *dev; + rte_eth_trace_fec_set(port_id, fec_capa); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4163,6 +4263,7 @@ rte_eth_dev_mac_addr_add(uint16_t port_id, struct rte_ether_addr *addr, uint64_t pool_mask; int ret; + rte_ethdev_trace_mac_addr_add(port_id, addr, pool); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4221,6 +4322,7 @@ rte_eth_dev_mac_addr_remove(uint16_t port_id, struct rte_ether_addr *addr) struct rte_eth_dev *dev; int index; + rte_ethdev_trace_mac_addr_remove(port_id, addr); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4260,6 +4362,7 @@ rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct rte_ether_addr *addr) struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_default_mac_addr_set(port_id, addr); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4322,6 +4425,7 @@ rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct rte_ether_addr *addr, int ret; struct rte_eth_dev *dev; + rte_ethdev_trace_uc_hash_table_set(port_id, addr, on); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4379,6 +4483,7 @@ rte_eth_dev_uc_all_hash_table_set(uint16_t port_id, uint8_t on) { struct rte_eth_dev *dev; + rte_ethdev_trace_uc_all_hash_table_set(port_id, on); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4395,6 +4500,7 @@ int rte_eth_set_queue_rate_limit(uint16_t port_id, uint16_t queue_idx, struct rte_eth_link link; int ret; + rte_eth_trace_set_queue_rate_limit(port_id, queue_idx, tx_rate); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4428,6 +4534,7 @@ int rte_eth_rx_avail_thresh_set(uint16_t port_id, uint16_t queue_id, { struct rte_eth_dev *dev; + rte_eth_trace_rx_avail_thresh_set(port_id, queue_id, avail_thresh); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4462,6 +4569,7 @@ int rte_eth_rx_avail_thresh_query(uint16_t port_id, uint16_t *queue_id, if (*queue_id >= dev->data->nb_rx_queues) *queue_id = 0; + rte_eth_trace_rx_avail_thresh_query(port_id, *queue_id); RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_avail_thresh_query, -ENOTSUP); return eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_query)(dev, queue_id, avail_thresh)); @@ -4493,6 +4601,7 @@ rte_eth_dev_callback_register(uint16_t port_id, uint16_t next_port; uint16_t last_port; + rte_ethdev_trace_callback_register(port_id, event, cb_fn, cb_arg); if (cb_fn == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot register ethdev port %u callback from NULL\n", @@ -4560,6 +4669,7 @@ rte_eth_dev_callback_unregister(uint16_t port_id, uint16_t next_port; uint16_t last_port; + rte_ethdev_trace_callback_unregister(port_id, event, cb_fn, cb_arg); if (cb_fn == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot unregister ethdev port %u callback from NULL\n", @@ -4619,6 +4729,7 @@ rte_eth_dev_rx_intr_ctl(uint16_t port_id, int epfd, int op, void *data) uint16_t qid; int rc; + rte_ethdev_trace_rx_intr_ctl(port_id, epfd, op, data); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4679,6 +4790,7 @@ rte_eth_dev_rx_intr_ctl_q_get_fd(uint16_t port_id, uint16_t queue_id) (vec - RTE_INTR_VEC_RXTX_OFFSET) : vec; fd = rte_intr_efds_index_get(intr_handle, efd_idx); + rte_ethdev_trace_rx_intr_ctl_q_get_fd(port_id, queue_id, fd); return fd; } @@ -4691,6 +4803,7 @@ rte_eth_dev_rx_intr_ctl_q(uint16_t port_id, uint16_t queue_id, struct rte_intr_handle *intr_handle; int rc; + rte_ethdev_trace_rx_intr_ctl_q(port_id, queue_id, epfd, op, data); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4729,6 +4842,7 @@ rte_eth_dev_rx_intr_enable(uint16_t port_id, struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_rx_intr_enable(port_id, queue_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4747,6 +4861,7 @@ rte_eth_dev_rx_intr_disable(uint16_t port_id, struct rte_eth_dev *dev; int ret; + rte_ethdev_trace_rx_intr_disable(port_id, queue_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4769,6 +4884,7 @@ rte_eth_add_rx_callback(uint16_t port_id, uint16_t queue_id, #endif struct rte_eth_dev *dev; + rte_eth_trace_add_rx_callback(port_id, queue_id, fn, user_param); /* check input parameters */ if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL || queue_id >= rte_eth_devices[port_id].data->nb_rx_queues) { @@ -4824,6 +4940,7 @@ rte_eth_add_first_rx_callback(uint16_t port_id, uint16_t queue_id, rte_errno = ENOTSUP; return NULL; #endif + rte_eth_trace_add_first_rx_callback(port_id, queue_id, fn, user_param); /* check input parameters */ if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL || queue_id >= rte_eth_devices[port_id].data->nb_rx_queues) { @@ -4865,6 +4982,7 @@ rte_eth_add_tx_callback(uint16_t port_id, uint16_t queue_id, #endif struct rte_eth_dev *dev; + rte_eth_trace_add_tx_callback(port_id, queue_id, fn, user_param); /* check input parameters */ if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL || queue_id >= rte_eth_devices[port_id].data->nb_tx_queues) { @@ -4932,6 +5050,7 @@ rte_eth_remove_rx_callback(uint16_t port_id, uint16_t queue_id, struct rte_eth_rxtx_callback **prev_cb; int ret = -EINVAL; + rte_eth_trace_remove_rx_callback(port_id, queue_id, user_cb); rte_spinlock_lock(ð_dev_rx_cb_lock); prev_cb = &dev->post_rx_burst_cbs[queue_id]; for (; *prev_cb != NULL; prev_cb = &cb->next) { @@ -4966,6 +5085,7 @@ rte_eth_remove_tx_callback(uint16_t port_id, uint16_t queue_id, struct rte_eth_rxtx_callback *cb; struct rte_eth_rxtx_callback **prev_cb; + rte_eth_trace_remove_tx_callback(port_id, queue_id, user_cb); rte_spinlock_lock(ð_dev_tx_cb_lock); prev_cb = &dev->pre_tx_burst_cbs[queue_id]; for (; *prev_cb != NULL; prev_cb = &cb->next) { @@ -5024,6 +5144,7 @@ rte_eth_rx_queue_info_get(uint16_t port_id, uint16_t queue_id, dev->dev_ops->rxq_info_get(dev, queue_id, qinfo); qinfo->queue_state = dev->data->rx_queue_state[queue_id]; + rte_eth_trace_rx_queue_info_get(port_id, queue_id, qinfo); return 0; } @@ -5069,6 +5190,7 @@ rte_eth_tx_queue_info_get(uint16_t port_id, uint16_t queue_id, dev->dev_ops->txq_info_get(dev, queue_id, qinfo); qinfo->queue_state = dev->data->tx_queue_state[queue_id]; + rte_eth_trace_tx_queue_info_get(port_id, queue_id, qinfo); return 0; } @@ -5078,6 +5200,7 @@ rte_eth_rx_burst_mode_get(uint16_t port_id, uint16_t queue_id, { struct rte_eth_dev *dev; + rte_eth_trace_rx_burst_mode_get(port_id, queue_id, mode); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5105,6 +5228,7 @@ rte_eth_tx_burst_mode_get(uint16_t port_id, uint16_t queue_id, { struct rte_eth_dev *dev; + rte_eth_trace_tx_burst_mode_get(port_id, queue_id, mode); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5132,6 +5256,7 @@ rte_eth_get_monitor_addr(uint16_t port_id, uint16_t queue_id, { struct rte_eth_dev *dev; + rte_eth_trace_get_monitor_addr(port_id, queue_id, pmc); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5159,6 +5284,7 @@ rte_eth_dev_set_mc_addr_list(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_set_mc_addr_list(port_id, mc_addr_set, nb_mc_addr); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5172,6 +5298,7 @@ rte_eth_timesync_enable(uint16_t port_id) { struct rte_eth_dev *dev; + rte_eth_trace_timesync_enable(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5184,6 +5311,7 @@ rte_eth_timesync_disable(uint16_t port_id) { struct rte_eth_dev *dev; + rte_eth_trace_timesync_disable(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5197,6 +5325,7 @@ rte_eth_timesync_read_rx_timestamp(uint16_t port_id, struct timespec *timestamp, { struct rte_eth_dev *dev; + rte_eth_trace_timesync_read_rx_timestamp(port_id, timestamp, flags); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5218,6 +5347,7 @@ rte_eth_timesync_read_tx_timestamp(uint16_t port_id, { struct rte_eth_dev *dev; + rte_eth_trace_timesync_read_tx_timestamp(port_id, timestamp); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5238,6 +5368,7 @@ rte_eth_timesync_adjust_time(uint16_t port_id, int64_t delta) { struct rte_eth_dev *dev; + rte_eth_trace_timesync_adjust_time(port_id, delta); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5250,6 +5381,7 @@ rte_eth_timesync_read_time(uint16_t port_id, struct timespec *timestamp) { struct rte_eth_dev *dev; + rte_eth_trace_timesync_read_time(port_id, timestamp); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5270,6 +5402,7 @@ rte_eth_timesync_write_time(uint16_t port_id, const struct timespec *timestamp) { struct rte_eth_dev *dev; + rte_eth_trace_timesync_write_time(port_id, timestamp); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5290,6 +5423,7 @@ rte_eth_read_clock(uint16_t port_id, uint64_t *clock) { struct rte_eth_dev *dev; + rte_eth_trace_read_clock(port_id, clock); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5308,6 +5442,7 @@ rte_eth_dev_get_reg_info(uint16_t port_id, struct rte_dev_reg_info *info) { struct rte_eth_dev *dev; + rte_ethdev_trace_get_reg_info(port_id, info); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5327,6 +5462,7 @@ rte_eth_dev_get_eeprom_length(uint16_t port_id) { struct rte_eth_dev *dev; + rte_ethdev_trace_get_eeprom_length(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5339,6 +5475,7 @@ rte_eth_dev_get_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info) { struct rte_eth_dev *dev; + rte_ethdev_trace_get_eeprom(port_id, info); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5358,6 +5495,7 @@ rte_eth_dev_set_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info) { struct rte_eth_dev *dev; + rte_ethdev_trace_set_eeprom(port_id, info); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5378,6 +5516,7 @@ rte_eth_dev_get_module_info(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_get_module_info(port_id, modinfo); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5398,6 +5537,7 @@ rte_eth_dev_get_module_eeprom(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_get_module_eeprom(port_id, info); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5432,6 +5572,7 @@ rte_eth_dev_get_dcb_info(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_get_dcb_info(port_id, dcb_info); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5481,6 +5622,7 @@ rte_eth_dev_adjust_nb_rx_tx_desc(uint16_t port_id, if (nb_tx_desc != NULL) eth_dev_adjust_nb_desc(nb_tx_desc, &dev_info.tx_desc_lim); + rte_ethdev_trace_adjust_nb_rx_tx_desc(port_id, *nb_rx_desc, *nb_tx_desc); return 0; } @@ -5490,6 +5632,7 @@ rte_eth_dev_hairpin_capability_get(uint16_t port_id, { struct rte_eth_dev *dev; + rte_ethdev_trace_hairpin_capability_get(port_id, cap); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5510,6 +5653,7 @@ rte_eth_dev_pool_ops_supported(uint16_t port_id, const char *pool) { struct rte_eth_dev *dev; + rte_ethdev_trace_pool_ops_supported(port_id, pool); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5772,6 +5916,7 @@ rte_eth_representor_info_get(uint16_t port_id, { struct rte_eth_dev *dev; + rte_eth_trace_representor_info_get(port_id, info); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5784,6 +5929,7 @@ rte_eth_rx_metadata_negotiate(uint16_t port_id, uint64_t *features) { struct rte_eth_dev *dev; + rte_eth_trace_rx_metadata_negotiate(port_id, features); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5810,6 +5956,7 @@ rte_eth_ip_reassembly_capability_get(uint16_t port_id, { struct rte_eth_dev *dev; + rte_eth_trace_ip_reassembly_capability_get(port_id, reassembly_capa); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5840,6 +5987,7 @@ rte_eth_ip_reassembly_conf_get(uint16_t port_id, { struct rte_eth_dev *dev; + rte_eth_trace_ip_reassembly_conf_get(port_id, conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5869,6 +6017,7 @@ rte_eth_ip_reassembly_conf_set(uint16_t port_id, { struct rte_eth_dev *dev; + rte_eth_trace_ip_reassembly_conf_set(port_id, conf); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5905,6 +6054,7 @@ rte_eth_dev_priv_dump(uint16_t port_id, FILE *file) { struct rte_eth_dev *dev; + rte_ethdev_trace_priv_dump(port_id); RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; diff --git a/lib/ethdev/rte_ethdev_trace.h b/lib/ethdev/rte_ethdev_trace.h index 1491c815c3..de728d355d 100644 --- a/lib/ethdev/rte_ethdev_trace.h +++ b/lib/ethdev/rte_ethdev_trace.h @@ -88,6 +88,1188 @@ RTE_TRACE_POINT( rte_trace_point_emit_u16(port_id); ) +RTE_TRACE_POINT( + rte_eth_trace_add_first_rx_callback, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + rte_rx_callback_fn fn, void *user_param), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(fn); + rte_trace_point_emit_ptr(user_param); +) + +RTE_TRACE_POINT( + rte_eth_trace_add_rx_callback, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + rte_rx_callback_fn fn, void *user_param), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(fn); + rte_trace_point_emit_ptr(user_param); +) + +RTE_TRACE_POINT( + rte_eth_trace_add_tx_callback, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + rte_tx_callback_fn fn, void *user_param), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(fn); + rte_trace_point_emit_ptr(user_param); +) + +RTE_TRACE_POINT( + rte_eth_trace_allmulticast_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_allmulticast_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_allmulticast_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_call_rx_callbacks, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + struct rte_mbuf **rx_pkts, uint16_t nb_rx, + uint16_t nb_pkts, void *opaque), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(rx_pkts); + rte_trace_point_emit_u16(nb_rx); + rte_trace_point_emit_u16(nb_pkts); + rte_trace_point_emit_ptr(opaque); +) + +RTE_TRACE_POINT( + rte_eth_trace_call_tx_callbacks, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + struct rte_mbuf **tx_pkts, uint16_t nb_pkts, + void *opaque), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(tx_pkts); + rte_trace_point_emit_u16(nb_pkts); + rte_trace_point_emit_ptr(opaque); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_mtu, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t mtu, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(mtu); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_adjust_nb_rx_tx_desc, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t nb_rx_desc, + uint16_t nb_tx_desc), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(nb_rx_desc); + rte_trace_point_emit_u16(nb_tx_desc); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_callback_register, + RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_eth_event_type event, + rte_eth_dev_cb_fn cb_fn, void *cb_arg), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(event); + rte_trace_point_emit_ptr(cb_fn); + rte_trace_point_emit_ptr(cb_arg); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_callback_unregister, + RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_eth_event_type event, + rte_eth_dev_cb_fn cb_fn, void *cb_arg), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(event); + rte_trace_point_emit_ptr(cb_fn); + rte_trace_point_emit_ptr(cb_arg); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_default_mac_addr_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_ether_addr *addr), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(addr); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_flow_ctrl_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_fc_conf *fc_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(fc_conf); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_flow_ctrl_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_fc_conf *fc_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(fc_conf->high_water); + rte_trace_point_emit_u32(fc_conf->low_water); + rte_trace_point_emit_u16(fc_conf->pause_time); + rte_trace_point_emit_u16(fc_conf->send_xon); + rte_trace_point_emit_int(fc_conf->mode); + rte_trace_point_emit_u8(fc_conf->mac_ctrl_frame_fwd); + rte_trace_point_emit_u8(fc_conf->autoneg); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_fw_version_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, char *fw_version, size_t fw_size), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(fw_version); + rte_trace_point_emit_size_t(fw_size); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_dcb_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_dcb_info *dcb_info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(dcb_info); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_eeprom, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_dev_eeprom_info *info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_eeprom_length, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_mtu, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t mtu), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(mtu); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_count_avail, + RTE_TRACE_POINT_ARGS(uint16_t count), + rte_trace_point_emit_u16(count); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_count_total, + RTE_TRACE_POINT_ARGS(uint16_t count), + rte_trace_point_emit_u16(count); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_name_by_port, + RTE_TRACE_POINT_ARGS(uint16_t port_id, char *name), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_port_by_name, + RTE_TRACE_POINT_ARGS(const char *name, uint16_t port_id), + rte_trace_point_emit_string(name); + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_reg_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_dev_reg_info *info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_sec_ctx, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_supported_ptypes, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t ptype_mask, + uint32_t *ptypes, int num), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(ptype_mask); + rte_trace_point_emit_ptr(ptypes); + rte_trace_point_emit_int(num); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_vlan_offload, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_dev_info *dev_info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(dev_info->driver_name); + rte_trace_point_emit_u32(dev_info->if_index); + rte_trace_point_emit_u16(dev_info->min_mtu); + rte_trace_point_emit_u16(dev_info->max_mtu); + rte_trace_point_emit_u32(dev_info->min_rx_bufsize); + rte_trace_point_emit_u32(dev_info->max_rx_pktlen); + rte_trace_point_emit_u64(dev_info->rx_offload_capa); + rte_trace_point_emit_u64(dev_info->tx_offload_capa); + rte_trace_point_emit_u64(dev_info->rx_queue_offload_capa); + rte_trace_point_emit_u64(dev_info->tx_queue_offload_capa); + rte_trace_point_emit_u16(dev_info->reta_size); + rte_trace_point_emit_u8(dev_info->hash_key_size); + rte_trace_point_emit_u16(dev_info->nb_rx_queues); + rte_trace_point_emit_u16(dev_info->nb_tx_queues); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_is_removed, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_is_valid_port, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_mac_addr_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_ether_addr *addr, + uint32_t pool), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(addr); + rte_trace_point_emit_u32(pool); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_mac_addr_remove, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_ether_addr *addr), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(addr); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_pool_ops_supported, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const char *pool), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(pool); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_priority_flow_ctrl_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_pfc_conf *pfc_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(pfc_conf->fc.high_water); + rte_trace_point_emit_u32(pfc_conf->fc.low_water); + rte_trace_point_emit_u16(pfc_conf->fc.pause_time); + rte_trace_point_emit_u16(pfc_conf->fc.send_xon); + rte_trace_point_emit_int(pfc_conf->fc.mode); + rte_trace_point_emit_u8(pfc_conf->fc.mac_ctrl_frame_fwd); + rte_trace_point_emit_u8(pfc_conf->fc.autoneg); + rte_trace_point_emit_u8(pfc_conf->priority); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_reset, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_hash_conf_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_rss_conf *rss_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(rss_conf); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_hash_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_rss_conf *rss_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(rss_conf->rss_key); + rte_trace_point_emit_u8(rss_conf->rss_key_len); + rte_trace_point_emit_u64(rss_conf->rss_hf); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_reta_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(reta_conf); + rte_trace_point_emit_u16(reta_size); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_reta_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(reta_conf->mask); + rte_trace_point_emit_u16(reta_size); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_intr_ctl, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int epfd, int op, void *data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(epfd); + rte_trace_point_emit_int(op); + rte_trace_point_emit_ptr(data); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_intr_ctl_q, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int epfd, + int op, void *data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_int(epfd); + rte_trace_point_emit_int(op); + rte_trace_point_emit_ptr(data); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_intr_ctl_q_get_fd, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int fd), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_int(fd); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_intr_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_intr_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_offload_name, + RTE_TRACE_POINT_ARGS(uint64_t offload, const char *name), + rte_trace_point_emit_u64(offload); + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_queue_start, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_queue_stop, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_eeprom, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_dev_eeprom_info *info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info->data); + rte_trace_point_emit_u32(info->offset); + rte_trace_point_emit_u32(info->length); + rte_trace_point_emit_u32(info->magic); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_link_down, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_link_up, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_mc_addr_list, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_ether_addr *mc_addr_set, + uint32_t nb_mc_addr), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(mc_addr_set); + rte_trace_point_emit_u32(nb_mc_addr); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_ptypes, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t ptype_mask, + uint32_t *set_ptypes, unsigned int num), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(ptype_mask); + rte_trace_point_emit_ptr(set_ptypes); + rte_trace_point_emit_u32(num); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_rx_queue_stats_mapping, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, + uint8_t stat_idx), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_u8(stat_idx); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_tx_queue_stats_mapping, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id, + uint8_t stat_idx), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tx_queue_id); + rte_trace_point_emit_u8(stat_idx); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_vlan_ether_type, + RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_vlan_type vlan_type, + uint16_t tag_type), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(vlan_type); + rte_trace_point_emit_u16(tag_type); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_vlan_offload, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int offload_mask), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(offload_mask); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_vlan_pvid, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t pvid, int on), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(pvid); + rte_trace_point_emit_int(on); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_vlan_strip_on_queue, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, + int on), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_int(on); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_socket_id, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_tx_offload_name, + RTE_TRACE_POINT_ARGS(uint64_t offload, const char *name), + rte_trace_point_emit_u64(offload); + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_tx_queue_start, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tx_queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_tx_queue_stop, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tx_queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_uc_all_hash_table_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint8_t on), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u8(on); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_uc_hash_table_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_ether_addr *addr, + uint8_t on), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(addr); + rte_trace_point_emit_u8(on); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_udp_tunnel_port_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_udp_tunnel *tunnel_udp), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tunnel_udp->udp_port); + rte_trace_point_emit_u8(tunnel_udp->prot_type); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_udp_tunnel_port_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_udp_tunnel *tunnel_udp), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tunnel_udp->udp_port); + rte_trace_point_emit_u8(tunnel_udp->prot_type); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_vlan_filter, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t vlan_id, int on), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(vlan_id); + rte_trace_point_emit_int(on); +) + +RTE_TRACE_POINT( + rte_eth_trace_find_next, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_find_next_of, + RTE_TRACE_POINT_ARGS(uint16_t port_id_start, + const struct rte_device *parent), + rte_trace_point_emit_u16(port_id_start); + rte_trace_point_emit_ptr(parent); +) + +RTE_TRACE_POINT( + rte_eth_trace_find_next_owned_by, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const uint64_t owner_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(owner_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_find_next_sibling, + RTE_TRACE_POINT_ARGS(uint16_t port_id_start, uint16_t ref_port_id), + rte_trace_point_emit_u16(port_id_start); + rte_trace_point_emit_u16(ref_port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_iterator_cleanup, + RTE_TRACE_POINT_ARGS(struct rte_dev_iterator *iter), + rte_trace_point_emit_ptr(iter); +) + +RTE_TRACE_POINT( + rte_eth_trace_iterator_init, + RTE_TRACE_POINT_ARGS(struct rte_dev_iterator *iter, const char *devargs), + rte_trace_point_emit_ptr(iter); + rte_trace_point_emit_ptr(devargs); +) + +RTE_TRACE_POINT( + rte_eth_trace_iterator_next, + RTE_TRACE_POINT_ARGS(struct rte_dev_iterator *iter), + rte_trace_point_emit_ptr(iter); +) + +RTE_TRACE_POINT( + rte_eth_trace_led_off, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_led_on, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_link_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_link *link), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(link->link_speed); +) + +RTE_TRACE_POINT( + rte_eth_trace_link_get_nowait, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_link *link), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(link->link_speed); +) + +RTE_TRACE_POINT( + rte_eth_trace_macaddr_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_ether_addr *mac_addr), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(mac_addr); +) + +RTE_TRACE_POINT( + rte_eth_trace_promiscuous_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_promiscuous_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_promiscuous_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_remove_rx_callback, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + const struct rte_eth_rxtx_callback *user_cb), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(user_cb); +) + +RTE_TRACE_POINT( + rte_eth_trace_remove_tx_callback, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + const struct rte_eth_rxtx_callback *user_cb), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(user_cb); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_burst_mode_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + struct rte_eth_burst_mode *mode), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(mode); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_queue_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + struct rte_eth_rxq_info *qinfo), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(qinfo->mp); + rte_trace_point_emit_u8(qinfo->scattered_rx); + rte_trace_point_emit_u8(qinfo->queue_state); + rte_trace_point_emit_u16(qinfo->nb_desc); + rte_trace_point_emit_u16(qinfo->rx_buf_size); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_queue_setup, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, + uint16_t nb_rx_desc, unsigned int socket_id, + const struct rte_eth_rxconf *rx_conf, + struct rte_mempool *mb_pool), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_u16(nb_rx_desc); + rte_trace_point_emit_u32(socket_id); + rte_trace_point_emit_ptr(rx_conf); + rte_trace_point_emit_ptr(mb_pool); +) + +RTE_TRACE_POINT( + rte_eth_trace_set_queue_rate_limit, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_idx, + uint16_t tx_rate), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_idx); + rte_trace_point_emit_u16(tx_rate); +) + +RTE_TRACE_POINT( + rte_eth_trace_speed_bitflag, + RTE_TRACE_POINT_ARGS(uint32_t speed, int duplex), + rte_trace_point_emit_u32(speed); + rte_trace_point_emit_int(duplex); +) + +RTE_TRACE_POINT( + rte_eth_trace_stats_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_stats *stats), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(stats); +) + +RTE_TRACE_POINT( + rte_eth_trace_stats_reset, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_adjust_time, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int64_t delta), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_i64(delta); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_read_rx_timestamp, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct timespec *timestamp, uint32_t flags), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(timestamp); + rte_trace_point_emit_u32(flags); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_read_time, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct timespec *time), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(time); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_read_tx_timestamp, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct timespec *timestamp), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(timestamp); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_write_time, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *time), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(time); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_buffer_count_callback, + RTE_TRACE_POINT_ARGS(struct rte_mbuf **pkts, uint16_t unsent, + uint64_t count), + rte_trace_point_emit_ptr(pkts); + rte_trace_point_emit_u16(unsent); + rte_trace_point_emit_u64(count); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_buffer_drop_callback, + RTE_TRACE_POINT_ARGS(struct rte_mbuf **pkts, uint16_t unsent), + rte_trace_point_emit_ptr(pkts); + rte_trace_point_emit_u16(unsent); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_buffer_init, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev_tx_buffer *buffer, uint16_t size), + rte_trace_point_emit_ptr(buffer); + rte_trace_point_emit_u16(size); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_buffer_set_err_callback, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev_tx_buffer *buffer, + buffer_tx_error_fn callback, void *userdata), + rte_trace_point_emit_ptr(buffer); + rte_trace_point_emit_ptr(callback); + rte_trace_point_emit_ptr(userdata); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_burst_mode_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + struct rte_eth_burst_mode *mode), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(mode); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_done_cleanup, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, uint32_t free_cnt), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_u32(free_cnt); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_queue_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + struct rte_eth_txq_info *qinfo), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_u16(qinfo->nb_desc); + rte_trace_point_emit_u8(qinfo->queue_state); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_queue_setup, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id, + uint16_t nb_tx_desc, unsigned int socket_id, + const struct rte_eth_txconf *tx_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tx_queue_id); + rte_trace_point_emit_u16(nb_tx_desc); + rte_trace_point_emit_u32(socket_id); + rte_trace_point_emit_ptr(tx_conf); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_xstat xstats, + int i), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(xstats.id); + rte_trace_point_emit_u64(xstats.value); + rte_trace_point_emit_u32(i); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_get_by_id, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *ids, + uint64_t *values, unsigned int size), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(ids); + rte_trace_point_emit_ptr(values); + rte_trace_point_emit_u32(size); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_get_id_by_name, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const char *xstat_name, + uint64_t *id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(xstat_name); + rte_trace_point_emit_ptr(id); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_get_names, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_xstat_name *xstats_names, + unsigned int size, int cnt_used_entries), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(xstats_names->name); + rte_trace_point_emit_u32(size); + rte_trace_point_emit_int(cnt_used_entries); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_get_names_by_id, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_xstat_name *xstats_names, uint64_t ids), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(xstats_names->name); + rte_trace_point_emit_u64(ids); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_reset, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_owner_delete, + RTE_TRACE_POINT_ARGS(const uint64_t owner_id, int ret), + rte_trace_point_emit_u64(owner_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_owner_get, + RTE_TRACE_POINT_ARGS(const uint16_t port_id, + struct rte_eth_dev_owner *owner), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(owner->id); + rte_trace_point_emit_string(owner->name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_owner_new, + RTE_TRACE_POINT_ARGS(uint64_t owner_id), + rte_trace_point_emit_u64(owner_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_owner_set, + RTE_TRACE_POINT_ARGS(const uint16_t port_id, + const struct rte_eth_dev_owner *owner), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(owner->id); + rte_trace_point_emit_string(owner->name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_owner_unset, + RTE_TRACE_POINT_ARGS(const uint16_t port_id, + const uint64_t owner_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(owner_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_module_eeprom, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_dev_eeprom_info *info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_module_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_dev_module_info *modinfo), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(modinfo); +) + +RTE_TRACE_POINT( + rte_eth_trace_read_clock, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint64_t *clk), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(clk); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_hairpin_capability_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_hairpin_cap *cap), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(cap); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_hairpin_queue_setup, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, + uint16_t nb_rx_desc, const struct rte_eth_hairpin_conf *conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_u16(nb_rx_desc); + rte_trace_point_emit_ptr(conf); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_hairpin_queue_setup, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id, + uint16_t nb_tx_desc, const struct rte_eth_hairpin_conf *conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tx_queue_id); + rte_trace_point_emit_u16(nb_tx_desc); + rte_trace_point_emit_ptr(conf); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_bind, + RTE_TRACE_POINT_ARGS(uint16_t tx_port, uint16_t rx_port), + rte_trace_point_emit_u16(tx_port); + rte_trace_point_emit_u16(rx_port); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_get_peer_ports, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t *peer_ports, + size_t len, uint32_t direction), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(peer_ports); + rte_trace_point_emit_size_t(len); + rte_trace_point_emit_u32(direction); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_unbind, + RTE_TRACE_POINT_ARGS(uint16_t tx_port, uint16_t rx_port), + rte_trace_point_emit_u16(tx_port); + rte_trace_point_emit_u16(rx_port); +) + +RTE_TRACE_POINT( + rte_eth_trace_link_speed_to_str, + RTE_TRACE_POINT_ARGS(uint32_t link_speed), + rte_trace_point_emit_u32(link_speed); +) + +RTE_TRACE_POINT( + rte_eth_trace_link_to_str, + RTE_TRACE_POINT_ARGS(char *str, size_t len, + const struct rte_eth_link *eth_link), + rte_trace_point_emit_ptr(str); + rte_trace_point_emit_size_t(len); + rte_trace_point_emit_ptr(eth_link); +) + +RTE_TRACE_POINT( + rte_eth_trace_fec_get_capability, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_fec_capa *speed_fec_capa, + unsigned int num), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(speed_fec_capa); + rte_trace_point_emit_u32(num); +) + +RTE_TRACE_POINT( + rte_eth_trace_fec_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t *fec_capa), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(fec_capa); +) + +RTE_TRACE_POINT( + rte_eth_trace_fec_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t fec_capa), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(fec_capa); +) + +RTE_TRACE_POINT( + rte_eth_trace_get_monitor_addr, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + struct rte_power_monitor_cond *pmc), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(pmc); +) + +RTE_TRACE_POINT( + rte_eth_trace_representor_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_representor_info *info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_capability_name, + RTE_TRACE_POINT_ARGS(uint64_t capability, const char *name), + rte_trace_point_emit_u64(capability); + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_conf_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_conf *dev_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(dev_conf); +) + +RTE_TRACE_POINT( + rte_eth_trace_macaddrs_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_ether_addr *ma, + unsigned int num), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(ma); + rte_trace_point_emit_u32(num); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_metadata_negotiate, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint64_t *features), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(features); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_priority_flow_ctrl_queue_configure, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_pfc_queue_conf *pfc_queue_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(pfc_queue_conf); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_priority_flow_ctrl_queue_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_pfc_queue_info *pfc_queue_info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(pfc_queue_info); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_priv_dump, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_ip_reassembly_capability_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_ip_reassembly_params *capa), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(capa); +) + +RTE_TRACE_POINT( + rte_eth_trace_ip_reassembly_conf_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_eth_ip_reassembly_params *conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); +) + +RTE_TRACE_POINT( + rte_eth_trace_ip_reassembly_conf_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_ip_reassembly_params *conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_avail_thresh_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_avail_thresh_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + uint8_t avail_thresh), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_u8(avail_thresh); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/version.map b/lib/ethdev/version.map index d46f31b63f..79bf947042 100644 --- a/lib/ethdev/version.map +++ b/lib/ethdev/version.map @@ -285,6 +285,153 @@ EXPERIMENTAL { rte_mtr_color_in_protocol_priority_get; rte_mtr_color_in_protocol_set; rte_mtr_meter_vlan_table_update; + + # added in 22.11 + __rte_eth_trace_add_first_rx_callback; + __rte_eth_trace_add_rx_callback; + __rte_eth_trace_add_tx_callback; + __rte_eth_trace_allmulticast_disable; + __rte_eth_trace_allmulticast_enable; + __rte_eth_trace_allmulticast_get; + __rte_eth_trace_call_rx_callbacks; + __rte_eth_trace_call_tx_callbacks; + __rte_ethdev_trace_count_avail; + __rte_ethdev_trace_count_total; + __rte_ethdev_trace_set_mtu; + __rte_ethdev_trace_adjust_nb_rx_tx_desc; + __rte_ethdev_trace_callback_register; + __rte_ethdev_trace_callback_unregister; + __rte_ethdev_trace_default_mac_addr_set; + __rte_ethdev_trace_flow_ctrl_get; + __rte_ethdev_trace_flow_ctrl_set; + __rte_ethdev_trace_fw_version_get; + __rte_ethdev_trace_get_dcb_info; + __rte_ethdev_trace_get_eeprom; + __rte_ethdev_trace_get_eeprom_length; + __rte_ethdev_trace_get_mtu; + __rte_ethdev_trace_get_name_by_port; + __rte_ethdev_trace_get_port_by_name; + __rte_ethdev_trace_get_reg_info; + __rte_ethdev_trace_get_sec_ctx; + __rte_ethdev_trace_get_supported_ptypes; + __rte_ethdev_trace_get_vlan_offload; + __rte_ethdev_trace_info_get; + __rte_ethdev_trace_is_removed; + __rte_ethdev_trace_is_valid_port; + __rte_ethdev_trace_mac_addr_add; + __rte_ethdev_trace_mac_addr_remove; + __rte_ethdev_trace_pool_ops_supported; + __rte_ethdev_trace_priority_flow_ctrl_set; + __rte_ethdev_trace_reset; + __rte_ethdev_trace_rss_hash_conf_get; + __rte_ethdev_trace_rss_hash_update; + __rte_ethdev_trace_rss_reta_query; + __rte_ethdev_trace_rss_reta_update; + __rte_ethdev_trace_rx_intr_ctl; + __rte_ethdev_trace_rx_intr_ctl_q; + __rte_ethdev_trace_rx_intr_ctl_q_get_fd; + __rte_ethdev_trace_rx_intr_disable; + __rte_ethdev_trace_rx_intr_enable; + __rte_ethdev_trace_rx_offload_name; + __rte_ethdev_trace_rx_queue_start; + __rte_ethdev_trace_rx_queue_stop; + __rte_ethdev_trace_set_eeprom; + __rte_ethdev_trace_set_link_down; + __rte_ethdev_trace_set_link_up; + __rte_ethdev_trace_set_mc_addr_list; + __rte_ethdev_trace_set_ptypes; + __rte_ethdev_trace_set_rx_queue_stats_mapping; + __rte_ethdev_trace_set_tx_queue_stats_mapping; + __rte_ethdev_trace_set_vlan_ether_type; + __rte_ethdev_trace_set_vlan_offload; + __rte_ethdev_trace_set_vlan_pvid; + __rte_ethdev_trace_set_vlan_strip_on_queue; + __rte_ethdev_trace_socket_id; + __rte_ethdev_trace_tx_offload_name; + __rte_ethdev_trace_tx_queue_start; + __rte_ethdev_trace_tx_queue_stop; + __rte_ethdev_trace_uc_all_hash_table_set; + __rte_ethdev_trace_uc_hash_table_set; + __rte_ethdev_trace_udp_tunnel_port_add; + __rte_ethdev_trace_udp_tunnel_port_delete; + __rte_ethdev_trace_vlan_filter; + __rte_eth_trace_find_next; + __rte_eth_trace_find_next_of; + __rte_eth_trace_find_next_owned_by; + __rte_eth_trace_find_next_sibling; + __rte_eth_trace_iterator_cleanup; + __rte_eth_trace_iterator_init; + __rte_eth_trace_iterator_next; + __rte_eth_trace_led_off; + __rte_eth_trace_led_on; + __rte_eth_trace_link_get; + __rte_eth_trace_link_get_nowait; + __rte_eth_trace_macaddr_get; + __rte_eth_trace_promiscuous_disable; + __rte_eth_trace_promiscuous_enable; + __rte_eth_trace_promiscuous_get; + __rte_eth_trace_remove_rx_callback; + __rte_eth_trace_remove_tx_callback; + __rte_eth_trace_rx_burst_mode_get; + __rte_eth_trace_rx_queue_info_get; + __rte_eth_trace_rx_queue_setup; + __rte_eth_trace_set_queue_rate_limit; + __rte_eth_trace_speed_bitflag; + __rte_eth_trace_stats_get; + __rte_eth_trace_stats_reset; + __rte_eth_trace_timesync_adjust_time; + __rte_eth_trace_timesync_disable; + __rte_eth_trace_timesync_enable; + __rte_eth_trace_timesync_read_rx_timestamp; + __rte_eth_trace_timesync_read_time; + __rte_eth_trace_timesync_read_tx_timestamp; + __rte_eth_trace_timesync_write_time; + __rte_eth_trace_tx_buffer_count_callback; + __rte_eth_trace_tx_buffer_drop_callback; + __rte_eth_trace_tx_buffer_init; + __rte_eth_trace_tx_buffer_set_err_callback; + __rte_eth_trace_tx_burst_mode_get; + __rte_eth_trace_tx_done_cleanup; + __rte_eth_trace_tx_queue_info_get; + __rte_eth_trace_tx_queue_setup; + __rte_eth_trace_xstats_get; + __rte_eth_trace_xstats_get_by_id; + __rte_eth_trace_xstats_get_id_by_name; + __rte_eth_trace_xstats_get_names; + __rte_eth_trace_xstats_get_names_by_id; + __rte_eth_trace_xstats_reset; + __rte_ethdev_trace_owner_delete; + __rte_ethdev_trace_owner_get; + __rte_ethdev_trace_owner_new; + __rte_ethdev_trace_owner_set; + __rte_ethdev_trace_owner_unset; + __rte_ethdev_trace_get_module_eeprom; + __rte_ethdev_trace_get_module_info; + __rte_ethdev_trace_hairpin_capability_get; + __rte_eth_trace_rx_hairpin_queue_setup; + __rte_eth_trace_tx_hairpin_queue_setup; + __rte_eth_trace_hairpin_bind; + __rte_eth_trace_hairpin_get_peer_ports; + __rte_eth_trace_hairpin_unbind; + __rte_eth_trace_link_speed_to_str; + __rte_eth_trace_link_to_str; + __rte_eth_trace_fec_get_capability; + __rte_eth_trace_fec_get; + __rte_eth_trace_fec_set; + __rte_eth_trace_get_monitor_addr; + __rte_eth_trace_representor_info_get; + __rte_ethdev_trace_capability_name; + __rte_ethdev_trace_conf_get; + __rte_eth_trace_macaddrs_get; + __rte_eth_trace_rx_metadata_negotiate; + __rte_ethdev_trace_priority_flow_ctrl_queue_configure; + __rte_ethdev_trace_priority_flow_ctrl_queue_info_get; + __rte_ethdev_trace_priv_dump; + __rte_eth_trace_ip_reassembly_capability_get; + __rte_eth_trace_ip_reassembly_conf_get; + __rte_eth_trace_ip_reassembly_conf_set; + __rte_eth_trace_rx_avail_thresh_query; + __rte_eth_trace_rx_avail_thresh_set; }; INTERNAL { From patchwork Thu Aug 4 13:44:26 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 114618 X-Patchwork-Delegate: andrew.rybchenko@oktetlabs.ru 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 6839DA00C4; Thu, 4 Aug 2022 15:48:43 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 589BB42BD9; Thu, 4 Aug 2022 15:48:43 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 31B5D4282B for ; Thu, 4 Aug 2022 15:48:41 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 274C1Ovn021008; Thu, 4 Aug 2022 06:46:22 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=dWVoIBRpp1ZDkNUhB/lEyifdGZQH4NYYhmbevyiCeZ4=; b=BQ+bVaAYVvnT1N65bFM1iJvj3qsR+4itu10Hwe/XRZFSPQMi9AIVYx9CmAvQy3xi8bj5 XfoM1Yc3l94UB/rOLoZokiFpF9g6YV1azc0zopf+gb6Y/efA66cUW2ulccHoOMTwsXv5 SsLLXC1MLCK9kEdSWRfuvoowmM9CfsZ42ahqLVSnI6Cx63AtfBghswRYk7f4+rfAVB+o V43tdhU8rFjSAqCv/Y/Xssso7WDnIPblF8o/0+L5CJwzFpPxmehcPjrVDnqMJYqsiL1l akalBM18UHzCQQVAJu/PQYGzzhIsevep6KgfD6J6eIBX96L5Mxa3EoDTJjILBts9B6uS lA== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3hqgf1xr3g-3 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 04 Aug 2022 06:46:22 -0700 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Thu, 4 Aug 2022 06:46:19 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.18 via Frontend Transport; Thu, 4 Aug 2022 06:46:19 -0700 Received: from hyd1349.t110.caveonetworks.com.com (unknown [10.29.45.13]) by maili.marvell.com (Postfix) with ESMTP id 9BD373F7057; Thu, 4 Aug 2022 06:45:56 -0700 (PDT) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH 2/6] ethdev: add trace points for flow Date: Thu, 4 Aug 2022 19:14:26 +0530 Message-ID: <20220804134430.6192-3-adwivedi@marvell.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20220804134430.6192-1-adwivedi@marvell.com> References: <20220804134430.6192-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: 5r29cVT8AOvuI15x6wOzusXMuBdxafrN X-Proofpoint-ORIG-GUID: 5r29cVT8AOvuI15x6wOzusXMuBdxafrN X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-04_03,2022-08-04_02,2022-06-22_01 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 Adds trace points for rte_flow specific functions in ethdev lib. Signed-off-by: Ankur Dwivedi --- lib/ethdev/ethdev_trace_points.c | 117 +++++++++ lib/ethdev/rte_ethdev_trace.h | 405 +++++++++++++++++++++++++++++++ lib/ethdev/rte_flow.c | 54 +++++ lib/ethdev/version.map | 39 +++ 4 files changed, 615 insertions(+) diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index 2e80401771..a8b974564c 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -467,3 +467,120 @@ RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_query, RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_set, lib.ethdev.rx_avail_thresh_set) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_copy, + lib.ethdev.flow.copy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_create, + lib.ethdev.flow.create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_destroy, + lib.ethdev.flow.destroy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_error_set, + lib.ethdev.flow.error_set) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_flush, + lib.ethdev.flow.flush) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_isolate, + lib.ethdev.flow.isolate) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_query, + lib.ethdev.flow.query) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_validate, + lib.ethdev.flow.validate) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_conv, + lib.ethdev.flow.conv) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_dynf_metadata_register, + lib.ethdev.dynf_metadata_register) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_dev_dump, + lib.ethdev.flow.dev_dump) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_get_aged_flows, + lib.ethdev.flow.get_aged_flows) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_tunnel_decap_set, + lib.ethdev.flow.tunnel_decap_set) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_tunnel_match, + lib.ethdev.flow.tunnel_match) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_get_restore_info, + lib.ethdev.flow.get_restore_info) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_tunnel_action_decap_release, + lib.ethdev.flow.tunnel_action_decap_release) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_tunnel_item_release, + lib.ethdev.flow.tunnel_item_release) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_action_handle_create, + lib.ethdev.flow.action_handle_create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_action_handle_destroy, + lib.ethdev.flow.action_handle_destroy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_action_handle_update, + lib.ethdev.flow.action_handle_update) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_action_handle_query, + lib.ethdev.flow.action_handle_query) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_flex_item_create, + lib.ethdev.flow.flex_item_create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_flex_item_release, + lib.ethdev.flow.flex_item_release) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_pick_transfer_proxy, + lib.ethdev.flow.pick_transfer_proxy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_info_get, + lib.ethdev.flow.info_get) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_configure, + lib.ethdev.flow.configure) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_pattern_template_create, + lib.ethdev.flow.pattern_template_create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_pattern_template_destroy, + lib.ethdev.flow.pattern_template_destroy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_actions_template_create, + lib.ethdev.flow.actions_template_create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_actions_template_destroy, + lib.ethdev.flow.actions_template_destroy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_template_table_create, + lib.ethdev.flow.template_table_create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_template_table_destroy, + lib.ethdev.flow.template_table_destroy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_create, + lib.ethdev.flow.async_create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_destroy, + lib.ethdev.flow.async_destroy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_push, + lib.ethdev.flow.push) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_pull, + lib.ethdev.flow.pull) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_create, + lib.ethdev.flow.async_action_handle_create) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_destroy, + lib.ethdev.flow.async_action_handle_destroy) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_update, + lib.ethdev.flow.async_action_handle_update) diff --git a/lib/ethdev/rte_ethdev_trace.h b/lib/ethdev/rte_ethdev_trace.h index de728d355d..94d4b955b6 100644 --- a/lib/ethdev/rte_ethdev_trace.h +++ b/lib/ethdev/rte_ethdev_trace.h @@ -1270,6 +1270,411 @@ RTE_TRACE_POINT( rte_trace_point_emit_u8(avail_thresh); ) +RTE_TRACE_POINT( + rte_flow_trace_copy, + RTE_TRACE_POINT_ARGS(struct rte_flow_desc *fd, size_t len, + const struct rte_flow_attr *attr, + const struct rte_flow_item *items, + const struct rte_flow_action *actions), + rte_trace_point_emit_ptr(fd); + rte_trace_point_emit_size_t(len); + rte_trace_point_emit_u32(attr->group); + rte_trace_point_emit_u32(attr->priority); + rte_trace_point_emit_ptr(items); + rte_trace_point_emit_ptr(actions); +) + +RTE_TRACE_POINT( + rte_flow_trace_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct rte_flow_attr *attr, + const struct rte_flow_item *pattern, + const struct rte_flow_action *actions), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(attr->group); + rte_trace_point_emit_u32(attr->priority); + rte_trace_point_emit_ptr(pattern); + rte_trace_point_emit_ptr(actions); +) + +RTE_TRACE_POINT( + rte_flow_trace_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_flow *flow), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(flow); +) + +RTE_TRACE_POINT( + rte_flow_trace_error_set, + RTE_TRACE_POINT_ARGS(struct rte_flow_error *err_p, + int code, enum rte_flow_error_type type, + const void *cause, const char *message), + rte_trace_point_emit_ptr(err_p); + rte_trace_point_emit_int(code); + rte_trace_point_emit_int(type); + rte_trace_point_emit_ptr(cause); + rte_trace_point_emit_string(message); +) + +RTE_TRACE_POINT( + rte_flow_trace_flush, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_flow_trace_isolate, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int set), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(set); +) + +RTE_TRACE_POINT( + rte_flow_trace_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_flow *flow, + const struct rte_flow_action *action, void *data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(flow); + rte_trace_point_emit_ptr(action); + rte_trace_point_emit_ptr(data); +) + +RTE_TRACE_POINT( + rte_flow_trace_validate, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_attr *attr, + const struct rte_flow_item *pattern, + const struct rte_flow_action *actions), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(attr->group); + rte_trace_point_emit_u32(attr->priority); + rte_trace_point_emit_ptr(pattern); + rte_trace_point_emit_ptr(actions); +) + +RTE_TRACE_POINT( + rte_flow_trace_conv, + RTE_TRACE_POINT_ARGS(enum rte_flow_conv_op op, void *dst, + size_t size, const void *src), + rte_trace_point_emit_int(op); + rte_trace_point_emit_ptr(dst); + rte_trace_point_emit_size_t(size); + rte_trace_point_emit_ptr(src); +) + +RTE_TRACE_POINT( + rte_flow_trace_dynf_metadata_register, + RTE_TRACE_POINT_ARGS(int offset, uint64_t flag), + rte_trace_point_emit_int(offset); + rte_trace_point_emit_u64(flag); +) + +RTE_TRACE_POINT( + rte_flow_trace_dev_dump, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_flow *flow), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(flow); +) + +RTE_TRACE_POINT( + rte_flow_trace_get_aged_flows, + RTE_TRACE_POINT_ARGS(uint16_t port_id, void **contexts, + uint32_t nb_contexts), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(contexts); + rte_trace_point_emit_u32(nb_contexts); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_decap_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_tunnel *tunnel, + struct rte_flow_action **actions, + uint32_t *num_of_actions), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(tunnel); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_ptr(num_of_actions); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_match, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_tunnel *tunnel, + struct rte_flow_item **items, + uint32_t *num_of_items), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(tunnel); + rte_trace_point_emit_ptr(items); + rte_trace_point_emit_ptr(num_of_items); +) + +RTE_TRACE_POINT( + rte_flow_trace_get_restore_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_mbuf *m, + struct rte_flow_restore_info *info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(m); + rte_trace_point_emit_ptr(info); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_action_decap_release, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_action *actions, + uint32_t num_of_actions), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_u32(num_of_actions); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_item_release, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_item *items, + uint32_t num_of_items), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(items); + rte_trace_point_emit_u32(num_of_items); +) + +RTE_TRACE_POINT( + rte_flow_trace_action_handle_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_indir_action_conf *conf, + const struct rte_flow_action *action), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); + rte_trace_point_emit_ptr(action); +) + +RTE_TRACE_POINT( + rte_flow_trace_action_handle_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_action_handle *handle), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); +) + +RTE_TRACE_POINT( + rte_flow_trace_action_handle_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_action_handle *handle, + const void *update), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); + rte_trace_point_emit_ptr(update); +) + +RTE_TRACE_POINT( + rte_flow_trace_action_handle_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_action_handle *handle, + void *data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); + rte_trace_point_emit_ptr(data); +) + +RTE_TRACE_POINT( + rte_flow_trace_flex_item_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_item_flex_conf *conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); +) + +RTE_TRACE_POINT( + rte_flow_trace_flex_item_release, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_item_flex_handle *handle), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); +) + +RTE_TRACE_POINT( + rte_flow_trace_pick_transfer_proxy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t *proxy_port_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(proxy_port_id); +) + +RTE_TRACE_POINT( + rte_flow_trace_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_port_info *port_info, + struct rte_flow_queue_info *queue_info), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(port_info); + rte_trace_point_emit_ptr(queue_info); +) + +RTE_TRACE_POINT( + rte_flow_trace_configure, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_port_attr *port_attr, + uint16_t nb_queue, + const struct rte_flow_queue_attr **queue_attr), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(port_attr); + rte_trace_point_emit_u16(nb_queue); + rte_trace_point_emit_ptr(queue_attr); +) + +RTE_TRACE_POINT( + rte_flow_trace_pattern_template_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_pattern_template_attr *template_attr, + const struct rte_flow_item *pattern), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(template_attr); + rte_trace_point_emit_ptr(pattern); +) + +RTE_TRACE_POINT( + rte_flow_trace_pattern_template_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_pattern_template *pattern_template), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(pattern_template); +) + +RTE_TRACE_POINT( + rte_flow_trace_actions_template_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_actions_template_attr *template_attr, + const struct rte_flow_action *actions, + const struct rte_flow_action *masks), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(template_attr); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_ptr(masks); +) + +RTE_TRACE_POINT( + rte_flow_trace_actions_template_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_actions_template *actions_template), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(actions_template); +) + +RTE_TRACE_POINT( + rte_flow_trace_template_table_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_template_table_attr *table_attr, + struct rte_flow_pattern_template **pattern_templates, + uint8_t nb_pattern_templates, + struct rte_flow_actions_template **actions_templates, + uint8_t nb_actions_templates), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(table_attr); + rte_trace_point_emit_ptr(pattern_templates); + rte_trace_point_emit_u8(nb_pattern_templates); + rte_trace_point_emit_ptr(actions_templates); + rte_trace_point_emit_u8(nb_actions_templates); +) + +RTE_TRACE_POINT( + rte_flow_trace_template_table_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_flow_template_table *template_table), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(template_table); +) + +RTE_TRACE_POINT( + rte_flow_trace_async_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + const struct rte_flow_op_attr *op_attr, + struct rte_flow_template_table *template_table, + const struct rte_flow_item *pattern, + uint8_t pattern_template_index, + const struct rte_flow_action *actions, + uint8_t actions_template_index, + void *user_data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_ptr(op_attr); + rte_trace_point_emit_ptr(template_table); + rte_trace_point_emit_ptr(pattern); + rte_trace_point_emit_u8(pattern_template_index); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_u8(actions_template_index); + rte_trace_point_emit_ptr(user_data); +) + +RTE_TRACE_POINT( + rte_flow_trace_async_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + const struct rte_flow_op_attr *op_attr, + struct rte_flow *flow, void *user_data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_ptr(op_attr); + rte_trace_point_emit_ptr(flow); + rte_trace_point_emit_ptr(user_data); +) + +RTE_TRACE_POINT( + rte_flow_trace_push, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); +) + +RTE_TRACE_POINT( + rte_flow_trace_pull, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + struct rte_flow_op_result *res, uint16_t n_res), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_ptr(res); + rte_trace_point_emit_u16(n_res); +) + +RTE_TRACE_POINT( + rte_flow_trace_async_action_handle_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + const struct rte_flow_op_attr *op_attr, + const struct rte_flow_indir_action_conf *indir_action_conf, + const struct rte_flow_action *action, + void *user_data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_ptr(op_attr); + rte_trace_point_emit_ptr(indir_action_conf); + rte_trace_point_emit_ptr(action); + rte_trace_point_emit_ptr(user_data); +) + +RTE_TRACE_POINT( + rte_flow_trace_async_action_handle_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + const struct rte_flow_op_attr *op_attr, + struct rte_flow_action_handle *action_handle, + void *user_data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_ptr(op_attr); + rte_trace_point_emit_ptr(action_handle); + rte_trace_point_emit_ptr(user_data); +) + +RTE_TRACE_POINT( + rte_flow_trace_async_action_handle_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + const struct rte_flow_op_attr *op_attr, + struct rte_flow_action_handle *action_handle, + const void *update, void *user_data), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_ptr(op_attr); + rte_trace_point_emit_ptr(action_handle); + rte_trace_point_emit_ptr(update); + rte_trace_point_emit_ptr(user_data); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/rte_flow.c b/lib/ethdev/rte_flow.c index 501be9d602..e349d112f9 100644 --- a/lib/ethdev/rte_flow.c +++ b/lib/ethdev/rte_flow.c @@ -13,6 +13,7 @@ #include #include #include "rte_ethdev.h" +#include "rte_ethdev_trace.h" #include "rte_flow_driver.h" #include "rte_flow.h" @@ -284,6 +285,7 @@ rte_flow_dynf_metadata_register(void) goto error; rte_flow_dynf_metadata_offs = offset; rte_flow_dynf_metadata_mask = RTE_BIT64(flag); + rte_flow_trace_dynf_metadata_register(offset, RTE_BIT64(flag)); return 0; error: @@ -357,6 +359,7 @@ rte_flow_validate(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; int ret; + rte_flow_trace_validate(port_id, attr, pattern, actions); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->validate)) { @@ -382,6 +385,7 @@ rte_flow_create(uint16_t port_id, struct rte_flow *flow; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_create(port_id, attr, pattern, actions); if (unlikely(!ops)) return NULL; if (likely(!!ops->create)) { @@ -407,6 +411,7 @@ rte_flow_destroy(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_destroy(port_id, flow); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->destroy)) { @@ -429,6 +434,7 @@ rte_flow_flush(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_flush(port_id); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->flush)) { @@ -454,6 +460,7 @@ rte_flow_query(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_query(port_id, flow, action, data); if (!ops) return -rte_errno; if (likely(!!ops->query)) { @@ -477,6 +484,7 @@ rte_flow_isolate(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_isolate(port_id, set); if (!ops) return -rte_errno; if (likely(!!ops->isolate)) { @@ -506,6 +514,7 @@ rte_flow_error_set(struct rte_flow_error *error, }; } rte_errno = code; + rte_flow_trace_error_set(error, code, type, cause, message); return -code; } @@ -1004,6 +1013,7 @@ rte_flow_conv(enum rte_flow_conv_op op, const void *src, struct rte_flow_error *error) { + rte_flow_trace_conv(op, dst, size, src); switch (op) { const struct rte_flow_attr *attr; @@ -1069,6 +1079,7 @@ rte_flow_copy(struct rte_flow_desc *desc, size_t len, RTE_BUILD_BUG_ON(sizeof(struct rte_flow_desc) < sizeof(struct rte_flow_conv_rule)); + rte_flow_trace_copy(desc, len, attr, items, actions); if (dst_size && (&dst->pattern != &desc->items || &dst->actions != &desc->actions || @@ -1099,6 +1110,7 @@ rte_flow_dev_dump(uint16_t port_id, struct rte_flow *flow, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_dev_dump(port_id, flow); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->dev_dump)) { @@ -1120,6 +1132,7 @@ rte_flow_get_aged_flows(uint16_t port_id, void **contexts, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_get_aged_flows(port_id, contexts, nb_contexts); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->get_aged_flows)) { @@ -1142,6 +1155,7 @@ rte_flow_action_handle_create(uint16_t port_id, struct rte_flow_action_handle *handle; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_action_handle_create(port_id, conf, action); if (unlikely(!ops)) return NULL; if (unlikely(!ops->action_handle_create)) { @@ -1165,6 +1179,7 @@ rte_flow_action_handle_destroy(uint16_t port_id, int ret; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_action_handle_destroy(port_id, handle); if (unlikely(!ops)) return -rte_errno; if (unlikely(!ops->action_handle_destroy)) @@ -1185,6 +1200,7 @@ rte_flow_action_handle_update(uint16_t port_id, int ret; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_action_handle_update(port_id, handle, update); if (unlikely(!ops)) return -rte_errno; if (unlikely(!ops->action_handle_update)) @@ -1205,6 +1221,7 @@ rte_flow_action_handle_query(uint16_t port_id, int ret; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_action_handle_query(port_id, handle, data); if (unlikely(!ops)) return -rte_errno; if (unlikely(!ops->action_handle_query)) @@ -1226,6 +1243,7 @@ rte_flow_tunnel_decap_set(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_tunnel_decap_set(port_id, tunnel, actions, num_of_actions); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_decap_set)) { @@ -1249,6 +1267,7 @@ rte_flow_tunnel_match(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_tunnel_match(port_id, tunnel, items, num_of_items); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_match)) { @@ -1271,6 +1290,7 @@ rte_flow_get_restore_info(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_get_restore_info(port_id, m, restore_info); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->get_restore_info)) { @@ -1293,6 +1313,7 @@ rte_flow_tunnel_action_decap_release(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_tunnel_action_decap_release(port_id, actions, num_of_actions); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_action_decap_release)) { @@ -1316,6 +1337,7 @@ rte_flow_tunnel_item_release(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_tunnel_item_release(port_id, items, num_of_items); if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_item_release)) { @@ -1336,6 +1358,7 @@ rte_flow_pick_transfer_proxy(uint16_t port_id, uint16_t *proxy_port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_eth_dev *dev; + rte_flow_trace_pick_transfer_proxy(port_id, proxy_port_id); if (unlikely(ops == NULL)) return -rte_errno; @@ -1360,6 +1383,7 @@ rte_flow_flex_item_create(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_flow_item_flex_handle *handle; + rte_flow_trace_flex_item_create(port_id, conf); if (unlikely(!ops)) return NULL; if (unlikely(!ops->flex_item_create)) { @@ -1383,6 +1407,7 @@ rte_flow_flex_item_release(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_flex_item_release(port_id, handle); if (unlikely(!ops || !ops->flex_item_release)) return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1400,6 +1425,7 @@ rte_flow_info_get(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_info_get(port_id, port_info, queue_info); if (unlikely(!ops)) return -rte_errno; if (dev->data->dev_configured == 0) { @@ -1433,6 +1459,7 @@ rte_flow_configure(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_configure(port_id, port_attr, nb_queue, queue_attr); if (unlikely(!ops)) return -rte_errno; if (dev->data->dev_configured == 0) { @@ -1476,6 +1503,8 @@ rte_flow_pattern_template_create(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_flow_pattern_template *template; + rte_flow_trace_pattern_template_create(port_id, template_attr, + pattern); if (unlikely(!ops)) return NULL; if (dev->data->flow_configured == 0) { @@ -1526,6 +1555,7 @@ rte_flow_pattern_template_destroy(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_pattern_template_destroy(port_id, pattern_template); if (unlikely(!ops)) return -rte_errno; if (unlikely(pattern_template == NULL)) @@ -1553,6 +1583,8 @@ rte_flow_actions_template_create(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_flow_actions_template *template; + rte_flow_trace_actions_template_create(port_id, template_attr, actions, + masks); if (unlikely(!ops)) return NULL; if (dev->data->flow_configured == 0) { @@ -1612,6 +1644,7 @@ rte_flow_actions_template_destroy(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_actions_template_destroy(port_id, actions_template); if (unlikely(!ops)) return -rte_errno; if (unlikely(actions_template == NULL)) @@ -1641,6 +1674,11 @@ rte_flow_template_table_create(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_flow_template_table *table; + rte_flow_trace_template_table_create(port_id, table_attr, + pattern_templates, + nb_pattern_templates, + actions_templates, + nb_actions_templates); if (unlikely(!ops)) return NULL; if (dev->data->flow_configured == 0) { @@ -1702,6 +1740,7 @@ rte_flow_template_table_destroy(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_template_table_destroy(port_id, template_table); if (unlikely(!ops)) return -rte_errno; if (unlikely(template_table == NULL)) @@ -1734,6 +1773,9 @@ rte_flow_async_create(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_flow *flow; + rte_flow_trace_async_create(port_id, queue_id, op_attr, template_table, + pattern, pattern_template_index, actions, + actions_template_index, user_data); flow = ops->async_create(dev, queue_id, op_attr, template_table, pattern, pattern_template_index, @@ -1755,6 +1797,8 @@ rte_flow_async_destroy(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_async_destroy(port_id, queue_id, op_attr, flow, + user_data); return flow_err(port_id, ops->async_destroy(dev, queue_id, op_attr, flow, @@ -1770,6 +1814,7 @@ rte_flow_push(uint16_t port_id, struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + rte_flow_trace_push(port_id, queue_id); return flow_err(port_id, ops->push(dev, queue_id, error), error); @@ -1786,6 +1831,7 @@ rte_flow_pull(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_pull(port_id, queue_id, res, n_res); ret = ops->pull(dev, queue_id, res, n_res, error); return ret ? ret : flow_err(port_id, ret, error); } @@ -1803,6 +1849,9 @@ rte_flow_async_action_handle_create(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_flow_action_handle *handle; + rte_flow_trace_async_action_handle_create(port_id, queue_id, op_attr, + indir_action_conf, action, + user_data); handle = ops->async_action_handle_create(dev, queue_id, op_attr, indir_action_conf, action, user_data, error); if (handle == NULL) @@ -1822,6 +1871,8 @@ rte_flow_async_action_handle_destroy(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_async_action_handle_destroy(port_id, queue_id, op_attr, + action_handle, user_data); ret = ops->async_action_handle_destroy(dev, queue_id, op_attr, action_handle, user_data, error); return flow_err(port_id, ret, error); @@ -1840,6 +1891,9 @@ rte_flow_async_action_handle_update(uint16_t port_id, const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); int ret; + rte_flow_trace_async_action_handle_update(port_id, queue_id, op_attr, + action_handle, update, + user_data); ret = ops->async_action_handle_update(dev, queue_id, op_attr, action_handle, update, user_data, error); return flow_err(port_id, ret, error); diff --git a/lib/ethdev/version.map b/lib/ethdev/version.map index 79bf947042..848ec442f1 100644 --- a/lib/ethdev/version.map +++ b/lib/ethdev/version.map @@ -432,6 +432,45 @@ EXPERIMENTAL { __rte_eth_trace_ip_reassembly_conf_set; __rte_eth_trace_rx_avail_thresh_query; __rte_eth_trace_rx_avail_thresh_set; + __rte_flow_trace_action_handle_create; + __rte_flow_trace_action_handle_destroy; + __rte_flow_trace_action_handle_query; + __rte_flow_trace_action_handle_update; + __rte_flow_trace_actions_template_create; + __rte_flow_trace_actions_template_destroy; + __rte_flow_trace_async_action_handle_create; + __rte_flow_trace_async_action_handle_destroy; + __rte_flow_trace_async_action_handle_update; + __rte_flow_trace_async_create; + __rte_flow_trace_async_destroy; + __rte_flow_trace_conv; + __rte_flow_trace_configure; + __rte_flow_trace_copy; + __rte_flow_trace_create; + __rte_flow_trace_destroy; + __rte_flow_trace_dev_dump; + __rte_flow_trace_dynf_metadata_register; + __rte_flow_trace_error_set; + __rte_flow_trace_flex_item_create; + __rte_flow_trace_flex_item_release; + __rte_flow_trace_flush; + __rte_flow_trace_get_aged_flows; + __rte_flow_trace_get_restore_info; + __rte_flow_trace_info_get; + __rte_flow_trace_isolate; + __rte_flow_trace_pattern_template_create; + __rte_flow_trace_pattern_template_destroy; + __rte_flow_trace_pick_transfer_proxy; + __rte_flow_trace_push; + __rte_flow_trace_pull; + __rte_flow_trace_query; + __rte_flow_trace_template_table_create; + __rte_flow_trace_template_table_destroy; + __rte_flow_trace_tunnel_action_decap_release; + __rte_flow_trace_tunnel_decap_set; + __rte_flow_trace_tunnel_item_release; + __rte_flow_trace_tunnel_match; + __rte_flow_trace_validate; }; INTERNAL { From patchwork Thu Aug 4 13:44:27 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 114619 X-Patchwork-Delegate: andrew.rybchenko@oktetlabs.ru 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 B4504A00C4; Thu, 4 Aug 2022 15:49:03 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id A424A42BE6; Thu, 4 Aug 2022 15:49:03 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 442CA42BE0 for ; Thu, 4 Aug 2022 15:49:02 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 274DK71t022469; Thu, 4 Aug 2022 06:46:46 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=ymMdppQgqo4ziNKHdtXPsU7FPMZUP7M6u2M6jzY7wLs=; b=GYYivrJPK6KwMncfRIhLR0VObbgLnqsK4x668sYfN8Shu8rmVshtdLwsAH1ie0hieaqB B7/3VGefMxGWG+agxErA9sYkS6M03cXgVm2CgIxxNFPQig/ZICs7OdcmbECaX4Wqn3SE Qeo6bojMxdfDY79Q8oV56xKM54mHyOTRNE4PUdjcefMOaPwpgy/vX77dva6ujEHV9CLC 9HTNIrojuHMy2MCBZxMOra675vRu4p8FgfqS9VPuqGIworYUIXM+jlOQh0LwsJZu3Gdt a7YkJCv84KQRHVxb+Mz4smqEPKHUNhB9uWg4Y68FhK8kG59cKqVQajJ/qEejWcBJ8Hu6 6g== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3hqgf1xr4u-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 04 Aug 2022 06:46:46 -0700 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Thu, 4 Aug 2022 06:46:44 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 4 Aug 2022 06:46:44 -0700 Received: from hyd1349.t110.caveonetworks.com.com (unknown [10.29.45.13]) by maili.marvell.com (Postfix) with ESMTP id 638A13F7057; Thu, 4 Aug 2022 06:46:23 -0700 (PDT) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH 3/6] ethdev: add trace points for mtr Date: Thu, 4 Aug 2022 19:14:27 +0530 Message-ID: <20220804134430.6192-4-adwivedi@marvell.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20220804134430.6192-1-adwivedi@marvell.com> References: <20220804134430.6192-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: QdyPczojiy4G14i_nRIBu8PxPUEBvd6m X-Proofpoint-ORIG-GUID: QdyPczojiy4G14i_nRIBu8PxPUEBvd6m X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-04_03,2022-08-04_02,2022-06-22_01 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 Adds trace points for rte_mtr specific functions in ethdev lib. Signed-off-by: Ankur Dwivedi --- lib/ethdev/ethdev_trace_points.c | 57 ++++++++++ lib/ethdev/rte_ethdev_trace.h | 176 +++++++++++++++++++++++++++++++ lib/ethdev/rte_mtr.c | 27 +++++ lib/ethdev/version.map | 19 ++++ 4 files changed, 279 insertions(+) diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index a8b974564c..673a0be13b 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -584,3 +584,60 @@ RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_destroy, RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_update, lib.ethdev.flow.async_action_handle_update) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_capabilities_get, + lib.ethdev.mtr.capabilities_get) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_create, + lib.ethdev.mtr.create) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_destroy, + lib.ethdev.mtr.destroy) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_disable, + lib.ethdev.mtr.meter_disable) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_dscp_table_update, + lib.ethdev.mtr.meter_dscp_table_update) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_enable, + lib.ethdev.mtr.meter_enable) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_profile_add, + lib.ethdev.mtr.meter_profile_add) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_profile_delete, + lib.ethdev.mtr.meter_profile_delete) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_profile_update, + lib.ethdev.mtr.meter_profile_update) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_stats_read, + lib.ethdev.mtr.stats_read) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_stats_update, + lib.ethdev.mtr.stats_update) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_policy_add, + lib.ethdev.mtr.meter_policy_add) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_policy_delete, + lib.ethdev.mtr.meter_policy_delete) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_policy_update, + lib.ethdev.mtr.meter_policy_update) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_policy_validate, + lib.ethdev.mtr.meter_policy_validate) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_meter_vlan_table_update, + lib.ethdev.mtr.meter_vlan_table_update) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_color_in_protocol_get, + lib.ethdev.mtr.color_in_protocol_get) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_color_in_protocol_priority_get, + lib.ethdev.mtr.color_in_protocol_priority_get) + +RTE_TRACE_POINT_REGISTER(rte_mtr_trace_color_in_protocol_set, + lib.ethdev.mtr.color_in_protocol_set) diff --git a/lib/ethdev/rte_ethdev_trace.h b/lib/ethdev/rte_ethdev_trace.h index 94d4b955b6..c07b5b3fb6 100644 --- a/lib/ethdev/rte_ethdev_trace.h +++ b/lib/ethdev/rte_ethdev_trace.h @@ -18,6 +18,7 @@ extern "C" { #include #include "rte_ethdev.h" +#include "rte_mtr.h" RTE_TRACE_POINT( rte_ethdev_trace_configure, @@ -1675,6 +1676,181 @@ RTE_TRACE_POINT( rte_trace_point_emit_ptr(user_data); ) +RTE_TRACE_POINT( + rte_mtr_trace_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_mtr_capabilities *cap), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(cap); +) + +RTE_TRACE_POINT( + rte_mtr_trace_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + struct rte_mtr_params *params, int shared), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_ptr(params); + rte_trace_point_emit_u32(params->meter_profile_id); + rte_trace_point_emit_int(params->use_prev_mtr_color); + rte_trace_point_emit_int(params->meter_enable); + rte_trace_point_emit_u64(params->stats_mask); + rte_trace_point_emit_u32(params->meter_policy_id); + rte_trace_point_emit_int(params->default_input_color); + rte_trace_point_emit_int(shared); +) + +RTE_TRACE_POINT( + rte_mtr_trace_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_dscp_table_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + enum rte_color *dscp_table), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_ptr(dscp_table); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_profile_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + uint32_t meter_profile_id, + struct rte_mtr_meter_profile *profile), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(meter_profile_id); + rte_trace_point_emit_int(profile->alg); + rte_trace_point_emit_int(profile->packet_mode); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_profile_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + uint32_t meter_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(meter_profile_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_profile_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + uint32_t meter_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_u32(meter_profile_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_stats_read, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + struct rte_mtr_stats *stats, uint64_t *stats_mask, + int clear), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_ptr(stats); + rte_trace_point_emit_ptr(stats_mask); + rte_trace_point_emit_int(clear); +) + +RTE_TRACE_POINT( + rte_mtr_trace_stats_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + uint64_t stats_mask), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_u64(stats_mask); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_policy_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t policy_id, + const struct rte_flow_action *actions), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(policy_id); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_int(actions->type); + rte_trace_point_emit_ptr(actions->conf); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_policy_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t policy_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(policy_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_policy_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + uint32_t meter_policy_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_u32(meter_policy_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_policy_validate, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_action *actions), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_int(actions->type); + rte_trace_point_emit_ptr(actions->conf); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_vlan_table_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + enum rte_color *vlan_table), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_ptr(vlan_table); +) + +RTE_TRACE_POINT( + rte_mtr_trace_color_in_protocol_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); +) + +RTE_TRACE_POINT( + rte_mtr_trace_color_in_protocol_priority_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + enum rte_mtr_color_in_protocol proto), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_int(proto); +) + +RTE_TRACE_POINT( + rte_mtr_trace_color_in_protocol_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + enum rte_mtr_color_in_protocol proto, uint32_t priority), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_int(proto); + rte_trace_point_emit_u32(priority); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/rte_mtr.c b/lib/ethdev/rte_mtr.c index c460e4f4e0..ff7265cd21 100644 --- a/lib/ethdev/rte_mtr.c +++ b/lib/ethdev/rte_mtr.c @@ -6,6 +6,7 @@ #include #include "rte_ethdev.h" +#include "rte_ethdev_trace.h" #include "rte_mtr_driver.h" #include "rte_mtr.h" @@ -63,6 +64,7 @@ rte_mtr_capabilities_get(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_capabilities_get(port_id, cap); return RTE_MTR_FUNC(port_id, capabilities_get)(dev, cap, error); } @@ -75,6 +77,7 @@ rte_mtr_meter_profile_add(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_profile_add(port_id, meter_profile_id, profile); return RTE_MTR_FUNC(port_id, meter_profile_add)(dev, meter_profile_id, profile, error); } @@ -86,6 +89,7 @@ rte_mtr_meter_profile_delete(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_profile_delete(port_id, meter_profile_id); return RTE_MTR_FUNC(port_id, meter_profile_delete)(dev, meter_profile_id, error); } @@ -97,6 +101,10 @@ rte_mtr_meter_policy_validate(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + int i; + + for (i = 0; i < RTE_COLORS; i++) + rte_mtr_trace_meter_policy_validate(port_id, policy->actions[i]); return RTE_MTR_FUNC(port_id, meter_policy_validate)(dev, policy, error); } @@ -109,6 +117,11 @@ rte_mtr_meter_policy_add(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + int i; + + for (i = 0; i < RTE_COLORS; i++) + rte_mtr_trace_meter_policy_add(port_id, policy_id, + policy->actions[i]); return RTE_MTR_FUNC(port_id, meter_policy_add)(dev, policy_id, policy, error); } @@ -120,6 +133,7 @@ rte_mtr_meter_policy_delete(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_policy_delete(port_id, policy_id); return RTE_MTR_FUNC(port_id, meter_policy_delete)(dev, policy_id, error); } @@ -133,6 +147,7 @@ rte_mtr_create(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_create(port_id, mtr_id, params, shared); return RTE_MTR_FUNC(port_id, create)(dev, mtr_id, params, shared, error); } @@ -144,6 +159,7 @@ rte_mtr_destroy(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_destroy(port_id, mtr_id); return RTE_MTR_FUNC(port_id, destroy)(dev, mtr_id, error); } @@ -155,6 +171,7 @@ rte_mtr_meter_enable(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_enable(port_id, mtr_id); return RTE_MTR_FUNC(port_id, meter_enable)(dev, mtr_id, error); } @@ -166,6 +183,7 @@ rte_mtr_meter_disable(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_disable(port_id, mtr_id); return RTE_MTR_FUNC(port_id, meter_disable)(dev, mtr_id, error); } @@ -178,6 +196,7 @@ rte_mtr_meter_profile_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_profile_update(port_id, mtr_id, meter_profile_id); return RTE_MTR_FUNC(port_id, meter_profile_update)(dev, mtr_id, meter_profile_id, error); } @@ -190,6 +209,7 @@ rte_mtr_meter_policy_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_policy_update(port_id, mtr_id, meter_policy_id); return RTE_MTR_FUNC(port_id, meter_policy_update)(dev, mtr_id, meter_policy_id, error); } @@ -202,6 +222,7 @@ rte_mtr_meter_dscp_table_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_dscp_table_update(port_id, mtr_id, dscp_table); return RTE_MTR_FUNC(port_id, meter_dscp_table_update)(dev, mtr_id, dscp_table, error); } @@ -214,6 +235,7 @@ rte_mtr_meter_vlan_table_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_meter_vlan_table_update(port_id, mtr_id, vlan_table); return RTE_MTR_FUNC(port_id, meter_vlan_table_update)(dev, mtr_id, vlan_table, error); } @@ -227,6 +249,7 @@ rte_mtr_color_in_protocol_set(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_color_in_protocol_set(port_id, mtr_id, proto, priority); return RTE_MTR_FUNC(port_id, in_proto_set)(dev, mtr_id, proto, priority, error); } @@ -239,6 +262,7 @@ rte_mtr_color_in_protocol_get(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_color_in_protocol_get(port_id, mtr_id); return RTE_MTR_FUNC(port_id, in_proto_get)(dev, mtr_id, proto_mask, error); } @@ -252,6 +276,7 @@ rte_mtr_color_in_protocol_priority_get(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_color_in_protocol_priority_get(port_id, mtr_id, proto); return RTE_MTR_FUNC(port_id, in_proto_prio_get)(dev, mtr_id, proto, priority, error); } @@ -264,6 +289,7 @@ rte_mtr_stats_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_stats_update(port_id, mtr_id, stats_mask); return RTE_MTR_FUNC(port_id, stats_update)(dev, mtr_id, stats_mask, error); } @@ -278,6 +304,7 @@ rte_mtr_stats_read(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_mtr_trace_stats_read(port_id, mtr_id, stats, stats_mask, clear); return RTE_MTR_FUNC(port_id, stats_read)(dev, mtr_id, stats, stats_mask, clear, error); } diff --git a/lib/ethdev/version.map b/lib/ethdev/version.map index 848ec442f1..2e282bb457 100644 --- a/lib/ethdev/version.map +++ b/lib/ethdev/version.map @@ -471,6 +471,25 @@ EXPERIMENTAL { __rte_flow_trace_tunnel_item_release; __rte_flow_trace_tunnel_match; __rte_flow_trace_validate; + __rte_mtr_trace_capabilities_get; + __rte_mtr_trace_color_in_protocol_get; + __rte_mtr_trace_color_in_protocol_priority_get; + __rte_mtr_trace_color_in_protocol_set; + __rte_mtr_trace_create; + __rte_mtr_trace_destroy; + __rte_mtr_trace_meter_disable; + __rte_mtr_trace_meter_dscp_table_update; + __rte_mtr_trace_meter_enable; + __rte_mtr_trace_meter_policy_add; + __rte_mtr_trace_meter_policy_delete; + __rte_mtr_trace_meter_policy_update; + __rte_mtr_trace_meter_policy_validate; + __rte_mtr_trace_meter_profile_add; + __rte_mtr_trace_meter_profile_delete; + __rte_mtr_trace_meter_profile_update; + __rte_mtr_trace_meter_vlan_table_update; + __rte_mtr_trace_stats_read; + __rte_mtr_trace_stats_update; }; INTERNAL { From patchwork Thu Aug 4 13:44:28 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 114620 X-Patchwork-Delegate: andrew.rybchenko@oktetlabs.ru 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 D7056A00C4; Thu, 4 Aug 2022 15:49:28 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C315542BDB; Thu, 4 Aug 2022 15:49:28 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 5306142BD9 for ; Thu, 4 Aug 2022 15:49:27 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 274COOAU020987; Thu, 4 Aug 2022 06:47:11 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=YvoFjKlzJI+FxnIFSBVVd//2FtWemtdld29ZyGCzC8c=; b=M17bOC59o6RqLDw6MuAgGvvENUv5y01EY6WSLQLn7iKejPwSVHTHkBJzcggjEI3HgePz 0XaTRMe1dPB52if3vksweI/heXkLm4UG6MmOY/qkXaRY1y2PhC/c89vNHAUthsmO7wj8 sczaDxB6TTCJxHhsl+36FTLnUwy0OYwAf3OUsfYx6jm1xKl2mnwHW5zJlev2aGAW4iaG /k5QzoIfjIxVw9eJ9xMUTTbCFEteFNYsRoCE8/8VYuYklK4oUG1OujX+ZYqEZIO5e3zu le03Mak+4QN3R4+GTceF87Vf/ZKYKok7nPpbcvujEpd3rl8jXSa7RME8Ec0YCtnym61Q 3Q== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3hqgf1xr5y-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 04 Aug 2022 06:47:11 -0700 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Thu, 4 Aug 2022 06:47:09 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.18 via Frontend Transport; Thu, 4 Aug 2022 06:47:09 -0700 Received: from hyd1349.t110.caveonetworks.com.com (unknown [10.29.45.13]) by maili.marvell.com (Postfix) with ESMTP id 520DB5B6941; Thu, 4 Aug 2022 06:46:48 -0700 (PDT) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH 4/6] ethdev: add trace points for tm Date: Thu, 4 Aug 2022 19:14:28 +0530 Message-ID: <20220804134430.6192-5-adwivedi@marvell.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20220804134430.6192-1-adwivedi@marvell.com> References: <20220804134430.6192-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: XgBe4K05mJRU4N-2c7TtBXcPLMsnOJYK X-Proofpoint-ORIG-GUID: XgBe4K05mJRU4N-2c7TtBXcPLMsnOJYK X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-04_03,2022-08-04_02,2022-06-22_01 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 Adds trace points for rte_tm specific functions in ethdev lib. Signed-off-by: Ankur Dwivedi --- lib/ethdev/ethdev_trace_points.c | 90 ++++++++++ lib/ethdev/rte_ethdev_trace.h | 283 +++++++++++++++++++++++++++++++ lib/ethdev/rte_tm.c | 40 +++++ lib/ethdev/version.map | 30 ++++ 4 files changed, 443 insertions(+) diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index 673a0be13b..341901d031 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -641,3 +641,93 @@ RTE_TRACE_POINT_REGISTER(rte_mtr_trace_color_in_protocol_priority_get, RTE_TRACE_POINT_REGISTER(rte_mtr_trace_color_in_protocol_set, lib.ethdev.mtr.color_in_protocol_set) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_capabilities_get, + lib.ethdev.tm.capabilities_get) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_get_number_of_leaf_nodes, + lib.ethdev.tm.get_number_of_leaf_nodes) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_hierarchy_commit, + lib.ethdev.tm.hierarchy_commit) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_level_capabilities_get, + lib.ethdev.tm.level_capabilities_get) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_mark_ip_dscp, + lib.ethdev.tm.mark_ip_dscp) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_mark_ip_ecn, + lib.ethdev.tm.mark_ip_ecn) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_mark_vlan_dei, + lib.ethdev.tm.mark_vlan_dei) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_add, + lib.ethdev.tm.node_add) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_capabilities_get, + lib.ethdev.tm.node_capabilities_get) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_cman_update, + lib.ethdev.tm.node_cman_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_delete, + lib.ethdev.tm.node_delete) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_parent_update, + lib.ethdev.tm.node_parent_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_resume, + lib.ethdev.tm.node_resume) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_shaper_update, + lib.ethdev.tm.node_shaper_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_shared_shaper_update, + lib.ethdev.tm.node_shared_shaper_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_shared_wred_context_update, + lib.ethdev.tm.node_shared_wred_context_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_stats_read, + lib.ethdev.tm.node_stats_read) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_stats_update, + lib.ethdev.tm.node_stats_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_suspend, + lib.ethdev.tm.node_suspend) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_type_get, + lib.ethdev.tm.node_type_get) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_wfq_weight_mode_update, + lib.ethdev.tm.node_wfq_weight_mode_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_node_wred_context_update, + lib.ethdev.tm.node_wred_context_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_shaper_profile_add, + lib.ethdev.tm.shaper_profile_add) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_shaper_profile_delete, + lib.ethdev.tm.shaper_profile_delete) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_shared_shaper_add_update, + lib.ethdev.tm.shared_shaper_add_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_shared_shaper_delete, + lib.ethdev.tm.shared_shaper_delete) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_shared_wred_context_add_update, + lib.ethdev.tm.shared_wred_context_add_update) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_shared_wred_context_delete, + lib.ethdev.tm.shared_wred_context_delete) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_wred_profile_add, + lib.ethdev.tm.wred_profile_add) + +RTE_TRACE_POINT_REGISTER(rte_tm_trace_wred_profile_delete, + lib.ethdev.tm.wred_profile_delete) diff --git a/lib/ethdev/rte_ethdev_trace.h b/lib/ethdev/rte_ethdev_trace.h index c07b5b3fb6..aa34a6a5e9 100644 --- a/lib/ethdev/rte_ethdev_trace.h +++ b/lib/ethdev/rte_ethdev_trace.h @@ -19,6 +19,7 @@ extern "C" { #include "rte_ethdev.h" #include "rte_mtr.h" +#include "rte_tm.h" RTE_TRACE_POINT( rte_ethdev_trace_configure, @@ -1851,6 +1852,288 @@ RTE_TRACE_POINT( rte_trace_point_emit_u32(priority); ) +RTE_TRACE_POINT( + rte_tm_trace_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + struct rte_tm_capabilities *cap), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(cap); +) + +RTE_TRACE_POINT( + rte_tm_trace_get_number_of_leaf_nodes, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t n_leaf_nodes, + struct rte_tm_error *error), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(n_leaf_nodes); + rte_trace_point_emit_int(error->type); + rte_trace_point_emit_string(error->message); +) + +RTE_TRACE_POINT( + rte_tm_trace_hierarchy_commit, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int clear_on_fail), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(clear_on_fail); +) + +RTE_TRACE_POINT( + rte_tm_trace_level_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t level_id, + struct rte_tm_level_capabilities *cap), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(level_id); + rte_trace_point_emit_ptr(cap); +) + +RTE_TRACE_POINT( + rte_tm_trace_mark_ip_dscp, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int mark_green, + int mark_yellow, int mark_red), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(mark_green); + rte_trace_point_emit_int(mark_yellow); + rte_trace_point_emit_int(mark_red); +) + +RTE_TRACE_POINT( + rte_tm_trace_mark_ip_ecn, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int mark_green, + int mark_yellow, int mark_red), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(mark_green); + rte_trace_point_emit_int(mark_yellow); + rte_trace_point_emit_int(mark_red); +) + +RTE_TRACE_POINT( + rte_tm_trace_mark_vlan_dei, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int mark_green, + int mark_yellow, int mark_red), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(mark_green); + rte_trace_point_emit_int(mark_yellow); + rte_trace_point_emit_int(mark_red); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + uint32_t parent_node_id, uint32_t priority, + uint32_t weight, uint32_t level_id, + struct rte_tm_node_params *params), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u32(parent_node_id); + rte_trace_point_emit_u32(priority); + rte_trace_point_emit_u32(weight); + rte_trace_point_emit_u32(level_id); + rte_trace_point_emit_ptr(params); + rte_trace_point_emit_u32(params->shaper_profile_id); + rte_trace_point_emit_u32(params->n_shared_shapers); + rte_trace_point_emit_u64(params->stats_mask); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + struct rte_tm_node_capabilities *cap), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_ptr(cap); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_cman_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + enum rte_tm_cman_mode cman), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_int(cman); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_parent_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + uint32_t parent_node_id, uint32_t priority, + uint32_t weight), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u32(parent_node_id); + rte_trace_point_emit_u32(priority); + rte_trace_point_emit_u32(weight); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_resume, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_shaper_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + uint32_t shaper_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u32(shaper_profile_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_shared_shaper_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + uint32_t shared_shaper_id, int add), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u32(shared_shaper_id); + rte_trace_point_emit_int(add); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_shared_wred_context_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + uint32_t shared_wred_context_id, int add), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u32(shared_wred_context_id); + rte_trace_point_emit_int(add); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_stats_read, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + struct rte_tm_node_stats *stats, + uint64_t *stats_mask, int clear), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_ptr(stats); + rte_trace_point_emit_ptr(stats_mask); + rte_trace_point_emit_int(clear); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_stats_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + uint64_t stats_mask), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u64(stats_mask); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_suspend, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_type_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + int *is_leaf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_ptr(is_leaf); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_wfq_weight_mode_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + int *wfq_weight_mode, uint32_t n_sp_priorities), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_ptr(wfq_weight_mode); + rte_trace_point_emit_u32(n_sp_priorities); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_wred_context_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + uint32_t wred_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u32(wred_profile_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_shaper_profile_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shaper_profile_id, + struct rte_tm_shaper_params *profile), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shaper_profile_id); + rte_trace_point_emit_ptr(profile); + rte_trace_point_emit_u64(profile->committed.rate); + rte_trace_point_emit_u64(profile->committed.size); + rte_trace_point_emit_u64(profile->peak.rate); + rte_trace_point_emit_u64(profile->peak.size); + rte_trace_point_emit_i32(profile->pkt_length_adjust); + rte_trace_point_emit_int(profile->packet_mode); +) + +RTE_TRACE_POINT( + rte_tm_trace_shaper_profile_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shaper_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shaper_profile_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_shared_shaper_add_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shared_shaper_id, + uint32_t shaper_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shared_shaper_id); + rte_trace_point_emit_u32(shaper_profile_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_shared_shaper_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shared_shaper_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shared_shaper_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_shared_wred_context_add_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shared_wred_context_id, + uint32_t wred_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shared_wred_context_id); + rte_trace_point_emit_u32(wred_profile_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_shared_wred_context_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shared_wred_context_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shared_wred_context_id); +) + +RTE_TRACE_POINT( + rte_tm_trace_wred_profile_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t wred_profile_id, + struct rte_tm_wred_params *profile), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(wred_profile_id); + rte_trace_point_emit_ptr(profile); + rte_trace_point_emit_int(profile->packet_mode); +) + +RTE_TRACE_POINT( + rte_tm_trace_wred_profile_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t wred_profile_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(wred_profile_id); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/rte_tm.c b/lib/ethdev/rte_tm.c index 9709454f35..b0b43eacc0 100644 --- a/lib/ethdev/rte_tm.c +++ b/lib/ethdev/rte_tm.c @@ -6,6 +6,7 @@ #include #include "rte_ethdev.h" +#include "rte_ethdev_trace.h" #include "rte_tm_driver.h" #include "rte_tm.h" @@ -79,6 +80,7 @@ rte_tm_get_number_of_leaf_nodes(uint16_t port_id, } *n_leaf_nodes = dev->data->nb_tx_queues; + rte_tm_trace_get_number_of_leaf_nodes(port_id, *n_leaf_nodes, error); return 0; } @@ -90,6 +92,7 @@ rte_tm_node_type_get(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_type_get(port_id, node_id, is_leaf); return RTE_TM_FUNC(port_id, node_type_get)(dev, node_id, is_leaf, error); } @@ -100,6 +103,7 @@ int rte_tm_capabilities_get(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_capabilities_get(port_id, cap); return RTE_TM_FUNC(port_id, capabilities_get)(dev, cap, error); } @@ -111,6 +115,7 @@ int rte_tm_level_capabilities_get(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_level_capabilities_get(port_id, level_id, cap); return RTE_TM_FUNC(port_id, level_capabilities_get)(dev, level_id, cap, error); } @@ -122,6 +127,7 @@ int rte_tm_node_capabilities_get(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_capabilities_get(port_id, node_id, cap); return RTE_TM_FUNC(port_id, node_capabilities_get)(dev, node_id, cap, error); } @@ -133,6 +139,7 @@ int rte_tm_wred_profile_add(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_wred_profile_add(port_id, wred_profile_id, profile); return RTE_TM_FUNC(port_id, wred_profile_add)(dev, wred_profile_id, profile, error); } @@ -143,6 +150,7 @@ int rte_tm_wred_profile_delete(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_wred_profile_delete(port_id, wred_profile_id); return RTE_TM_FUNC(port_id, wred_profile_delete)(dev, wred_profile_id, error); } @@ -154,6 +162,8 @@ int rte_tm_shared_wred_context_add_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_shared_wred_context_add_update(port_id, shared_wred_context_id, + wred_profile_id); return RTE_TM_FUNC(port_id, shared_wred_context_add_update)(dev, shared_wred_context_id, wred_profile_id, error); } @@ -164,6 +174,7 @@ int rte_tm_shared_wred_context_delete(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_shared_wred_context_delete(port_id, shared_wred_context_id); return RTE_TM_FUNC(port_id, shared_wred_context_delete)(dev, shared_wred_context_id, error); } @@ -175,6 +186,7 @@ int rte_tm_shaper_profile_add(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_shaper_profile_add(port_id, shaper_profile_id, profile); return RTE_TM_FUNC(port_id, shaper_profile_add)(dev, shaper_profile_id, profile, error); } @@ -185,6 +197,7 @@ int rte_tm_shaper_profile_delete(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_shaper_profile_delete(port_id, shaper_profile_id); return RTE_TM_FUNC(port_id, shaper_profile_delete)(dev, shaper_profile_id, error); } @@ -196,6 +209,8 @@ int rte_tm_shared_shaper_add_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_shared_shaper_add_update(port_id, shared_shaper_id, + shaper_profile_id); return RTE_TM_FUNC(port_id, shared_shaper_add_update)(dev, shared_shaper_id, shaper_profile_id, error); } @@ -206,6 +221,7 @@ int rte_tm_shared_shaper_delete(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_shared_shaper_delete(port_id, shared_shaper_id); return RTE_TM_FUNC(port_id, shared_shaper_delete)(dev, shared_shaper_id, error); } @@ -221,6 +237,8 @@ int rte_tm_node_add(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_add(port_id, node_id, parent_node_id, priority, + weight, level_id, params); return RTE_TM_FUNC(port_id, node_add)(dev, node_id, parent_node_id, priority, weight, level_id, params, error); @@ -232,6 +250,7 @@ int rte_tm_node_delete(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_delete(port_id, node_id); return RTE_TM_FUNC(port_id, node_delete)(dev, node_id, error); } @@ -242,6 +261,7 @@ int rte_tm_node_suspend(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_suspend(port_id, node_id); return RTE_TM_FUNC(port_id, node_suspend)(dev, node_id, error); } @@ -252,6 +272,7 @@ int rte_tm_node_resume(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_resume(port_id, node_id); return RTE_TM_FUNC(port_id, node_resume)(dev, node_id, error); } @@ -262,6 +283,7 @@ int rte_tm_hierarchy_commit(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_hierarchy_commit(port_id, clear_on_fail); return RTE_TM_FUNC(port_id, hierarchy_commit)(dev, clear_on_fail, error); } @@ -275,6 +297,8 @@ int rte_tm_node_parent_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_parent_update(port_id, node_id, parent_node_id, + priority, weight); return RTE_TM_FUNC(port_id, node_parent_update)(dev, node_id, parent_node_id, priority, weight, error); } @@ -286,6 +310,7 @@ int rte_tm_node_shaper_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_shaper_update(port_id, node_id, shaper_profile_id); return RTE_TM_FUNC(port_id, node_shaper_update)(dev, node_id, shaper_profile_id, error); } @@ -298,6 +323,8 @@ int rte_tm_node_shared_shaper_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_shared_shaper_update(port_id, node_id, shared_shaper_id, + add); return RTE_TM_FUNC(port_id, node_shared_shaper_update)(dev, node_id, shared_shaper_id, add, error); } @@ -309,6 +336,7 @@ int rte_tm_node_stats_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_stats_update(port_id, node_id, stats_mask); return RTE_TM_FUNC(port_id, node_stats_update)(dev, node_id, stats_mask, error); } @@ -321,6 +349,8 @@ int rte_tm_node_wfq_weight_mode_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_wfq_weight_mode_update(port_id, node_id, wfq_weight_mode, + n_sp_priorities); return RTE_TM_FUNC(port_id, node_wfq_weight_mode_update)(dev, node_id, wfq_weight_mode, n_sp_priorities, error); } @@ -332,6 +362,7 @@ int rte_tm_node_cman_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_cman_update(port_id, node_id, cman); return RTE_TM_FUNC(port_id, node_cman_update)(dev, node_id, cman, error); } @@ -343,6 +374,7 @@ int rte_tm_node_wred_context_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_wred_context_update(port_id, node_id, wred_profile_id); return RTE_TM_FUNC(port_id, node_wred_context_update)(dev, node_id, wred_profile_id, error); } @@ -355,6 +387,9 @@ int rte_tm_node_shared_wred_context_update(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_shared_wred_context_update(port_id, node_id, + shared_wred_context_id, + add); return RTE_TM_FUNC(port_id, node_shared_wred_context_update)(dev, node_id, shared_wred_context_id, add, error); } @@ -368,6 +403,8 @@ int rte_tm_node_stats_read(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_node_stats_read(port_id, node_id, stats, stats_mask, + clear); return RTE_TM_FUNC(port_id, node_stats_read)(dev, node_id, stats, stats_mask, clear, error); } @@ -380,6 +417,7 @@ int rte_tm_mark_vlan_dei(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_mark_vlan_dei(port_id, mark_green, mark_yellow, mark_red); return RTE_TM_FUNC(port_id, mark_vlan_dei)(dev, mark_green, mark_yellow, mark_red, error); } @@ -392,6 +430,7 @@ int rte_tm_mark_ip_ecn(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_mark_ip_ecn(port_id, mark_green, mark_yellow, mark_red); return RTE_TM_FUNC(port_id, mark_ip_ecn)(dev, mark_green, mark_yellow, mark_red, error); } @@ -404,6 +443,7 @@ int rte_tm_mark_ip_dscp(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + rte_tm_trace_mark_ip_dscp(port_id, mark_green, mark_yellow, mark_red); return RTE_TM_FUNC(port_id, mark_ip_dscp)(dev, mark_green, mark_yellow, mark_red, error); } diff --git a/lib/ethdev/version.map b/lib/ethdev/version.map index 2e282bb457..ee4012789f 100644 --- a/lib/ethdev/version.map +++ b/lib/ethdev/version.map @@ -490,6 +490,36 @@ EXPERIMENTAL { __rte_mtr_trace_meter_vlan_table_update; __rte_mtr_trace_stats_read; __rte_mtr_trace_stats_update; + __rte_tm_trace_capabilities_get; + __rte_tm_trace_get_number_of_leaf_nodes; + __rte_tm_trace_hierarchy_commit; + __rte_tm_trace_level_capabilities_get; + __rte_tm_trace_mark_ip_dscp; + __rte_tm_trace_mark_ip_ecn; + __rte_tm_trace_mark_vlan_dei; + __rte_tm_trace_node_add; + __rte_tm_trace_node_capabilities_get; + __rte_tm_trace_node_cman_update; + __rte_tm_trace_node_delete; + __rte_tm_trace_node_parent_update; + __rte_tm_trace_node_resume; + __rte_tm_trace_node_shaper_update; + __rte_tm_trace_node_shared_shaper_update; + __rte_tm_trace_node_shared_wred_context_update; + __rte_tm_trace_node_stats_read; + __rte_tm_trace_node_stats_update; + __rte_tm_trace_node_suspend; + __rte_tm_trace_node_type_get; + __rte_tm_trace_node_wfq_weight_mode_update; + __rte_tm_trace_node_wred_context_update; + __rte_tm_trace_shaper_profile_add; + __rte_tm_trace_shaper_profile_delete; + __rte_tm_trace_shared_shaper_add_update; + __rte_tm_trace_shared_shaper_delete; + __rte_tm_trace_shared_wred_context_add_update; + __rte_tm_trace_shared_wred_context_delete; + __rte_tm_trace_wred_profile_add; + __rte_tm_trace_wred_profile_delete; }; INTERNAL { From patchwork Thu Aug 4 13:44:29 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 114621 X-Patchwork-Delegate: andrew.rybchenko@oktetlabs.ru 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 D6A67A00C4; Thu, 4 Aug 2022 15:50:03 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C3A3642BE0; Thu, 4 Aug 2022 15:50:03 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id CF87042BD9 for ; Thu, 4 Aug 2022 15:50:02 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 274CHYfI020978; Thu, 4 Aug 2022 06:47:36 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=W0xEx8RZo+rU+q0PKcBQ061/4mG9OzfImRa64uyA1n4=; b=AzosckasoxGLPeu0WUuU1vofj63QYw/lDenHD8fyH5qhcewKmJurKY/a6oxiGpxzIj3V 4xT7XrYcgozq2f0KRpsiWPO6c4+4hZkPa2OQMhsPt2/0eP5fvYYNE3/xoMMZ82tCeYek e1lM725OT+okqrI14H4thvPr46gc1wLHjITbSJOYgznNas23l+e1j7uDNyN4ZSIvgFXj GwNZRCO/Yy5beDwdGhmtksB/V4yxDQMKcN2rp0oftpx9UERnUjNKYf+Rj2AlYyINJYsU U+j0yaKEvE2sUPK2Ek0E7KZqmIH2b74z6JheyiKbEop4ep91m+D+RraUmb47Udgwr4lW YQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3hqgf1xr7k-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 04 Aug 2022 06:47:36 -0700 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Thu, 4 Aug 2022 06:47:34 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 4 Aug 2022 06:47:34 -0700 Received: from hyd1349.t110.caveonetworks.com.com (unknown [10.29.45.13]) by maili.marvell.com (Postfix) with ESMTP id 791043F705C; Thu, 4 Aug 2022 06:47:13 -0700 (PDT) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH 5/6] ethdev: add trace points for driver Date: Thu, 4 Aug 2022 19:14:29 +0530 Message-ID: <20220804134430.6192-6-adwivedi@marvell.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20220804134430.6192-1-adwivedi@marvell.com> References: <20220804134430.6192-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: gFZ-iJH2smNziLRFb2-vRoIrk5nUWXcK X-Proofpoint-ORIG-GUID: gFZ-iJH2smNziLRFb2-vRoIrk5nUWXcK X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-04_03,2022-08-04_02,2022-06-22_01 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 Adds trace points for ethdev driver specific functions in ethdev lib. Signed-off-by: Ankur Dwivedi --- lib/ethdev/ethdev_driver.c | 29 +++++ lib/ethdev/ethdev_trace_points.c | 66 ++++++++++ lib/ethdev/rte_ethdev_trace.h | 200 +++++++++++++++++++++++++++++++ lib/ethdev/version.map | 22 ++++ 4 files changed, 317 insertions(+) diff --git a/lib/ethdev/ethdev_driver.c b/lib/ethdev/ethdev_driver.c index a285f213f0..74ec57f5fe 100644 --- a/lib/ethdev/ethdev_driver.c +++ b/lib/ethdev/ethdev_driver.c @@ -5,6 +5,7 @@ #include #include +#include "rte_ethdev_trace.h" #include "ethdev_driver.h" #include "ethdev_private.h" @@ -113,6 +114,7 @@ rte_eth_dev_allocate(const char *name) unlock: rte_spinlock_unlock(ð_dev_shared_data->ownership_lock); + rte_ethdev_trace_allocate(name, eth_dev); return eth_dev; } @@ -121,6 +123,7 @@ rte_eth_dev_allocated(const char *name) { struct rte_eth_dev *ethdev; + rte_ethdev_trace_allocated(name); eth_dev_shared_data_prepare(); rte_spinlock_lock(ð_dev_shared_data->ownership_lock); @@ -162,6 +165,7 @@ rte_eth_dev_attach_secondary(const char *name) } rte_spinlock_unlock(ð_dev_shared_data->ownership_lock); + rte_ethdev_trace_attach_secondary(name, eth_dev); return eth_dev; } @@ -173,6 +177,7 @@ rte_eth_dev_callback_process(struct rte_eth_dev *dev, struct rte_eth_dev_callback dev_cb; int rc = 0; + rte_ethdev_trace_callback_process(dev, event, ret_param); rte_spinlock_lock(ð_dev_cb_lock); TAILQ_FOREACH(cb_lst, &(dev->link_intr_cbs), next) { if (cb_lst->cb_fn == NULL || cb_lst->event != event) @@ -195,6 +200,7 @@ rte_eth_dev_callback_process(struct rte_eth_dev *dev, void rte_eth_dev_probing_finish(struct rte_eth_dev *dev) { + rte_ethdev_trace_probing_finish(dev); if (dev == NULL) return; @@ -214,6 +220,7 @@ rte_eth_dev_probing_finish(struct rte_eth_dev *dev) int rte_eth_dev_release_port(struct rte_eth_dev *eth_dev) { + rte_ethdev_trace_release_port(eth_dev); if (eth_dev == NULL) return -EINVAL; @@ -264,6 +271,9 @@ rte_eth_dev_create(struct rte_device *device, const char *name, struct rte_eth_dev *ethdev; int retval; + rte_ethdev_trace_create(device, name, priv_data_size, + ethdev_bus_specific_init, bus_init_params, + ethdev_init, init_params); RTE_FUNC_PTR_OR_ERR_RET(*ethdev_init, -EINVAL); if (rte_eal_process_type() == RTE_PROC_PRIMARY) { @@ -324,6 +334,7 @@ rte_eth_dev_destroy(struct rte_eth_dev *ethdev, { int ret; + rte_ethdev_trace_destroy(ethdev, ethdev_uninit); ethdev = rte_eth_dev_allocated(ethdev->data->name); if (!ethdev) return -ENODEV; @@ -342,6 +353,7 @@ rte_eth_dev_get_by_name(const char *name) { uint16_t pid; + rte_ethdev_trace_get_by_name(name); if (rte_eth_dev_get_port_by_name(name, &pid)) return NULL; @@ -351,6 +363,7 @@ rte_eth_dev_get_by_name(const char *name) int rte_eth_dev_is_rx_hairpin_queue(struct rte_eth_dev *dev, uint16_t queue_id) { + rte_ethdev_trace_is_rx_hairpin_queue(dev, queue_id); if (dev->data->rx_queue_state[queue_id] == RTE_ETH_QUEUE_STATE_HAIRPIN) return 1; return 0; @@ -359,6 +372,7 @@ rte_eth_dev_is_rx_hairpin_queue(struct rte_eth_dev *dev, uint16_t queue_id) int rte_eth_dev_is_tx_hairpin_queue(struct rte_eth_dev *dev, uint16_t queue_id) { + rte_ethdev_trace_is_tx_hairpin_queue(dev, queue_id); if (dev->data->tx_queue_state[queue_id] == RTE_ETH_QUEUE_STATE_HAIRPIN) return 1; return 0; @@ -367,6 +381,7 @@ rte_eth_dev_is_tx_hairpin_queue(struct rte_eth_dev *dev, uint16_t queue_id) void rte_eth_dev_internal_reset(struct rte_eth_dev *dev) { + rte_ethdev_trace_internal_reset(dev, dev->data->dev_started); if (dev->data->dev_started) { RTE_ETHDEV_LOG(ERR, "Port %u must be stopped to allow reset\n", dev->data->port_id); @@ -451,6 +466,7 @@ rte_eth_devargs_parse(const char *dargs, struct rte_eth_devargs *eth_da) unsigned int i; int result = 0; + rte_eth_trace_devargs_parse(dargs, eth_da); memset(eth_da, 0, sizeof(*eth_da)); result = eth_dev_devargs_tokenise(&args, dargs); @@ -495,6 +511,7 @@ rte_eth_dma_zone_free(const struct rte_eth_dev *dev, const char *ring_name, const struct rte_memzone *mz; int rc = 0; + rte_eth_trace_dma_zone_free(dev, ring_name, queue_id); rc = eth_dev_dma_mzone_name(z_name, sizeof(z_name), dev->data->port_id, queue_id, ring_name); if (rc >= RTE_MEMZONE_NAMESIZE) { @@ -520,6 +537,7 @@ rte_eth_dma_zone_reserve(const struct rte_eth_dev *dev, const char *ring_name, const struct rte_memzone *mz; int rc; + rte_eth_trace_dma_zone_reserve(dev, ring_name, queue_id, size, align, socket_id); rc = eth_dev_dma_mzone_name(z_name, sizeof(z_name), dev->data->port_id, queue_id, ring_name); if (rc >= RTE_MEMZONE_NAMESIZE) { @@ -553,6 +571,8 @@ rte_eth_hairpin_queue_peer_bind(uint16_t cur_port, uint16_t cur_queue, { struct rte_eth_dev *dev; + rte_eth_trace_hairpin_queue_peer_bind(cur_port, cur_queue, peer_info, + direction); if (peer_info == NULL) return -EINVAL; @@ -571,6 +591,7 @@ rte_eth_hairpin_queue_peer_unbind(uint16_t cur_port, uint16_t cur_queue, { struct rte_eth_dev *dev; + rte_eth_trace_hairpin_queue_peer_unbind(cur_port, cur_queue, direction); /* No need to check the validity again. */ dev = &rte_eth_devices[cur_port]; RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->hairpin_queue_peer_unbind, @@ -588,6 +609,8 @@ rte_eth_hairpin_queue_peer_update(uint16_t peer_port, uint16_t peer_queue, { struct rte_eth_dev *dev; + rte_eth_trace_hairpin_queue_peer_update(peer_port, peer_queue, cur_info, + peer_info, direction); /* Current queue information is not mandatory. */ if (peer_info == NULL) return -EINVAL; @@ -626,6 +649,8 @@ rte_eth_ip_reassembly_dynfield_register(int *field_offset, int *flag_offset) if (flag_offset != NULL) *flag_offset = offset; + rte_eth_trace_ip_reassembly_dynfield_register(*field_offset, + *flag_offset); return 0; } @@ -729,6 +754,8 @@ rte_eth_representor_id_get(uint16_t port_id, } out: free(info); + rte_eth_trace_representor_id_get(port_id, type, controller, pf, + representor_port, *repr_id); return ret; } @@ -745,6 +772,7 @@ rte_eth_switch_domain_alloc(uint16_t *domain_id) eth_dev_switch_domains[i].state = RTE_ETH_SWITCH_DOMAIN_ALLOCATED; *domain_id = i; + rte_eth_trace_switch_domain_alloc(*domain_id); return 0; } } @@ -755,6 +783,7 @@ rte_eth_switch_domain_alloc(uint16_t *domain_id) int rte_eth_switch_domain_free(uint16_t domain_id) { + rte_eth_trace_switch_domain_free(domain_id); if (domain_id == RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID || domain_id >= RTE_MAX_ETHPORTS) return -EINVAL; diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index 341901d031..61539f379c 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -731,3 +731,69 @@ RTE_TRACE_POINT_REGISTER(rte_tm_trace_wred_profile_add, RTE_TRACE_POINT_REGISTER(rte_tm_trace_wred_profile_delete, lib.ethdev.tm.wred_profile_delete) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_allocate, + lib.ethdev.allocate) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_allocated, + lib.ethdev.allocated) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_attach_secondary, + lib.ethdev.attach_secondary) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_callback_process, + lib.ethdev.callback_process) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_create, + lib.ethdev_create) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_destroy, + lib.ethdev.destroy) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_by_name, + lib.ethdev.get_by_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_is_rx_hairpin_queue, + lib.ethdev.is_rx_hairpin_queue) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_is_tx_hairpin_queue, + lib.ethdev.is_tx_hairpin_queue) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_probing_finish, + lib.ethdev.probing_finish) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_release_port, + lib.ethdev.release_port) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_internal_reset, + lib.ethdev.internal_reset) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_devargs_parse, + lib.ethdev.devargs_parse) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_dma_zone_free, + lib.ethdev.dma_zone_free) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_dma_zone_reserve, + lib.ethdev.dma_zone_reserve) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_hairpin_queue_peer_bind, + lib.ethdev.hairpin_queue_peer_bind) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_hairpin_queue_peer_unbind, + lib.ethdev.hairpin_queue_peer_unbind) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_hairpin_queue_peer_update, + lib.ethdev.hairpin_queue_peer_update) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_ip_reassembly_dynfield_register, + lib.ethdev.ip_reassembly_dynfield_register) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_representor_id_get, + lib.ethdev.representor_id_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_switch_domain_alloc, + lib.ethdev.switch_domain_alloc) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_switch_domain_free, + lib.ethdev.switch_domain_free) diff --git a/lib/ethdev/rte_ethdev_trace.h b/lib/ethdev/rte_ethdev_trace.h index aa34a6a5e9..a3c0b6fa76 100644 --- a/lib/ethdev/rte_ethdev_trace.h +++ b/lib/ethdev/rte_ethdev_trace.h @@ -17,6 +17,7 @@ extern "C" { #include +#include "ethdev_driver.h" #include "rte_ethdev.h" #include "rte_mtr.h" #include "rte_tm.h" @@ -2134,6 +2135,205 @@ RTE_TRACE_POINT( rte_trace_point_emit_u32(wred_profile_id); ) +RTE_TRACE_POINT( + rte_ethdev_trace_allocate, + RTE_TRACE_POINT_ARGS(const char *name, struct rte_eth_dev *eth_dev), + rte_trace_point_emit_string(name); + rte_trace_point_emit_u16(eth_dev->data->nb_rx_queues); + rte_trace_point_emit_u16(eth_dev->data->nb_tx_queues); + rte_trace_point_emit_u16(eth_dev->data->mtu); + rte_trace_point_emit_u16(eth_dev->data->port_id); + rte_trace_point_emit_int(eth_dev->state); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_allocated, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_attach_secondary, + RTE_TRACE_POINT_ARGS(const char *name, struct rte_eth_dev *eth_dev), + rte_trace_point_emit_string(name); + rte_trace_point_emit_u16(eth_dev->data->nb_rx_queues); + rte_trace_point_emit_u16(eth_dev->data->nb_tx_queues); + rte_trace_point_emit_u16(eth_dev->data->mtu); + rte_trace_point_emit_u16(eth_dev->data->port_id); + rte_trace_point_emit_int(eth_dev->state); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_callback_process, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev *dev, + enum rte_eth_event_type event, + void *ret_param), + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_int(event); + rte_trace_point_emit_ptr(ret_param); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_create, + RTE_TRACE_POINT_ARGS(struct rte_device *device, const char *name, + size_t priv_data_size, + ethdev_bus_specific_init bus_specific_init, + void *bus_init_params, ethdev_init_t ethdev_init, + void *init_params), + rte_trace_point_emit_ptr(device); + rte_trace_point_emit_string(name); + rte_trace_point_emit_size_t(priv_data_size); + rte_trace_point_emit_ptr(bus_specific_init); + rte_trace_point_emit_ptr(bus_init_params); + rte_trace_point_emit_ptr(ethdev_init); + rte_trace_point_emit_ptr(init_params); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_destroy, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev *ethdev, ethdev_uninit_t ethdev_uninit), + rte_trace_point_emit_ptr(ethdev); + rte_trace_point_emit_ptr(ethdev_uninit); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_by_name, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_is_rx_hairpin_queue, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev *dev, uint16_t queue_id), + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u16(queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_is_tx_hairpin_queue, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev *dev, uint16_t queue_id), + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u16(queue_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_probing_finish, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev *dev), + rte_trace_point_emit_ptr(dev); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_release_port, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev *eth_dev), + rte_trace_point_emit_ptr(eth_dev); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_internal_reset, + RTE_TRACE_POINT_ARGS(struct rte_eth_dev *dev, + uint8_t dev_started), + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u8(dev_started); +) + +RTE_TRACE_POINT( + rte_eth_trace_devargs_parse, + RTE_TRACE_POINT_ARGS(const char *devargs, struct rte_eth_devargs *eth_devargs), + rte_trace_point_emit_string(devargs); + rte_trace_point_emit_ptr(eth_devargs); + rte_trace_point_emit_u16(eth_devargs->nb_mh_controllers); + rte_trace_point_emit_u16(eth_devargs->nb_ports); + rte_trace_point_emit_u16(eth_devargs->nb_representor_ports); +) + +RTE_TRACE_POINT( + rte_eth_trace_dma_zone_free, + RTE_TRACE_POINT_ARGS(const struct rte_eth_dev *eth_dev, const char *name, + uint16_t queue_id), + rte_trace_point_emit_ptr(eth_dev); + rte_trace_point_emit_string(name); + rte_trace_point_emit_u16(queue_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_dma_zone_reserve, + RTE_TRACE_POINT_ARGS(const struct rte_eth_dev *eth_dev, const char *name, + uint16_t queue_id, size_t size, unsigned int align, + int socket_id), + rte_trace_point_emit_ptr(eth_dev); + rte_trace_point_emit_string(name); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_size_t(size); + rte_trace_point_emit_u32(align); + rte_trace_point_emit_int(socket_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_queue_peer_bind, + RTE_TRACE_POINT_ARGS(uint16_t cur_port, uint16_t cur_queue, + struct rte_hairpin_peer_info *peer_info, + uint32_t direction), + rte_trace_point_emit_u16(cur_port); + rte_trace_point_emit_u16(cur_queue); + rte_trace_point_emit_ptr(peer_info); + rte_trace_point_emit_u32(direction); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_queue_peer_unbind, + RTE_TRACE_POINT_ARGS(uint16_t cur_port, uint16_t cur_queue, + uint32_t direction), + rte_trace_point_emit_u16(cur_port); + rte_trace_point_emit_u16(cur_queue); + rte_trace_point_emit_u32(direction); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_queue_peer_update, + RTE_TRACE_POINT_ARGS(uint16_t peer_port, uint16_t peer_queue, + struct rte_hairpin_peer_info *cur_info, + struct rte_hairpin_peer_info *peer_info, + uint32_t direction), + rte_trace_point_emit_u16(peer_port); + rte_trace_point_emit_u16(peer_queue); + rte_trace_point_emit_ptr(cur_info); + rte_trace_point_emit_ptr(peer_info); + rte_trace_point_emit_u32(direction); +) + +RTE_TRACE_POINT( + rte_eth_trace_ip_reassembly_dynfield_register, + RTE_TRACE_POINT_ARGS(int field_offset, int flag_offset), + rte_trace_point_emit_int(field_offset); + rte_trace_point_emit_int(flag_offset); +) + +RTE_TRACE_POINT( + rte_eth_trace_representor_id_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + enum rte_eth_representor_type type, + int controller, int pf, int representor_port, + uint16_t repr_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(type); + rte_trace_point_emit_int(controller); + rte_trace_point_emit_int(pf); + rte_trace_point_emit_int(representor_port); + rte_trace_point_emit_u16(repr_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_switch_domain_alloc, + RTE_TRACE_POINT_ARGS(uint16_t domain_id), + rte_trace_point_emit_u16(domain_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_switch_domain_free, + RTE_TRACE_POINT_ARGS(uint16_t domain_id), + rte_trace_point_emit_u16(domain_id); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/version.map b/lib/ethdev/version.map index ee4012789f..ee3ff4793d 100644 --- a/lib/ethdev/version.map +++ b/lib/ethdev/version.map @@ -520,6 +520,28 @@ EXPERIMENTAL { __rte_tm_trace_shared_wred_context_delete; __rte_tm_trace_wred_profile_add; __rte_tm_trace_wred_profile_delete; + __rte_ethdev_trace_allocate; + __rte_ethdev_trace_allocated; + __rte_ethdev_trace_attach_secondary; + __rte_ethdev_trace_callback_process; + __rte_ethdev_trace_create; + __rte_ethdev_trace_destroy; + __rte_ethdev_trace_get_by_name; + __rte_ethdev_trace_is_rx_hairpin_queue; + __rte_ethdev_trace_is_tx_hairpin_queue; + __rte_ethdev_trace_probing_finish; + __rte_ethdev_trace_release_port; + __rte_ethdev_trace_internal_reset; + __rte_eth_trace_devargs_parse; + __rte_eth_trace_dma_zone_free; + __rte_eth_trace_dma_zone_reserve; + __rte_eth_trace_hairpin_queue_peer_bind; + __rte_eth_trace_hairpin_queue_peer_unbind; + __rte_eth_trace_hairpin_queue_peer_update; + __rte_eth_trace_ip_reassembly_dynfield_register; + __rte_eth_trace_representor_id_get; + __rte_eth_trace_switch_domain_alloc; + __rte_eth_trace_switch_domain_free; }; INTERNAL { From patchwork Thu Aug 4 13:44:30 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 114622 X-Patchwork-Delegate: andrew.rybchenko@oktetlabs.ru 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 0D676A00C4; Thu, 4 Aug 2022 15:50:24 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id EE09342BDB; Thu, 4 Aug 2022 15:50:23 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 2BF484282B for ; Thu, 4 Aug 2022 15:50:23 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 274Dj2Dr020893; Thu, 4 Aug 2022 06:48:05 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=+5nM1zZfVytYlqWtKajNou6+mxfw77/VB0G2gu3QCjE=; b=dcVGHG5dTz8A620OKlmVomRzFk1i2umqfOH7rx1VYDPw3s5afdPwPSruHs2cAfslUw4q 5vH0nkag2+zKaVnhyzlutZu7306zHYjmnITODYGEOCz3SqFyYFnD7cOQkbetGsR3sfao sfTb/9M9SGUWXNkjYpywb2IkM/UuwtyG+0Nkfe1v+79JT4mFjKMfAcio5vn8QbK3PCVy 1QmSK7jIKvwV6rJo5j8Wpvldgg9x9hKuz4+ek8sSVB943gdyGCMMcLDvuyHH4/KuLLXS sXTL682ev9bhVTjbZYFtSOhjaYVweMiHzgpM/gkuPSD2QUWAlAhgaft68YCu8pcUOxPq uQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3hqgf1xr9g-5 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 04 Aug 2022 06:48:05 -0700 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Thu, 4 Aug 2022 06:48:02 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 4 Aug 2022 06:48:02 -0700 Received: from hyd1349.t110.caveonetworks.com.com (unknown [10.29.45.13]) by maili.marvell.com (Postfix) with ESMTP id 5C73C5B6932; Thu, 4 Aug 2022 06:47:41 -0700 (PDT) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi , Subject: [PATCH 6/6] devtools: add trace function check in checkpatch Date: Thu, 4 Aug 2022 19:14:30 +0530 Message-ID: <20220804134430.6192-7-adwivedi@marvell.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20220804134430.6192-1-adwivedi@marvell.com> References: <20220804134430.6192-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: GNPgkHsABX81LKYCgB1-1HVoG9In8bBZ X-Proofpoint-ORIG-GUID: GNPgkHsABX81LKYCgB1-1HVoG9In8bBZ X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.883,Hydra:6.0.517,FMLib:17.11.122.1 definitions=2022-08-04_03,2022-08-04_02,2022-06-22_01 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 This patch adds a check in checkpatch tool, to check if trace function is added in any new function added in ethdev library. It uses the existing build_map_changes() function and version.map file to create a list of newly added functions. The definition of these functions are checked if they contain trace calls or not. The checkpatch return error if the trace calls are not present. Cc: tduszynski@marvell.com Signed-off-by: Ankur Dwivedi --- devtools/check-symbol-change.sh | 76 +------------------------------- devtools/check-trace-func.py | 52 ++++++++++++++++++++++ devtools/check-trace-func.sh | 50 +++++++++++++++++++++ devtools/checkpatches.sh | 9 ++++ devtools/common-func.sh | 77 +++++++++++++++++++++++++++++++++ 5 files changed, 190 insertions(+), 74 deletions(-) create mode 100755 devtools/check-trace-func.py create mode 100755 devtools/check-trace-func.sh create mode 100644 devtools/common-func.sh diff --git a/devtools/check-symbol-change.sh b/devtools/check-symbol-change.sh index 8992214ac8..4bdd0d727a 100755 --- a/devtools/check-symbol-change.sh +++ b/devtools/check-symbol-change.sh @@ -2,80 +2,8 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2018 Neil Horman -build_map_changes() -{ - local fname="$1" - local mapdb="$2" - - cat "$fname" | awk ' - # Initialize our variables - BEGIN {map="";sym="";ar="";sec=""; in_sec=0; in_map=0} - - # Anything that starts with + or -, followed by an a - # and ends in the string .map is the name of our map file - # This may appear multiple times in a patch if multiple - # map files are altered, and all section/symbol names - # appearing between a triggering of this rule and the - # next trigger of this rule are associated with this file - /[-+] [ab]\/.*\.map/ {map=$2; in_map=1; next} - - # The previous rule catches all .map files, anything else - # indicates we left the map chunk. - /[-+] [ab]\// {in_map=0} - - # Triggering this rule, which starts a line and ends it - # with a { identifies a versioned section. The section name is - # the rest of the line with the + and { symbols removed. - # Triggering this rule sets in_sec to 1, which actives the - # symbol rule below - /^.*{/ { - gsub("+", ""); - if (in_map == 1) { - sec=$(NF-1); in_sec=1; - } - } - - # This rule identifies the end of a section, and disables the - # symbol rule - /.*}/ {in_sec=0} - - # This rule matches on a + followed by any characters except a : - # (which denotes a global vs local segment), and ends with a ;. - # The semicolon is removed and the symbol is printed with its - # association file name and version section, along with an - # indicator that the symbol is a new addition. Note this rule - # only works if we have found a version section in the rule - # above (hence the in_sec check) And found a map file (the - # in_map check). If we are not in a map chunk, do nothing. If - # we are in a map chunk but not a section chunk, record it as - # unknown. - /^+[^}].*[^:*];/ {gsub(";","");sym=$2; - if (in_map == 1) { - if (in_sec == 1) { - print map " " sym " " sec " add" - } else { - print map " " sym " unknown add" - } - } - } - - # This is the same rule as above, but the rule matches on a - # leading - rather than a +, denoting that the symbol is being - # removed. - /^-[^}].*[^:*];/ {gsub(";","");sym=$2; - if (in_map == 1) { - if (in_sec == 1) { - print map " " sym " " sec " del" - } else { - print map " " sym " unknown del" - } - } - }' > "$mapdb" - - sort -u "$mapdb" > "$mapdb.2" - mv -f "$mapdb.2" "$mapdb" - -} +selfdir=$(dirname $(readlink -f $0)) +. $selfdir/common-func.sh is_stable_section() { [ "$1" != 'EXPERIMENTAL' ] && [ "$1" != 'INTERNAL' ] diff --git a/devtools/check-trace-func.py b/devtools/check-trace-func.py new file mode 100755 index 0000000000..d38d8616cd --- /dev/null +++ b/devtools/check-trace-func.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: BSD-3-Clause +# Copyright (C) 2022 Marvell. + +import sys + +patch = sys.argv[1] +fn = sys.argv[2] + +with open(patch, 'r') as fr: + fstr = fr.read() + +def find_fn_def(): + found = 0 + tmp = 0 + idx = 0 + while found == 0: + idx = fstr.find("+"+fn+"(", idx) + if (idx != -1): + tmp = fstr.find(')', idx) + if (fstr[tmp + 1] == ';'): + idx = tmp + continue + else: + found = 1 + else: + break + return idx + +def find_trace(index): + fp = fstr.find("{", index) + sp = fstr.find("}", fp) + fd = fstr[fp:sp] + + i = fd.find("_trace_") + if (i != -1): + return 0 + else: + return 1 + + +def __main(): + ret=0 + index = find_fn_def() + if (index != -1): + # If function definition is present, + # check if trace call is present + ret = find_trace(index) + return ret + +if __name__ == "__main__": + sys.exit(__main()) diff --git a/devtools/check-trace-func.sh b/devtools/check-trace-func.sh new file mode 100755 index 0000000000..777b9a03e0 --- /dev/null +++ b/devtools/check-trace-func.sh @@ -0,0 +1,50 @@ +#!/bin/sh +# SPDX-License-Identifier: BSD-3-Clause +# Copyright (C) 2022 Marvell. + +selfdir=$(dirname $(readlink -f $0)) +. $selfdir/common-func.sh + +libdir="ethdev" +check_for_trace_call() +{ + mapdb="$2" + ret=0 + + while read -r mname symname secname ar; do + libp=0 + libname=$(echo $mname | awk 'BEGIN {FS="/"};{print $3}') + + for i in $libdir; do + if [ $i = $libname ]; then + libp=1 + break + fi + done + + if [ $libp -eq 1 ] && [ "$ar" = "add" ]; then + if [ "$secname" = "EXPERIMENTAL" ]; then + # Check if new API is added with trace function call + if ! devtools/check-trace-func.py $1 $symname; then + ret=1 + echo -n "ERROR: Function $symname " + echo "is added without trace call" + fi + fi + fi + done < "$mapdb" + + return $ret +} + +clean_and_exit_on_sig() +{ + rm -rf "$mapfile" +} + +trap clean_and_exit_on_sig EXIT + +mapfile=$(mktemp -t dpdk.mapdb.XXXXXX) + +build_map_changes "$1" "$mapfile" +check_for_trace_call "$1" "$mapfile" diff --git a/devtools/checkpatches.sh b/devtools/checkpatches.sh index 1edc5810ad..35c47b3e85 100755 --- a/devtools/checkpatches.sh +++ b/devtools/checkpatches.sh @@ -10,6 +10,7 @@ . $(dirname $(readlink -f $0))/load-devel-config VALIDATE_NEW_API=$(dirname $(readlink -f $0))/check-symbol-change.sh +VALIDATE_TRACE_FUNC=$(dirname $(readlink -f $0))/check-trace-func.sh # Enable codespell by default. This can be overwritten from a config file. # Codespell can also be enabled by setting DPDK_CHECKPATCH_CODESPELL to a valid path @@ -338,6 +339,14 @@ check () { # ret=1 fi + ! $verbose || printf '\nChecking API additions with trace function call :\n' + report=$($VALIDATE_TRACE_FUNC "$tmpinput") + if [ $? -ne 0 ] ; then + $headline_printed || print_headline "$3" + printf '%s\n' "$report" + ret=1 + fi + if [ "$tmpinput" != "$1" ]; then rm -f "$tmpinput" trap - INT diff --git a/devtools/common-func.sh b/devtools/common-func.sh new file mode 100644 index 0000000000..c88e949890 --- /dev/null +++ b/devtools/common-func.sh @@ -0,0 +1,77 @@ +#!/bin/sh +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2018 Neil Horman <nhorman@tuxdriver.com> + +build_map_changes() +{ + local fname="$1" + local mapdb="$2" + + cat "$fname" | awk ' + # Initialize our variables + BEGIN {map="";sym="";ar="";sec=""; in_sec=0; in_map=0} + + # Anything that starts with + or -, followed by an a + # and ends in the string .map is the name of our map file + # This may appear multiple times in a patch if multiple + # map files are altered, and all section/symbol names + # appearing between a triggering of this rule and the + # next trigger of this rule are associated with this file + /[-+] [ab]\/.*\.map/ {map=$2; in_map=1; next} + + # The previous rule catches all .map files, anything else + # indicates we left the map chunk. + /[-+] [ab]\// {in_map=0} + + # Triggering this rule, which starts a line and ends it + # with a { identifies a versioned section. The section name is + # the rest of the line with the + and { symbols removed. + # Triggering this rule sets in_sec to 1, which actives the + # symbol rule below + /^.*{/ { + gsub("+", ""); + if (in_map == 1) { + sec=$(NF-1); in_sec=1; + } + } + + # This rule identifies the end of a section, and disables the + # symbol rule + /.*}/ {in_sec=0} + + # This rule matches on a + followed by any characters except a : + # (which denotes a global vs local segment), and ends with a ;. + # The semicolon is removed and the symbol is printed with its + # association file name and version section, along with an + # indicator that the symbol is a new addition. Note this rule + # only works if we have found a version section in the rule + # above (hence the in_sec check) And found a map file (the + # in_map check). If we are not in a map chunk, do nothing. If + # we are in a map chunk but not a section chunk, record it as + # unknown. + /^+[^}].*[^:*];/ {gsub(";","");sym=$2; + if (in_map == 1) { + if (in_sec == 1) { + print map " " sym " " sec " add" + } else { + print map " " sym " unknown add" + } + } + } + + # This is the same rule as above, but the rule matches on a + # leading - rather than a +, denoting that the symbol is being + # removed. + /^-[^}].*[^:*];/ {gsub(";","");sym=$2; + if (in_map == 1) { + if (in_sec == 1) { + print map " " sym " " sec " del" + } else { + print map " " sym " unknown del" + } + } + }' > "$mapdb" + + sort -u "$mapdb" > "$mapdb.2" + mv -f "$mapdb.2" "$mapdb" +}