From patchwork Tue Feb 7 06:32:49 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 123198 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 9436241C2A; Tue, 7 Feb 2023 07:36:14 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 75A874282D; Tue, 7 Feb 2023 07:36:14 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 72DD6427F2 for ; Tue, 7 Feb 2023 07:36:13 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 3174UsZO005847; Mon, 6 Feb 2023 22:33:51 -0800 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-type : content-transfer-encoding; s=pfpt0220; bh=OOmru3ckS18joS39nLiBcBUMHToAWYd7r3gpHqzk//I=; b=GBk3WMbkuZ1dqQjJT/YZsskpis5i5yNHkZUn0kr8u6sC3Rh8xRVpBGJZqUgeMf7eTbAR UhdLpeNwsAjl+vAsVLPELVajDfmukxopCvtBZSbmkiX9YpcTS5HPweYN1ixz6G1ximal lxvpvCFTolV89SQReMViZ/9oqIB1Orjnv8FVxj1KxF/kX+8zSbCPyoX+rT/GjeWKT1Y8 Gq8C5YGEYJRBZRFBgkfpyWC1sEkYsXewhuAa0mDAYMA4uxanSkowZmlc0loYD+mMTeb9 CJBWvq/i+CrxypB/yNTEUOpngBa/x9FqZBzYYyn7dAag0dqTuuXDUWZmj75p0lJPcNw5 kw== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrth9gb-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 06 Feb 2023 22:33:51 -0800 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.42; Mon, 6 Feb 2023 22:33:48 -0800 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.42 via Frontend Transport; Mon, 6 Feb 2023 22:33:48 -0800 Received: from localhost.localdomain (unknown [10.28.36.185]) by maili.marvell.com (Postfix) with ESMTP id D21EB3F7043; Mon, 6 Feb 2023 22:33:26 -0800 (PST) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH v9 1/6] eal: trace: add trace point emit for blob Date: Tue, 7 Feb 2023 12:02:49 +0530 Message-ID: <20230207063254.401538-2-adwivedi@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230207063254.401538-1-adwivedi@marvell.com> References: <20230206115810.308574-1-adwivedi@marvell.com> <20230207063254.401538-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: OpckHknhyjmXXdQt_TPAbf_f-ZR76c-X X-Proofpoint-ORIG-GUID: OpckHknhyjmXXdQt_TPAbf_f-ZR76c-X X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-06_07,2023-02-06_03,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 a trace point emit function for capturing a blob. The blob captures the length passed by the application followed by the array. The maximum blob bytes which can be captured is bounded by RTE_TRACE_BLOB_LEN_MAX macro. The value for max blob length macro is 64 bytes. If the length is less than 64 the remaining trailing bytes are set to zero. This patch also adds test case for emit blob tracepoint function. Signed-off-by: Ankur Dwivedi Acked-by: Morten Brørup Acked-by: Sunil Kumar Kori Acked-by: Jerin Jacob Acked-by: Ferruh Yigit --- app/test/test_trace.c | 11 ++++++++ doc/guides/prog_guide/trace_lib.rst | 12 +++++++++ lib/eal/common/eal_common_trace_points.c | 2 ++ lib/eal/include/rte_eal_trace.h | 6 +++++ lib/eal/include/rte_trace_point.h | 31 ++++++++++++++++++++++ lib/eal/include/rte_trace_point_register.h | 9 +++++++ lib/eal/version.map | 1 + 7 files changed, 72 insertions(+) diff --git a/app/test/test_trace.c b/app/test/test_trace.c index 6bedf14024..ad4a394a29 100644 --- a/app/test/test_trace.c +++ b/app/test/test_trace.c @@ -4,6 +4,7 @@ #include #include +#include #include #include "test.h" @@ -177,7 +178,12 @@ test_fp_trace_points(void) static int test_generic_trace_points(void) { + uint8_t arr[RTE_TRACE_BLOB_LEN_MAX]; int tmp; + int i; + + for (i = 0; i < RTE_TRACE_BLOB_LEN_MAX; i++) + arr[i] = i; rte_eal_trace_generic_void(); rte_eal_trace_generic_u64(0x10000000000000); @@ -195,6 +201,11 @@ test_generic_trace_points(void) rte_eal_trace_generic_ptr(&tmp); rte_eal_trace_generic_str("my string"); rte_eal_trace_generic_size_t(sizeof(void *)); + rte_eal_trace_generic_blob(arr, 0); + rte_eal_trace_generic_blob(arr, 17); + rte_eal_trace_generic_blob(arr, RTE_TRACE_BLOB_LEN_MAX); + rte_eal_trace_generic_blob(arr, rte_rand() % + RTE_TRACE_BLOB_LEN_MAX); RTE_EAL_TRACE_GENERIC_FUNC; return TEST_SUCCESS; diff --git a/doc/guides/prog_guide/trace_lib.rst b/doc/guides/prog_guide/trace_lib.rst index 9a8f38073d..3e0ea5835c 100644 --- a/doc/guides/prog_guide/trace_lib.rst +++ b/doc/guides/prog_guide/trace_lib.rst @@ -352,3 +352,15 @@ event ID. The ``packet.header`` and ``packet.context`` will be written in the slow path at the time of trace memory creation. The ``trace.header`` and trace payload will be emitted when the tracepoint function is invoked. + +Limitations +----------- + +- The ``rte_trace_point_emit_blob()`` function can capture a maximum blob of + length ``RTE_TRACE_BLOB_LEN_MAX`` bytes. The application can call + ``rte_trace_point_emit_blob()`` multiple times with length less than or equal to + ``RTE_TRACE_BLOB_LEN_MAX``, if it needs to capture more than ``RTE_TRACE_BLOB_LEN_MAX`` + bytes. +- If the length passed to the ``rte_trace_point_emit_blob()`` is less than + ``RTE_TRACE_BLOB_LEN_MAX``, then the trailing ``(RTE_TRACE_BLOB_LEN_MAX - len)`` + bytes in the trace are set to zero. diff --git a/lib/eal/common/eal_common_trace_points.c b/lib/eal/common/eal_common_trace_points.c index 0b0b254615..051f89809c 100644 --- a/lib/eal/common/eal_common_trace_points.c +++ b/lib/eal/common/eal_common_trace_points.c @@ -40,6 +40,8 @@ RTE_TRACE_POINT_REGISTER(rte_eal_trace_generic_size_t, lib.eal.generic.size_t) RTE_TRACE_POINT_REGISTER(rte_eal_trace_generic_func, lib.eal.generic.func) +RTE_TRACE_POINT_REGISTER(rte_eal_trace_generic_blob, + lib.eal.generic.blob) RTE_TRACE_POINT_REGISTER(rte_eal_trace_alarm_set, lib.eal.alarm.set) diff --git a/lib/eal/include/rte_eal_trace.h b/lib/eal/include/rte_eal_trace.h index 5ef4398230..6f5c022558 100644 --- a/lib/eal/include/rte_eal_trace.h +++ b/lib/eal/include/rte_eal_trace.h @@ -143,6 +143,12 @@ RTE_TRACE_POINT( rte_trace_point_emit_string(func); ) +RTE_TRACE_POINT( + rte_eal_trace_generic_blob, + RTE_TRACE_POINT_ARGS(const void *in, uint8_t len), + rte_trace_point_emit_blob(in, len); +) + #define RTE_EAL_TRACE_GENERIC_FUNC rte_eal_trace_generic_func(__func__) /* Interrupt */ diff --git a/lib/eal/include/rte_trace_point.h b/lib/eal/include/rte_trace_point.h index 0f8700974f..4d6b5700dd 100644 --- a/lib/eal/include/rte_trace_point.h +++ b/lib/eal/include/rte_trace_point.h @@ -144,6 +144,16 @@ _tp _args \ #define rte_trace_point_emit_ptr(val) /** Tracepoint function payload for string datatype */ #define rte_trace_point_emit_string(val) +/** + * Tracepoint function to capture a blob. + * + * @param val + * Pointer to the array to be captured. + * @param len + * Length to be captured. The maximum supported length is + * RTE_TRACE_BLOB_LEN_MAX bytes. + */ +#define rte_trace_point_emit_blob(val, len) #endif /* __DOXYGEN__ */ @@ -152,6 +162,9 @@ _tp _args \ /** @internal Macro to define event header size. */ #define __RTE_TRACE_EVENT_HEADER_SZ sizeof(uint64_t) +/** Macro to define maximum emit length of blob. */ +#define RTE_TRACE_BLOB_LEN_MAX 64 + /** * Enable recording events of the given tracepoint in the trace buffer. * @@ -374,12 +387,30 @@ do { \ mem = RTE_PTR_ADD(mem, __RTE_TRACE_EMIT_STRING_LEN_MAX); \ } while (0) +#define rte_trace_point_emit_blob(in, len) \ +do { \ + if (unlikely(in == NULL)) \ + return; \ + if (len > RTE_TRACE_BLOB_LEN_MAX) \ + len = RTE_TRACE_BLOB_LEN_MAX; \ + __rte_trace_point_emit(len, uint8_t); \ + memcpy(mem, in, len); \ + memset(RTE_PTR_ADD(mem, len), 0, RTE_TRACE_BLOB_LEN_MAX - len); \ + mem = RTE_PTR_ADD(mem, RTE_TRACE_BLOB_LEN_MAX); \ +} while (0) + #else #define __rte_trace_point_emit_header_generic(t) RTE_SET_USED(t) #define __rte_trace_point_emit_header_fp(t) RTE_SET_USED(t) #define __rte_trace_point_emit(in, type) RTE_SET_USED(in) #define rte_trace_point_emit_string(in) RTE_SET_USED(in) +#define rte_trace_point_emit_blob(in, len) \ +do { \ + RTE_SET_USED(in); \ + RTE_SET_USED(len); \ +} while (0) + #endif /* ALLOW_EXPERIMENTAL_API */ #endif /* _RTE_TRACE_POINT_REGISTER_H_ */ diff --git a/lib/eal/include/rte_trace_point_register.h b/lib/eal/include/rte_trace_point_register.h index a32f4d731b..a9682d3f22 100644 --- a/lib/eal/include/rte_trace_point_register.h +++ b/lib/eal/include/rte_trace_point_register.h @@ -47,6 +47,15 @@ do { \ RTE_STR(in)"[32]", "string_bounded_t"); \ } while (0) +#define rte_trace_point_emit_blob(in, len) \ +do { \ + RTE_SET_USED(in); \ + __rte_trace_point_emit(len, uint8_t); \ + __rte_trace_point_emit_field(RTE_TRACE_BLOB_LEN_MAX, \ + RTE_STR(in)"[" RTE_STR(RTE_TRACE_BLOB_LEN_MAX)"]", \ + RTE_STR(uint8_t)); \ +} while (0) + #ifdef __cplusplus } #endif diff --git a/lib/eal/version.map b/lib/eal/version.map index 6523102157..21aa1b8ce3 100644 --- a/lib/eal/version.map +++ b/lib/eal/version.map @@ -442,6 +442,7 @@ EXPERIMENTAL { # added in 23.03 rte_thread_set_name; + __rte_eal_trace_generic_blob; }; INTERNAL { From patchwork Tue Feb 7 06:32:50 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 123199 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 8852A41C2A; Tue, 7 Feb 2023 07:37:01 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 70A0D41148; Tue, 7 Feb 2023 07:37:01 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id E90B240E6E for ; Tue, 7 Feb 2023 07:36:59 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317569tS013911; Mon, 6 Feb 2023 22:34:23 -0800 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=4gcVbbAfWC/hKXAEyXzl/oxgH/lYoUBNi4ZY3Rx/2FA=; b=CwMNs8azTOGFoa9YYvF2WPL64I9IBbHByeitf5DsC1ZJAh+6EYuS/doKkl3dQjy+CYHC klafSGuPGFg+ZQl6wi5PKDA2zbWL8Aj2HkLME29xCgnTkYMXDrMYw99xLjb4bs7VpvCq erZ0D97S/7zL92OYQqx51/UxENxp2KKQGEQDSUDbSKHxvALx/KX4d4Jwm/msagf1/lVT aFhsDDv86fN/t6/68+Cxuu+li+HeTm6klxfFDrMyf6G/lPk/XSRoP5w8lyE1566bM6GA /3DSYxAo3Mdi8fVT8HdZinH0l+bOlkXNRuEbBIw0ahTIzAe8T7IfTwDG1ciA4sCajl39 Hg== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrth9ky-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 06 Feb 2023 22:34:23 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Mon, 6 Feb 2023 22:34:19 -0800 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.42 via Frontend Transport; Mon, 6 Feb 2023 22:34:19 -0800 Received: from localhost.localdomain (unknown [10.28.36.185]) by maili.marvell.com (Postfix) with ESMTP id EB16B3F7085; Mon, 6 Feb 2023 22:33:55 -0800 (PST) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH v9 2/6] ethdev: add trace points for ethdev (part one) Date: Tue, 7 Feb 2023 12:02:50 +0530 Message-ID: <20230207063254.401538-3-adwivedi@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230207063254.401538-1-adwivedi@marvell.com> References: <20230206115810.308574-1-adwivedi@marvell.com> <20230207063254.401538-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: cjLRpqa7Y-v0tPPbgULbwsWEB-4OfM3w X-Proofpoint-ORIG-GUID: cjLRpqa7Y-v0tPPbgULbwsWEB-4OfM3w X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-06_07,2023-02-06_03,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 functions. The rte_ethdev_trace.h is removed. The file ethdev_trace.h is added as an internal header. ethdev_trace.h contains internal slow path and fast path tracepoints. The public fast path tracepoints are present in rte_ethdev_trace_fp.h header. Signed-off-by: Ankur Dwivedi Acked-by: Sunil Kumar Kori Reviewed-by: Ferruh Yigit --- lib/ethdev/ethdev_private.c | 7 + lib/ethdev/ethdev_trace.h | 642 +++++++++++++++++++++++++++++++ lib/ethdev/ethdev_trace_points.c | 195 +++++++++- lib/ethdev/meson.build | 2 +- lib/ethdev/rte_ethdev.c | 386 ++++++++++++++++--- lib/ethdev/rte_ethdev_trace.h | 95 ----- lib/ethdev/rte_ethdev_trace_fp.h | 36 ++ 7 files changed, 1206 insertions(+), 157 deletions(-) create mode 100644 lib/ethdev/ethdev_trace.h delete mode 100644 lib/ethdev/rte_ethdev_trace.h diff --git a/lib/ethdev/ethdev_private.c b/lib/ethdev/ethdev_private.c index 48090c879a..14ec8c6ccf 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_fp.h" #include "ethdev_driver.h" #include "ethdev_private.h" @@ -297,6 +298,9 @@ rte_eth_call_rx_callbacks(uint16_t port_id, uint16_t queue_id, cb = cb->next; } + rte_eth_trace_call_rx_callbacks(port_id, queue_id, (void **)rx_pkts, + nb_rx, nb_pkts); + return nb_rx; } @@ -312,6 +316,9 @@ rte_eth_call_tx_callbacks(uint16_t port_id, uint16_t queue_id, cb = cb->next; } + rte_eth_trace_call_tx_callbacks(port_id, queue_id, (void **)tx_pkts, + nb_pkts); + return nb_pkts; } diff --git a/lib/ethdev/ethdev_trace.h b/lib/ethdev/ethdev_trace.h new file mode 100644 index 0000000000..a5058f97ea --- /dev/null +++ b/lib/ethdev/ethdev_trace.h @@ -0,0 +1,642 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2023 Marvell International Ltd. + */ + +#ifndef _RTE_ETHDEV_TRACE_H_ +#define _RTE_ETHDEV_TRACE_H_ + +/** + * @file + * + * API for ethdev trace support + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "rte_ethdev.h" + +RTE_TRACE_POINT( + rte_ethdev_trace_configure, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t nb_rx_q, + uint16_t nb_tx_q, const struct rte_eth_conf *dev_conf, int rc), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(nb_rx_q); + rte_trace_point_emit_u16(nb_tx_q); + rte_trace_point_emit_u32(dev_conf->link_speeds); + rte_trace_point_emit_u32(dev_conf->rxmode.mq_mode); + rte_trace_point_emit_u32(dev_conf->rxmode.mtu); + rte_trace_point_emit_u64(dev_conf->rxmode.offloads); + rte_trace_point_emit_u32(dev_conf->txmode.mq_mode); + rte_trace_point_emit_u64(dev_conf->txmode.offloads); + rte_trace_point_emit_u32(dev_conf->lpbk_mode); + rte_trace_point_emit_int(rc); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rxq_setup, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, + uint16_t nb_rx_desc, void *mp, + const struct rte_eth_rxconf *rx_conf, int rc), + 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(mp); + rte_trace_point_emit_u8(rx_conf->rx_thresh.pthresh); + rte_trace_point_emit_u8(rx_conf->rx_thresh.hthresh); + rte_trace_point_emit_u8(rx_conf->rx_thresh.wthresh); + rte_trace_point_emit_u8(rx_conf->rx_drop_en); + rte_trace_point_emit_u8(rx_conf->rx_deferred_start); + rte_trace_point_emit_u64(rx_conf->offloads); + rte_trace_point_emit_int(rc); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_txq_setup, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id, + uint16_t nb_tx_desc, 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_u8(tx_conf->tx_thresh.pthresh); + rte_trace_point_emit_u8(tx_conf->tx_thresh.hthresh); + rte_trace_point_emit_u8(tx_conf->tx_thresh.wthresh); + rte_trace_point_emit_u8(tx_conf->tx_deferred_start); + rte_trace_point_emit_u16(tx_conf->tx_free_thresh); + rte_trace_point_emit_u64(tx_conf->offloads); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_start, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_stop, + 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_close, + RTE_TRACE_POINT_ARGS(uint16_t port_id), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_eth_trace_iterator_init, + RTE_TRACE_POINT_ARGS(const char *devargs), + rte_trace_point_emit_string(devargs); +) + +RTE_TRACE_POINT( + rte_eth_trace_iterator_next, + RTE_TRACE_POINT_ARGS(const struct rte_dev_iterator *iter, uint16_t id), + rte_trace_point_emit_ptr(iter); + rte_trace_point_emit_string(iter->bus_str); + rte_trace_point_emit_string(iter->cls_str); + rte_trace_point_emit_u16(id); +) + +RTE_TRACE_POINT( + rte_eth_trace_iterator_cleanup, + RTE_TRACE_POINT_ARGS(const struct rte_dev_iterator *iter), + rte_trace_point_emit_ptr(iter); + rte_trace_point_emit_string(iter->bus_str); + rte_trace_point_emit_string(iter->cls_str); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(owner->id); + rte_trace_point_emit_string(owner->name); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_owner_unset, + RTE_TRACE_POINT_ARGS(const uint16_t port_id, + const uint64_t owner_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(owner_id); + rte_trace_point_emit_int(ret); +) + +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_socket_id, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int socket_id), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(socket_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_queue_start, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_queue_stop, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_tx_queue_start, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tx_queue_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_tx_queue_stop, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(tx_queue_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_speed_bitflag, + RTE_TRACE_POINT_ARGS(uint32_t speed, int duplex, uint32_t ret), + rte_trace_point_emit_u32(speed); + rte_trace_point_emit_int(duplex); + rte_trace_point_emit_u32(ret); +) + +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_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_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_set_link_up, + 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_set_link_down, + 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_reset, + 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_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, + int ret), + uint16_t peer_count = conf->peer_count; + uint8_t tx_explicit = conf->tx_explicit; + uint8_t manual_bind = conf->manual_bind; + uint8_t use_locked_device_memory = conf->use_locked_device_memory; + uint8_t use_rte_memory = conf->use_rte_memory; + uint8_t force_memory = conf->force_memory; + + 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_emit_u16(peer_count); + rte_trace_point_emit_u8(tx_explicit); + rte_trace_point_emit_u8(manual_bind); + rte_trace_point_emit_u8(use_locked_device_memory); + rte_trace_point_emit_u8(use_rte_memory); + rte_trace_point_emit_u8(force_memory); + rte_trace_point_emit_int(ret); +) + +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, + int ret), + uint16_t peer_count = conf->peer_count; + uint8_t tx_explicit = conf->tx_explicit; + uint8_t manual_bind = conf->manual_bind; + uint8_t use_locked_device_memory = conf->use_locked_device_memory; + uint8_t use_rte_memory = conf->use_rte_memory; + uint8_t force_memory = conf->force_memory; + + 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_emit_u16(peer_count); + rte_trace_point_emit_u8(tx_explicit); + rte_trace_point_emit_u8(manual_bind); + rte_trace_point_emit_u8(use_locked_device_memory); + rte_trace_point_emit_u8(use_rte_memory); + rte_trace_point_emit_u8(force_memory); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_bind, + RTE_TRACE_POINT_ARGS(uint16_t tx_port, uint16_t rx_port, int ret), + rte_trace_point_emit_u16(tx_port); + rte_trace_point_emit_u16(rx_port); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_hairpin_unbind, + RTE_TRACE_POINT_ARGS(uint16_t tx_port, uint16_t rx_port, int ret), + rte_trace_point_emit_u16(tx_port); + rte_trace_point_emit_u16(rx_port); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_buffer_set_err_callback, + RTE_TRACE_POINT_ARGS(const struct rte_eth_dev_tx_buffer *buffer), + rte_trace_point_emit_ptr(buffer); + rte_trace_point_emit_ptr(buffer->error_callback); + rte_trace_point_emit_ptr(buffer->error_userdata); +) + +RTE_TRACE_POINT( + rte_eth_trace_promiscuous_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int promiscuous, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(promiscuous); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_promiscuous_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int promiscuous, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(promiscuous); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_allmulticast_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int all_multicast, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(all_multicast); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_allmulticast_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int all_multicast, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(all_multicast); + rte_trace_point_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_fw_version_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const char *fw_version, + size_t fw_size, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(fw_version); + rte_trace_point_emit_size_t(fw_size); + rte_trace_point_emit_int(ret); +) + +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, const struct rte_device *parent), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(parent->name); + rte_trace_point_emit_string(parent->bus_info); + rte_trace_point_emit_int(parent->numa_node); +) + +RTE_TRACE_POINT( + rte_eth_trace_find_next_sibling, + RTE_TRACE_POINT_ARGS(uint16_t port_id_start, uint16_t ref_port_id, + uint16_t ret), + rte_trace_point_emit_u16(port_id_start); + rte_trace_point_emit_u16(ref_port_id); + rte_trace_point_emit_u16(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_is_valid_port, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int is_valid), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(is_valid); +) + +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_ethdev_trace_owner_get, + 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_get_sec_ctx, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const void *ctx), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(ctx); +) + +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, const 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_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_eth_trace_hairpin_get_peer_ports, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint16_t *peer_ports, + size_t len, uint32_t direction, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_buffer_init, + RTE_TRACE_POINT_ARGS(const struct rte_eth_dev_tx_buffer *buffer, + uint16_t size, int ret), + rte_trace_point_emit_ptr(buffer); + rte_trace_point_emit_u16(size); + rte_trace_point_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_u32(free_cnt); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_promiscuous_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int promiscuous), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(promiscuous); +) + +RTE_TRACE_POINT( + rte_eth_trace_allmulticast_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int all_multicast), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(all_multicast); +) + +RTE_TRACE_POINT( + rte_eth_trace_link_get_nowait, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct rte_eth_link *link), + uint8_t link_duplex = link->link_duplex; + uint8_t link_autoneg = link->link_autoneg; + uint8_t link_status = link->link_status; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(link->link_speed); + rte_trace_point_emit_u8(link_duplex); + rte_trace_point_emit_u8(link_autoneg); + rte_trace_point_emit_u8(link_status); +) + +RTE_TRACE_POINT( + rte_eth_trace_link_to_str, + RTE_TRACE_POINT_ARGS(size_t len, const struct rte_eth_link *link, + char *str, int ret), + uint8_t link_duplex = link->link_duplex; + uint8_t link_autoneg = link->link_autoneg; + uint8_t link_status = link->link_status; + + rte_trace_point_emit_size_t(len); + rte_trace_point_emit_u32(link->link_speed); + rte_trace_point_emit_u8(link_duplex); + rte_trace_point_emit_u8(link_autoneg); + rte_trace_point_emit_u8(link_status); + rte_trace_point_emit_string(str); + rte_trace_point_emit_int(ret); +) + +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_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_u64(id); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_get_names_by_id, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const 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_get_names, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int i, + 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_int(i); + 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_by_id, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *ids, + const 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, + RTE_TRACE_POINT_ARGS(uint16_t port_id, struct rte_eth_xstat xstats), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u64(xstats.id); + rte_trace_point_emit_u64(xstats.value); +) + +RTE_TRACE_POINT( + rte_eth_trace_xstats_reset, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(ret); +) + +/* Fast path trace points */ + +/* Called in loop in examples/qos_sched and examples/distributor */ +RTE_TRACE_POINT_FP( + rte_eth_trace_stats_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_stats *stats, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(stats); + rte_trace_point_emit_u64(stats->rx_nombuf); + rte_trace_point_emit_u64(stats->ipackets); + rte_trace_point_emit_u64(stats->opackets); + rte_trace_point_emit_u64(stats->ibytes); + rte_trace_point_emit_u64(stats->obytes); + rte_trace_point_emit_u64(stats->imissed); + rte_trace_point_emit_u64(stats->ierrors); + rte_trace_point_emit_u64(stats->oerrors); + rte_trace_point_emit_int(ret); +) + +/* Called in loop in examples/ip_pipeline */ +RTE_TRACE_POINT_FP( + rte_eth_trace_link_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct rte_eth_link *link), + uint8_t link_duplex = link->link_duplex; + uint8_t link_autoneg = link->link_autoneg; + uint8_t link_status = link->link_status; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(link->link_speed); + rte_trace_point_emit_u8(link_duplex); + rte_trace_point_emit_u8(link_autoneg); + rte_trace_point_emit_u8(link_status); +) + +/* Called in loop in examples/ip_pipeline */ +RTE_TRACE_POINT_FP( + rte_eth_trace_link_speed_to_str, + RTE_TRACE_POINT_ARGS(uint32_t link_speed, const char *ret), + rte_trace_point_emit_u32(link_speed); + rte_trace_point_emit_string(ret); +) + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_ETHDEV_TRACE_H_ */ diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index 2919409a15..3e58c679c3 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -4,7 +4,8 @@ #include -#include +#include +#include RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_configure, lib.ethdev.configure) @@ -29,3 +30,195 @@ 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_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_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_iterator_cleanup, + lib.ethdev.iterator_cleanup) + +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_sibling, + lib.ethdev.find_next_sibling) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_is_valid_port, + lib.ethdev.is_valid_port) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_find_next_owned_by, + lib.ethdev.find_next_owned_by) + +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_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_socket_id, + lib.ethdev.socket_id) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_sec_ctx, + lib.ethdev.get_sec_ctx) + +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_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_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_eth_trace_speed_bitflag, + lib.ethdev.speed_bitflag) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_offload_name, + lib.ethdev.rx_offload_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_tx_offload_name, + lib.ethdev.tx_offload_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_capability_name, + lib.ethdev.capability_name) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_link_up, + lib.ethdev.set_link_up) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_link_down, + lib.ethdev.set_link_down) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_reset, + lib.ethdev.reset) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_is_removed, + lib.ethdev.is_removed) + +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_unbind, + lib.ethdev.hairpin_unbind) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_hairpin_get_peer_ports, + lib.ethdev.hairpin_get_peer_ports) + +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_count_callback, + lib.ethdev.tx_buffer_count_callback) + +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_buffer_init, + lib.ethdev.tx_buffer_init) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_done_cleanup, + lib.ethdev.tx_done_cleanup) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_promiscuous_enable, + lib.ethdev.promiscuous_enable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_promiscuous_disable, + lib.ethdev.promiscuous_disable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_promiscuous_get, + lib.ethdev.promiscuous_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_allmulticast_enable, + lib.ethdev.allmulticast_enable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_allmulticast_disable, + lib.ethdev.allmulticast_disable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_allmulticast_get, + lib.ethdev.allmulticast_get) + +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_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_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_xstats_get_id_by_name, + lib.ethdev.xstats_get_id_by_name) + +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_get_names, + lib.ethdev.xstats_get_names) + +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, + lib.ethdev.xstats_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_xstats_reset, + lib.ethdev.xstats_reset) + +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_rx_queue_stats_mapping, + lib.ethdev.set_rx_queue_stats_mapping) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_fw_version_get, + lib.ethdev.fw_version_get) diff --git a/lib/ethdev/meson.build b/lib/ethdev/meson.build index 39250b5da1..7835c96601 100644 --- a/lib/ethdev/meson.build +++ b/lib/ethdev/meson.build @@ -22,7 +22,6 @@ sources = files( headers = files( 'rte_cman.h', 'rte_ethdev.h', - 'rte_ethdev_trace.h', 'rte_ethdev_trace_fp.h', 'rte_dev_info.h', 'rte_flow.h', @@ -41,6 +40,7 @@ indirect_headers += files( driver_sdk_headers += files( 'ethdev_driver.h', 'ethdev_pci.h', + 'ethdev_trace.h', 'ethdev_vdev.h', ) diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c index 5d5e18db1e..731ce7f27e 100644 --- a/lib/ethdev/rte_ethdev.c +++ b/lib/ethdev/rte_ethdev.c @@ -27,11 +27,12 @@ #include #include -#include "rte_ethdev_trace.h" #include "rte_ethdev.h" +#include "rte_ethdev_trace_fp.h" #include "ethdev_driver.h" #include "ethdev_profile.h" #include "ethdev_private.h" +#include "ethdev_trace.h" #include "sff_telemetry.h" struct rte_eth_dev rte_eth_devices[RTE_MAX_ETHPORTS]; @@ -259,6 +260,9 @@ rte_eth_iterator_init(struct rte_dev_iterator *iter, const char *devargs_str) end: iter->cls = rte_class_find_by_name("eth"); rte_devargs_reset(&devargs); + + rte_eth_trace_iterator_init(devargs_str); + return 0; error: @@ -297,8 +301,13 @@ rte_eth_iterator_next(struct rte_dev_iterator *iter) /* A device is matching bus part, need to check ethdev part. */ iter->class_device = iter->cls->dev_iterate( iter->class_device, iter->cls_str, iter); - if (iter->class_device != NULL) - return eth_dev_to_id(iter->class_device); /* match */ + if (iter->class_device != NULL) { + uint16_t id = eth_dev_to_id(iter->class_device); + + rte_eth_trace_iterator_next(iter, id); + + return id; /* match */ + } } while (iter->bus != NULL); /* need to try next rte_device */ /* No more ethdev port to iterate. */ @@ -316,6 +325,9 @@ rte_eth_iterator_cleanup(struct rte_dev_iterator *iter) if (iter->bus_str == NULL) return; /* nothing to free in pure class filter */ + + rte_eth_trace_iterator_cleanup(iter); + free(RTE_CAST_FIELD(iter, bus_str, char *)); /* workaround const */ free(RTE_CAST_FIELD(iter, cls_str, char *)); /* workaround const */ memset(iter, 0, sizeof(*iter)); @@ -331,6 +343,8 @@ rte_eth_find_next(uint16_t port_id) if (port_id >= RTE_MAX_ETHPORTS) return RTE_MAX_ETHPORTS; + rte_eth_trace_find_next(port_id); + return port_id; } @@ -351,15 +365,23 @@ rte_eth_find_next_of(uint16_t port_id, const struct rte_device *parent) rte_eth_devices[port_id].device != parent) port_id = rte_eth_find_next(port_id + 1); + rte_eth_trace_find_next_of(port_id, parent); + return port_id; } uint16_t rte_eth_find_next_sibling(uint16_t port_id, uint16_t ref_port_id) { + uint16_t ret; + RTE_ETH_VALID_PORTID_OR_ERR_RET(ref_port_id, RTE_MAX_ETHPORTS); - return rte_eth_find_next_of(port_id, + ret = rte_eth_find_next_of(port_id, rte_eth_devices[ref_port_id].device); + + rte_eth_trace_find_next_sibling(port_id, ref_port_id, ret); + + return ret; } static bool @@ -371,11 +393,17 @@ eth_dev_is_allocated(const struct rte_eth_dev *ethdev) int rte_eth_dev_is_valid_port(uint16_t port_id) { + int is_valid; + if (port_id >= RTE_MAX_ETHPORTS || (rte_eth_devices[port_id].state == RTE_ETH_DEV_UNUSED)) - return 0; + is_valid = 0; else - return 1; + is_valid = 1; + + rte_ethdev_trace_is_valid_port(port_id, is_valid); + + return is_valid; } static int @@ -395,6 +423,8 @@ rte_eth_find_next_owned_by(uint16_t port_id, const uint64_t owner_id) rte_eth_devices[port_id].data->owner.id != owner_id) port_id = rte_eth_find_next(port_id + 1); + rte_eth_trace_find_next_owned_by(port_id, owner_id); + return port_id; } @@ -413,6 +443,9 @@ 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; } @@ -476,6 +509,9 @@ rte_eth_dev_owner_set(const uint16_t port_id, ret = eth_dev_owner_set(port_id, RTE_ETH_DEV_NO_OWNER, owner); rte_spinlock_unlock(ð_dev_shared_data->ownership_lock); + + rte_ethdev_trace_owner_set(port_id, owner, ret); + return ret; } @@ -493,6 +529,9 @@ rte_eth_dev_owner_unset(const uint16_t port_id, const uint64_t owner_id) ret = eth_dev_owner_set(port_id, owner_id, &new_owner); rte_spinlock_unlock(ð_dev_shared_data->ownership_lock); + + rte_ethdev_trace_owner_unset(port_id, owner_id, ret); + return ret; } @@ -526,6 +565,8 @@ 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; } @@ -555,6 +596,8 @@ 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; } @@ -570,14 +613,23 @@ rte_eth_dev_socket_id(uint16_t port_id) if (socket_id == SOCKET_ID_ANY) rte_errno = 0; } + + rte_ethdev_trace_socket_id(port_id, socket_id); + return socket_id; } void * rte_eth_dev_get_sec_ctx(uint16_t port_id) { + void *ctx; + RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, NULL); - return rte_eth_devices[port_id].security_ctx; + ctx = rte_eth_devices[port_id].security_ctx; + + rte_ethdev_trace_get_sec_ctx(port_id, ctx); + + return ctx; } uint16_t @@ -591,6 +643,8 @@ rte_eth_dev_count_avail(void) RTE_ETH_FOREACH_DEV(p) count++; + rte_ethdev_trace_count_avail(count); + return count; } @@ -602,6 +656,8 @@ rte_eth_dev_count_total(void) RTE_ETH_FOREACH_VALID_DEV(port) count++; + rte_ethdev_trace_count_total(count); + return count; } @@ -622,6 +678,9 @@ 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; } @@ -644,6 +703,9 @@ 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; } @@ -745,7 +807,11 @@ rte_eth_dev_rx_queue_start(uint16_t port_id, uint16_t rx_queue_id) return 0; } - return eth_err(port_id, dev->dev_ops->rx_queue_start(dev, rx_queue_id)); + ret = eth_err(port_id, dev->dev_ops->rx_queue_start(dev, rx_queue_id)); + + rte_ethdev_trace_rx_queue_start(port_id, rx_queue_id, ret); + + return ret; } int @@ -778,7 +844,11 @@ rte_eth_dev_rx_queue_stop(uint16_t port_id, uint16_t rx_queue_id) return 0; } - return eth_err(port_id, dev->dev_ops->rx_queue_stop(dev, rx_queue_id)); + ret = eth_err(port_id, dev->dev_ops->rx_queue_stop(dev, rx_queue_id)); + + rte_ethdev_trace_rx_queue_stop(port_id, rx_queue_id, ret); + + return ret; } int @@ -818,7 +888,11 @@ rte_eth_dev_tx_queue_start(uint16_t port_id, uint16_t tx_queue_id) return 0; } - return eth_err(port_id, dev->dev_ops->tx_queue_start(dev, tx_queue_id)); + ret = eth_err(port_id, dev->dev_ops->tx_queue_start(dev, tx_queue_id)); + + rte_ethdev_trace_tx_queue_start(port_id, tx_queue_id, ret); + + return ret; } int @@ -851,42 +925,65 @@ rte_eth_dev_tx_queue_stop(uint16_t port_id, uint16_t tx_queue_id) return 0; } - return eth_err(port_id, dev->dev_ops->tx_queue_stop(dev, tx_queue_id)); + ret = eth_err(port_id, dev->dev_ops->tx_queue_stop(dev, tx_queue_id)); + + rte_ethdev_trace_tx_queue_stop(port_id, tx_queue_id, ret); + + return ret; } uint32_t rte_eth_speed_bitflag(uint32_t speed, int duplex) { + uint32_t ret; + switch (speed) { case RTE_ETH_SPEED_NUM_10M: - return duplex ? RTE_ETH_LINK_SPEED_10M : RTE_ETH_LINK_SPEED_10M_HD; + ret = duplex ? RTE_ETH_LINK_SPEED_10M : RTE_ETH_LINK_SPEED_10M_HD; + break; case RTE_ETH_SPEED_NUM_100M: - return duplex ? RTE_ETH_LINK_SPEED_100M : RTE_ETH_LINK_SPEED_100M_HD; + ret = duplex ? RTE_ETH_LINK_SPEED_100M : RTE_ETH_LINK_SPEED_100M_HD; + break; case RTE_ETH_SPEED_NUM_1G: - return RTE_ETH_LINK_SPEED_1G; + ret = RTE_ETH_LINK_SPEED_1G; + break; case RTE_ETH_SPEED_NUM_2_5G: - return RTE_ETH_LINK_SPEED_2_5G; + ret = RTE_ETH_LINK_SPEED_2_5G; + break; case RTE_ETH_SPEED_NUM_5G: - return RTE_ETH_LINK_SPEED_5G; + ret = RTE_ETH_LINK_SPEED_5G; + break; case RTE_ETH_SPEED_NUM_10G: - return RTE_ETH_LINK_SPEED_10G; + ret = RTE_ETH_LINK_SPEED_10G; + break; case RTE_ETH_SPEED_NUM_20G: - return RTE_ETH_LINK_SPEED_20G; + ret = RTE_ETH_LINK_SPEED_20G; + break; case RTE_ETH_SPEED_NUM_25G: - return RTE_ETH_LINK_SPEED_25G; + ret = RTE_ETH_LINK_SPEED_25G; + break; case RTE_ETH_SPEED_NUM_40G: - return RTE_ETH_LINK_SPEED_40G; + ret = RTE_ETH_LINK_SPEED_40G; + break; case RTE_ETH_SPEED_NUM_50G: - return RTE_ETH_LINK_SPEED_50G; + ret = RTE_ETH_LINK_SPEED_50G; + break; case RTE_ETH_SPEED_NUM_56G: - return RTE_ETH_LINK_SPEED_56G; + ret = RTE_ETH_LINK_SPEED_56G; + break; case RTE_ETH_SPEED_NUM_100G: - return RTE_ETH_LINK_SPEED_100G; + ret = RTE_ETH_LINK_SPEED_100G; + break; case RTE_ETH_SPEED_NUM_200G: - return RTE_ETH_LINK_SPEED_200G; + ret = RTE_ETH_LINK_SPEED_200G; + break; default: - return 0; + ret = 0; } + + rte_eth_trace_speed_bitflag(speed, duplex, ret); + + return ret; } const char * @@ -902,6 +999,8 @@ rte_eth_dev_rx_offload_name(uint64_t offload) } } + rte_ethdev_trace_rx_offload_name(offload, name); + return name; } @@ -918,6 +1017,8 @@ rte_eth_dev_tx_offload_name(uint64_t offload) } } + rte_ethdev_trace_tx_offload_name(offload, name); + return name; } @@ -934,6 +1035,8 @@ rte_eth_dev_capability_name(uint64_t capability) } } + rte_ethdev_trace_capability_name(capability, name); + return name; } @@ -1554,26 +1657,36 @@ int rte_eth_dev_set_link_up(uint16_t port_id) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->dev_set_link_up == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->dev_set_link_up)(dev)); + ret = eth_err(port_id, (*dev->dev_ops->dev_set_link_up)(dev)); + + rte_ethdev_trace_set_link_up(port_id, ret); + + return ret; } int rte_eth_dev_set_link_down(uint16_t port_id) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->dev_set_link_down == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->dev_set_link_down)(dev)); + ret = eth_err(port_id, (*dev->dev_ops->dev_set_link_down)(dev)); + + rte_ethdev_trace_set_link_down(port_id, ret); + + return ret; } int @@ -1628,9 +1741,11 @@ rte_eth_dev_reset(uint16_t port_id) "Failed to stop device (port %u) before reset: %s - ignore\n", port_id, rte_strerror(-ret)); } - ret = dev->dev_ops->dev_reset(dev); + ret = eth_err(port_id, dev->dev_ops->dev_reset(dev)); - return eth_err(port_id, ret); + rte_ethdev_trace_reset(port_id, ret); + + return ret; } int @@ -1653,6 +1768,8 @@ 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; } @@ -2151,7 +2268,12 @@ rte_eth_rx_hairpin_queue_setup(uint16_t port_id, uint16_t rx_queue_id, if (ret == 0) dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_HAIRPIN; - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_eth_trace_rx_hairpin_queue_setup(port_id, rx_queue_id, nb_rx_desc, + conf, ret); + + return ret; } int @@ -2340,7 +2462,12 @@ rte_eth_tx_hairpin_queue_setup(uint16_t port_id, uint16_t tx_queue_id, if (ret == 0) dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_HAIRPIN; - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_eth_trace_tx_hairpin_queue_setup(port_id, tx_queue_id, nb_tx_desc, + conf, ret); + + return ret; } int @@ -2365,6 +2492,8 @@ rte_eth_hairpin_bind(uint16_t tx_port, uint16_t rx_port) " to Rx %d (%d - all ports)\n", tx_port, rx_port, RTE_MAX_ETHPORTS); + rte_eth_trace_hairpin_bind(tx_port, rx_port, ret); + return ret; } @@ -2390,6 +2519,8 @@ rte_eth_hairpin_unbind(uint16_t tx_port, uint16_t rx_port) " from Rx %d (%d - all ports)\n", tx_port, rx_port, RTE_MAX_ETHPORTS); + rte_eth_trace_hairpin_unbind(tx_port, rx_port, ret); + return ret; } @@ -2426,6 +2557,9 @@ rte_eth_hairpin_get_peer_ports(uint16_t port_id, uint16_t *peer_ports, RTE_ETHDEV_LOG(ERR, "Failed to get %d hairpin peer %s ports\n", port_id, direction ? "Rx" : "Tx"); + rte_eth_trace_hairpin_get_peer_ports(port_id, peer_ports, len, + direction, ret); + return ret; } @@ -2434,6 +2568,8 @@ rte_eth_tx_buffer_drop_callback(struct rte_mbuf **pkts, uint16_t unsent, void *userdata __rte_unused) { rte_pktmbuf_free_bulk(pkts, unsent); + + rte_eth_trace_tx_buffer_drop_callback((void **)pkts, unsent); } void @@ -2444,6 +2580,8 @@ 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((void **)pkts, unsent, *count); } int @@ -2458,6 +2596,9 @@ rte_eth_tx_buffer_set_err_callback(struct rte_eth_dev_tx_buffer *buffer, buffer->error_callback = cbfn; buffer->error_userdata = userdata; + + rte_eth_trace_tx_buffer_set_err_callback(buffer); + return 0; } @@ -2477,6 +2618,8 @@ rte_eth_tx_buffer_init(struct rte_eth_dev_tx_buffer *buffer, uint16_t size) buffer, rte_eth_tx_buffer_drop_callback, NULL); } + rte_eth_trace_tx_buffer_init(buffer, size, ret); + return ret; } @@ -2495,7 +2638,11 @@ rte_eth_tx_done_cleanup(uint16_t port_id, uint16_t queue_id, uint32_t free_cnt) /* Call driver to free pending mbufs. */ ret = (*dev->dev_ops->tx_done_cleanup)(dev->data->tx_queues[queue_id], free_cnt); - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_eth_trace_tx_done_cleanup(port_id, queue_id, free_cnt, ret); + + return ret; } int @@ -2516,7 +2663,12 @@ rte_eth_promiscuous_enable(uint16_t port_id) diag = (*dev->dev_ops->promiscuous_enable)(dev); dev->data->promiscuous = (diag == 0) ? 1 : 0; - return eth_err(port_id, diag); + diag = eth_err(port_id, diag); + + rte_eth_trace_promiscuous_enable(port_id, dev->data->promiscuous, + diag); + + return diag; } int @@ -2539,7 +2691,12 @@ rte_eth_promiscuous_disable(uint16_t port_id) if (diag != 0) dev->data->promiscuous = 1; - return eth_err(port_id, diag); + diag = eth_err(port_id, diag); + + rte_eth_trace_promiscuous_disable(port_id, dev->data->promiscuous, + diag); + + return diag; } int @@ -2550,6 +2707,8 @@ rte_eth_promiscuous_get(uint16_t port_id) RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; + rte_eth_trace_promiscuous_get(port_id, dev->data->promiscuous); + return dev->data->promiscuous; } @@ -2570,7 +2729,12 @@ rte_eth_allmulticast_enable(uint16_t port_id) diag = (*dev->dev_ops->allmulticast_enable)(dev); dev->data->all_multicast = (diag == 0) ? 1 : 0; - return eth_err(port_id, diag); + diag = eth_err(port_id, diag); + + rte_eth_trace_allmulticast_enable(port_id, dev->data->all_multicast, + diag); + + return diag; } int @@ -2592,7 +2756,12 @@ rte_eth_allmulticast_disable(uint16_t port_id) if (diag != 0) dev->data->all_multicast = 1; - return eth_err(port_id, diag); + diag = eth_err(port_id, diag); + + rte_eth_trace_allmulticast_disable(port_id, dev->data->all_multicast, + diag); + + return diag; } int @@ -2603,6 +2772,8 @@ rte_eth_allmulticast_get(uint16_t port_id) RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; + rte_eth_trace_allmulticast_get(port_id, dev->data->all_multicast); + return dev->data->all_multicast; } @@ -2629,6 +2800,8 @@ 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; } @@ -2655,35 +2828,76 @@ 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) { + const char *ret; + switch (link_speed) { - case RTE_ETH_SPEED_NUM_NONE: return "None"; - case RTE_ETH_SPEED_NUM_10M: return "10 Mbps"; - case RTE_ETH_SPEED_NUM_100M: return "100 Mbps"; - case RTE_ETH_SPEED_NUM_1G: return "1 Gbps"; - case RTE_ETH_SPEED_NUM_2_5G: return "2.5 Gbps"; - case RTE_ETH_SPEED_NUM_5G: return "5 Gbps"; - case RTE_ETH_SPEED_NUM_10G: return "10 Gbps"; - case RTE_ETH_SPEED_NUM_20G: return "20 Gbps"; - case RTE_ETH_SPEED_NUM_25G: return "25 Gbps"; - case RTE_ETH_SPEED_NUM_40G: return "40 Gbps"; - case RTE_ETH_SPEED_NUM_50G: return "50 Gbps"; - case RTE_ETH_SPEED_NUM_56G: return "56 Gbps"; - case RTE_ETH_SPEED_NUM_100G: return "100 Gbps"; - case RTE_ETH_SPEED_NUM_200G: return "200 Gbps"; - case RTE_ETH_SPEED_NUM_UNKNOWN: return "Unknown"; - default: return "Invalid"; + case RTE_ETH_SPEED_NUM_NONE: + ret = "None"; + break; + case RTE_ETH_SPEED_NUM_10M: + ret = "10 Mbps"; + break; + case RTE_ETH_SPEED_NUM_100M: + ret = "100 Mbps"; + break; + case RTE_ETH_SPEED_NUM_1G: + ret = "1 Gbps"; + break; + case RTE_ETH_SPEED_NUM_2_5G: + ret = "2.5 Gbps"; + break; + case RTE_ETH_SPEED_NUM_5G: + ret = "5 Gbps"; + break; + case RTE_ETH_SPEED_NUM_10G: + ret = "10 Gbps"; + break; + case RTE_ETH_SPEED_NUM_20G: + ret = "20 Gbps"; + break; + case RTE_ETH_SPEED_NUM_25G: + ret = "25 Gbps"; + break; + case RTE_ETH_SPEED_NUM_40G: + ret = "40 Gbps"; + break; + case RTE_ETH_SPEED_NUM_50G: + ret = "50 Gbps"; + break; + case RTE_ETH_SPEED_NUM_56G: + ret = "56 Gbps"; + break; + case RTE_ETH_SPEED_NUM_100G: + ret = "100 Gbps"; + break; + case RTE_ETH_SPEED_NUM_200G: + ret = "200 Gbps"; + break; + case RTE_ETH_SPEED_NUM_UNKNOWN: + ret = "Unknown"; + break; + default: + ret = "Invalid"; } + + rte_eth_trace_link_speed_to_str(link_speed, ret); + + return ret; } int rte_eth_link_to_str(char *str, size_t len, const struct rte_eth_link *eth_link) { + int ret; + if (str == NULL) { RTE_ETHDEV_LOG(ERR, "Cannot convert link to NULL string\n"); return -EINVAL; @@ -2701,20 +2915,25 @@ rte_eth_link_to_str(char *str, size_t len, const struct rte_eth_link *eth_link) } if (eth_link->link_status == RTE_ETH_LINK_DOWN) - return snprintf(str, len, "Link down"); + ret = snprintf(str, len, "Link down"); else - return snprintf(str, len, "Link up at %s %s %s", + ret = snprintf(str, len, "Link up at %s %s %s", rte_eth_link_speed_to_str(eth_link->link_speed), (eth_link->link_duplex == RTE_ETH_LINK_FULL_DUPLEX) ? "FDX" : "HDX", (eth_link->link_autoneg == RTE_ETH_LINK_AUTONEG) ? "Autoneg" : "Fixed"); + + rte_eth_trace_link_to_str(len, eth_link, str, ret); + + return ret; } int rte_eth_stats_get(uint16_t port_id, struct rte_eth_stats *stats) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -2730,7 +2949,11 @@ rte_eth_stats_get(uint16_t port_id, struct rte_eth_stats *stats) if (*dev->dev_ops->stats_get == NULL) return -ENOTSUP; stats->rx_nombuf = dev->data->rx_mbuf_alloc_failed; - return eth_err(port_id, (*dev->dev_ops->stats_get)(dev, stats)); + ret = eth_err(port_id, (*dev->dev_ops->stats_get)(dev, stats)); + + rte_eth_trace_stats_get(port_id, stats, ret); + + return ret; } int @@ -2750,6 +2973,8 @@ rte_eth_stats_reset(uint16_t port_id) dev->data->rx_mbuf_alloc_failed = 0; + rte_eth_trace_stats_reset(port_id); + return 0; } @@ -2833,6 +3058,10 @@ rte_eth_xstats_get_id_by_name(uint16_t port_id, const char *xstat_name, for (idx_xstat = 0; idx_xstat < cnt_xstats; idx_xstat++) { if (!strcmp(xstats_names[idx_xstat].name, xstat_name)) { *id = idx_xstat; + + rte_eth_trace_xstats_get_id_by_name(port_id, + xstat_name, *id); + return 0; }; } @@ -2986,6 +3215,9 @@ 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); @@ -3025,6 +3257,10 @@ rte_eth_xstats_get_names(uint16_t port_id, cnt_used_entries += cnt_driver_entries; } + for (int i = 0; i < cnt_used_entries; i++) + rte_eth_trace_xstats_get_names(port_id, i, xstats_names[i], + size, cnt_used_entries); + return cnt_used_entries; } @@ -3174,6 +3410,9 @@ rte_eth_xstats_get_by_id(uint16_t port_id, const uint64_t *ids, } values[i] = xstats[ids[i]].value; } + + rte_eth_trace_xstats_get_by_id(port_id, ids, values, size); + return size; } @@ -3221,6 +3460,9 @@ 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]); + return count + xcount; } @@ -3234,8 +3476,13 @@ rte_eth_xstats_reset(uint16_t port_id) dev = &rte_eth_devices[port_id]; /* implemented by the driver */ - if (dev->dev_ops->xstats_reset != NULL) - return eth_err(port_id, (*dev->dev_ops->xstats_reset)(dev)); + if (dev->dev_ops->xstats_reset != NULL) { + int ret = eth_err(port_id, (*dev->dev_ops->xstats_reset)(dev)); + + rte_eth_trace_xstats_reset(port_id, ret); + + return ret; + } /* fallback to default */ return rte_eth_stats_reset(port_id); @@ -3268,24 +3515,39 @@ int rte_eth_dev_set_tx_queue_stats_mapping(uint16_t port_id, uint16_t tx_queue_id, uint8_t stat_idx) { - return eth_err(port_id, eth_dev_set_queue_stats_mapping(port_id, + int ret; + + ret = eth_err(port_id, eth_dev_set_queue_stats_mapping(port_id, tx_queue_id, stat_idx, STAT_QMAP_TX)); + + rte_ethdev_trace_set_tx_queue_stats_mapping(port_id, tx_queue_id, + stat_idx, ret); + + return ret; } int rte_eth_dev_set_rx_queue_stats_mapping(uint16_t port_id, uint16_t rx_queue_id, uint8_t stat_idx) { - return eth_err(port_id, eth_dev_set_queue_stats_mapping(port_id, + int ret; + + ret = eth_err(port_id, eth_dev_set_queue_stats_mapping(port_id, rx_queue_id, stat_idx, STAT_QMAP_RX)); + + rte_ethdev_trace_set_rx_queue_stats_mapping(port_id, rx_queue_id, + stat_idx, ret); + + return ret; } int rte_eth_dev_fw_version_get(uint16_t port_id, char *fw_version, size_t fw_size) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -3299,8 +3561,12 @@ rte_eth_dev_fw_version_get(uint16_t port_id, char *fw_version, size_t fw_size) if (*dev->dev_ops->fw_version_get == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->fw_version_get)(dev, + ret = eth_err(port_id, (*dev->dev_ops->fw_version_get)(dev, fw_version, fw_size)); + + rte_ethdev_trace_fw_version_get(port_id, fw_version, fw_size, ret); + + return ret; } int diff --git a/lib/ethdev/rte_ethdev_trace.h b/lib/ethdev/rte_ethdev_trace.h deleted file mode 100644 index 1491c815c3..0000000000 --- a/lib/ethdev/rte_ethdev_trace.h +++ /dev/null @@ -1,95 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause - * Copyright(C) 2020 Marvell International Ltd. - */ - -#ifndef _RTE_ETHDEV_TRACE_H_ -#define _RTE_ETHDEV_TRACE_H_ - -/** - * @file - * - * API for ethdev trace support - */ - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#include "rte_ethdev.h" - -RTE_TRACE_POINT( - rte_ethdev_trace_configure, - RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t nb_rx_q, - uint16_t nb_tx_q, const struct rte_eth_conf *dev_conf, int rc), - rte_trace_point_emit_u16(port_id); - rte_trace_point_emit_u16(nb_rx_q); - rte_trace_point_emit_u16(nb_tx_q); - rte_trace_point_emit_u32(dev_conf->link_speeds); - rte_trace_point_emit_u32(dev_conf->rxmode.mq_mode); - rte_trace_point_emit_u32(dev_conf->rxmode.mtu); - rte_trace_point_emit_u64(dev_conf->rxmode.offloads); - rte_trace_point_emit_u32(dev_conf->txmode.mq_mode); - rte_trace_point_emit_u64(dev_conf->txmode.offloads); - rte_trace_point_emit_u32(dev_conf->lpbk_mode); - rte_trace_point_emit_int(rc); -) - -RTE_TRACE_POINT( - rte_ethdev_trace_rxq_setup, - RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, - uint16_t nb_rx_desc, void *mp, - const struct rte_eth_rxconf *rx_conf, int rc), - 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(mp); - rte_trace_point_emit_u8(rx_conf->rx_thresh.pthresh); - rte_trace_point_emit_u8(rx_conf->rx_thresh.hthresh); - rte_trace_point_emit_u8(rx_conf->rx_thresh.wthresh); - rte_trace_point_emit_u8(rx_conf->rx_drop_en); - rte_trace_point_emit_u8(rx_conf->rx_deferred_start); - rte_trace_point_emit_u64(rx_conf->offloads); - rte_trace_point_emit_int(rc); -) - -RTE_TRACE_POINT( - rte_ethdev_trace_txq_setup, - RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t tx_queue_id, - uint16_t nb_tx_desc, 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_u8(tx_conf->tx_thresh.pthresh); - rte_trace_point_emit_u8(tx_conf->tx_thresh.hthresh); - rte_trace_point_emit_u8(tx_conf->tx_thresh.wthresh); - rte_trace_point_emit_u8(tx_conf->tx_deferred_start); - rte_trace_point_emit_u16(tx_conf->tx_free_thresh); - rte_trace_point_emit_u64(tx_conf->offloads); -) - -RTE_TRACE_POINT( - rte_ethdev_trace_start, - RTE_TRACE_POINT_ARGS(uint16_t port_id), - rte_trace_point_emit_u16(port_id); -) - -RTE_TRACE_POINT( - rte_ethdev_trace_stop, - 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_close, - RTE_TRACE_POINT_ARGS(uint16_t port_id), - rte_trace_point_emit_u16(port_id); -) - -#ifdef __cplusplus -} -#endif - -#endif /* _RTE_ETHDEV_TRACE_H_ */ diff --git a/lib/ethdev/rte_ethdev_trace_fp.h b/lib/ethdev/rte_ethdev_trace_fp.h index 40084d1929..186271c9ff 100644 --- a/lib/ethdev/rte_ethdev_trace_fp.h +++ b/lib/ethdev/rte_ethdev_trace_fp.h @@ -37,6 +37,42 @@ RTE_TRACE_POINT_FP( rte_trace_point_emit_u16(nb_pkts); ) +RTE_TRACE_POINT_FP( + rte_eth_trace_call_rx_callbacks, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + void **rx_pkts, uint16_t nb_rx, uint16_t nb_pkts), + 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_FP( + rte_eth_trace_call_tx_callbacks, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + void **tx_pkts, uint16_t nb_pkts), + 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_FP( + rte_eth_trace_tx_buffer_drop_callback, + RTE_TRACE_POINT_ARGS(void **pkts, uint16_t unsent), + rte_trace_point_emit_ptr(pkts); + rte_trace_point_emit_u16(unsent); +) + +RTE_TRACE_POINT_FP( + rte_eth_trace_tx_buffer_count_callback, + RTE_TRACE_POINT_ARGS(void **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); +) + #ifdef __cplusplus } #endif From patchwork Tue Feb 7 06:32:51 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 123200 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 841E941C2A; Tue, 7 Feb 2023 07:37:24 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6EAF8427F2; Tue, 7 Feb 2023 07:37:24 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id E438C427F2 for ; Tue, 7 Feb 2023 07:37:21 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 3174ZoRk026114; Mon, 6 Feb 2023 22:34:48 -0800 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=RndcbZd6VBraRLvm8Np2TIcjSRY2Smz8m7AIEKpu0ZE=; b=TF5QRuM9LNazLipogKBzaYFS9qa3rmmeMf/YBAvWcVr7oAWKgNvVrD5Bf2SkfEQrnfaq tzODDF8oYPmyRIk0JqO9mA7Qda+t0pvUrIPM/JXmjqGPyL+kvzdi2xvnPO1jIxtBBCe3 1KWCZ1HoIbgWMo2LbDFw0Cqrc/Jtdmg8Rja8vWxTypyEWSrxgtXrBDAqHe6Wohh/dzn5 tlMCNwROQAYPYG1pQbZiolJ/tyg9fadbhl6afz6D6Q18q7s2+r2me8fXwQri5OBjhUkU zC6XlxLgje4VQQZHlu0dIVfUM58XpAJjOYL1NuBrxBfU7IgF3ciPAxOaAAQfM0v56b/i lQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrth9q0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 06 Feb 2023 22:34:47 -0800 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.42; Mon, 6 Feb 2023 22:34:44 -0800 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.42 via Frontend Transport; Mon, 6 Feb 2023 22:34:44 -0800 Received: from localhost.localdomain (unknown [10.28.36.185]) by maili.marvell.com (Postfix) with ESMTP id 57E2F3F7043; Mon, 6 Feb 2023 22:34:22 -0800 (PST) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH v9 3/6] ethdev: add trace points for ethdev (part two) Date: Tue, 7 Feb 2023 12:02:51 +0530 Message-ID: <20230207063254.401538-4-adwivedi@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230207063254.401538-1-adwivedi@marvell.com> References: <20230206115810.308574-1-adwivedi@marvell.com> <20230207063254.401538-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: dOB2tdMAA3ekiKrqxuE0GQG5MSqJz4Nn X-Proofpoint-ORIG-GUID: dOB2tdMAA3ekiKrqxuE0GQG5MSqJz4Nn X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-06_07,2023-02-06_03,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 remaining ethdev functions. Signed-off-by: Ankur Dwivedi Acked-by: Sunil Kumar Kori --- lib/ethdev/ethdev_trace.h | 893 +++++++++++++++++++++++++++++++ lib/ethdev/ethdev_trace_points.c | 252 +++++++++ lib/ethdev/rte_ethdev.c | 486 ++++++++++++++--- lib/ethdev/rte_ethdev_cman.c | 29 +- 4 files changed, 1581 insertions(+), 79 deletions(-) diff --git a/lib/ethdev/ethdev_trace.h b/lib/ethdev/ethdev_trace.h index a5058f97ea..9039446b5f 100644 --- a/lib/ethdev/ethdev_trace.h +++ b/lib/ethdev/ethdev_trace.h @@ -592,6 +592,815 @@ RTE_TRACE_POINT( rte_trace_point_emit_int(ret); ) +RTE_TRACE_POINT( + rte_ethdev_trace_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const 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_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_u16(dev_info->max_rx_queues); + rte_trace_point_emit_u16(dev_info->max_tx_queues); + rte_trace_point_emit_u32(dev_info->max_mac_addrs); + 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_u64(dev_info->flow_type_rss_offloads); + rte_trace_point_emit_u16(dev_info->rx_desc_lim.nb_max); + rte_trace_point_emit_u16(dev_info->rx_desc_lim.nb_min); + rte_trace_point_emit_u16(dev_info->rx_desc_lim.nb_align); + rte_trace_point_emit_u16(dev_info->tx_desc_lim.nb_max); + rte_trace_point_emit_u16(dev_info->tx_desc_lim.nb_min); + rte_trace_point_emit_u16(dev_info->tx_desc_lim.nb_align); + rte_trace_point_emit_u32(dev_info->speed_capa); + rte_trace_point_emit_u16(dev_info->nb_rx_queues); + rte_trace_point_emit_u16(dev_info->nb_tx_queues); + rte_trace_point_emit_u64(dev_info->dev_capa); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_conf_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_conf *dev_conf), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(dev_conf); + rte_trace_point_emit_u32(dev_conf->link_speeds); + rte_trace_point_emit_u64(dev_conf->rxmode.offloads); + rte_trace_point_emit_u64(dev_conf->txmode.offloads); + rte_trace_point_emit_u32(dev_conf->lpbk_mode); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_supported_ptypes, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int supported_num, int num, + uint32_t ptypes), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(supported_num); + rte_trace_point_emit_int(num); + rte_trace_point_emit_u32(ptypes); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_ptypes, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int supported_num, + unsigned int num, uint32_t set_ptypes), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(supported_num); + rte_trace_point_emit_u32(num); + rte_trace_point_emit_u32(set_ptypes); +) + +RTE_TRACE_POINT( + rte_eth_trace_macaddrs_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, unsigned int num), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(num); +) + +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_vlan_filter, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t vlan_id, int on, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(vlan_id); + rte_trace_point_emit_int(on); + rte_trace_point_emit_int(ret); +) + +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_set_vlan_ether_type, + RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_vlan_type vlan_type, + uint16_t tag_type, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(vlan_type); + rte_trace_point_emit_u16(tag_type); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_vlan_offload, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int offload_mask, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(offload_mask); + rte_trace_point_emit_int(ret); +) + +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_set_vlan_pvid, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t pvid, int on, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(pvid); + rte_trace_point_emit_int(on); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_flow_ctrl_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_fc_conf *fc_conf, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(fc_conf); + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_flow_ctrl_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_fc_conf *fc_conf, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_priority_flow_ctrl_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_pfc_conf *pfc_conf, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_priority_flow_ctrl_queue_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_pfc_queue_info *pfc_queue_info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(pfc_queue_info); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_priority_flow_ctrl_queue_configure, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_pfc_queue_conf *pfc_queue_conf, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(pfc_queue_conf); + rte_trace_point_emit_int(pfc_queue_conf->mode); + rte_trace_point_emit_u16(pfc_queue_conf->rx_pause.tx_qid); + rte_trace_point_emit_u16(pfc_queue_conf->tx_pause.rx_qid); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_reta_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_rss_reta_entry64 *reta_conf, + uint16_t reta_size, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(reta_conf); + rte_trace_point_emit_u16(reta_size); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_reta_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_rss_reta_entry64 *reta_conf, + uint16_t reta_size, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(reta_conf); + rte_trace_point_emit_u16(reta_size); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_hash_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_rss_conf *rss_conf, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rss_hash_conf_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_rss_conf *rss_conf, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_udp_tunnel_port_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_udp_tunnel *tunnel_udp, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_udp_tunnel_port_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_udp_tunnel *tunnel_udp, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_led_on, + 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_eth_trace_led_off, + 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_eth_trace_fec_get_capability, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_fec_capa *speed_fec_capa, + unsigned int num, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(speed_fec_capa); + rte_trace_point_emit_u32(speed_fec_capa->speed); + rte_trace_point_emit_u32(speed_fec_capa->capa); + rte_trace_point_emit_u32(num); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_fec_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint32_t *fec_capa, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(fec_capa); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_fec_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t fec_capa, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(fec_capa); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_mac_addr_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_ether_addr *addr, uint32_t pool, int ret), + uint8_t len = RTE_ETHER_ADDR_LEN; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(addr); + rte_trace_point_emit_blob(addr->addr_bytes, len); + rte_trace_point_emit_u32(pool); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_mac_addr_remove, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_ether_addr *addr), + uint8_t len = RTE_ETHER_ADDR_LEN; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(addr); + rte_trace_point_emit_blob(addr->addr_bytes, len); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_default_mac_addr_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_ether_addr *addr), + uint8_t len = RTE_ETHER_ADDR_LEN; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(addr); + rte_trace_point_emit_blob(addr->addr_bytes, len); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_uc_hash_table_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint8_t on, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u8(on); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_uc_all_hash_table_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint8_t on, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u8(on); + rte_trace_point_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_idx); + rte_trace_point_emit_u16(tx_rate); + rte_trace_point_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_u8(avail_thresh); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_avail_thresh_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_int(ret); +) + +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, const void *cb_arg, uint16_t next_port, + uint16_t last_port), + 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_emit_u16(next_port); + rte_trace_point_emit_u16(last_port); +) + +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, const void *cb_arg, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_rx_intr_ctl, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t qid, int epfd, int op, + const void *data, int rc), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(qid); + rte_trace_point_emit_int(epfd); + rte_trace_point_emit_int(op); + rte_trace_point_emit_ptr(data); + rte_trace_point_emit_int(rc); +) + +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_ctl_q, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int epfd, + int op, const void *data, int rc), + 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_emit_int(rc); +) + +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, + const struct rte_eth_rxtx_callback *cb), + 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_emit_ptr(cb); +) + +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, const void *user_param, + const struct rte_eth_rxtx_callback *cb), + 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_emit_ptr(cb); +) + +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, const void *user_param, + const struct rte_eth_rxtx_callback *cb), + 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_emit_ptr(cb); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(user_cb); + rte_trace_point_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(user_cb); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_queue_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + const 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->conf.rx_drop_en); + rte_trace_point_emit_u64(qinfo->conf.offloads); + 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_tx_queue_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + const 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_rx_burst_mode_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + const struct rte_eth_burst_mode *mode, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(mode); + rte_trace_point_emit_u64(mode->flags); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_tx_burst_mode_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + const struct rte_eth_burst_mode *mode, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(mode); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_get_monitor_addr, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, + const struct rte_power_monitor_cond *pmc, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_ptr(pmc); + rte_trace_point_emit_ptr(pmc->addr); + rte_trace_point_emit_u8(pmc->size); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_mc_addr_list, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_ether_addr *mc_addr_set, uint32_t nb_mc_addr, + int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_timesync_enable, + 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_eth_trace_timesync_disable, + 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_eth_trace_timesync_write_time, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *time, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(time); + rte_trace_point_emit_size_t(time->tv_sec); + rte_trace_point_emit_long(time->tv_nsec); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_read_clock, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *clk, int ret), + uint64_t clk_v = *clk; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(clk); + rte_trace_point_emit_u64(clk_v); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_reg_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_dev_reg_info *info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); + 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->width); + rte_trace_point_emit_u32(info->version); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_eeprom_length, + 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_get_eeprom, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_dev_eeprom_info *info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_set_eeprom, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_dev_eeprom_info *info, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_module_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_dev_module_info *modinfo, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(modinfo); + rte_trace_point_emit_u32(modinfo->type); + rte_trace_point_emit_u32(modinfo->eeprom_len); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_module_eeprom, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_dev_eeprom_info *info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_get_dcb_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_dcb_info *dcb_info, int ret), + uint8_t num_user_priorities = RTE_ETH_DCB_NUM_USER_PRIORITIES; + uint8_t num_tcs = RTE_ETH_DCB_NUM_TCS; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(dcb_info); + rte_trace_point_emit_u8(dcb_info->nb_tcs); + rte_trace_point_emit_blob(dcb_info->prio_tc, num_user_priorities); + rte_trace_point_emit_blob(dcb_info->tc_bws, num_tcs); + 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), + rte_trace_point_emit_u16(port_id); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_hairpin_capability_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_hairpin_cap *cap, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(cap); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_ethdev_trace_pool_ops_supported, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const char *pool, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_string(pool); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_representor_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_representor_info *info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_rx_metadata_negotiate, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *features, + uint64_t features_val, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(features); + rte_trace_point_emit_u64(features_val); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_ip_reassembly_capability_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_ip_reassembly_params *capa, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(capa); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_ip_reassembly_conf_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_ip_reassembly_params *conf, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); + rte_trace_point_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); + rte_trace_point_emit_u32(conf->timeout_ms); + rte_trace_point_emit_u16(conf->max_frags); + rte_trace_point_emit_u16(conf->flags); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_buffer_split_get_supported_hdr_ptypes, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int supported_num, + uint32_t ptypes), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(supported_num); + rte_trace_point_emit_u32(ptypes); +) + +RTE_TRACE_POINT( + rte_eth_trace_cman_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_cman_info *info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(info); + rte_trace_point_emit_u64(info->modes_supported); + rte_trace_point_emit_u64(info->objs_supported); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_cman_config_init, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_cman_config *config, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(config); + rte_trace_point_emit_int(config->obj); + rte_trace_point_emit_int(config->mode); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_cman_config_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_cman_config *config, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(config); + rte_trace_point_emit_int(config->obj); + rte_trace_point_emit_int(config->mode); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eth_trace_cman_config_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_eth_cman_config *config, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(config); + rte_trace_point_emit_int(config->obj); + rte_trace_point_emit_int(config->mode); + rte_trace_point_emit_int(ret); +) + /* Fast path trace points */ /* Called in loop in examples/qos_sched and examples/distributor */ @@ -635,6 +1444,90 @@ RTE_TRACE_POINT_FP( rte_trace_point_emit_string(ret); ) +/* Called in loop in examples/bond and examples/ethtool */ +RTE_TRACE_POINT_FP( + rte_eth_trace_macaddr_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_ether_addr *mac_addr), + uint8_t len = RTE_ETHER_ADDR_LEN; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(mac_addr); + rte_trace_point_emit_blob(mac_addr->addr_bytes, len); +) + +/* Called in loop in examples/ip_pipeline */ +RTE_TRACE_POINT_FP( + 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); +) + +/* Called in loop in examples/l3fwd-power */ +RTE_TRACE_POINT_FP( + rte_ethdev_trace_rx_intr_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_int(ret); +) + +/* Called in loop in examples/l3fwd-power */ +RTE_TRACE_POINT_FP( + rte_ethdev_trace_rx_intr_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u16(queue_id); + rte_trace_point_emit_int(ret); +) + +/* Called in loop in examples/ptpclient */ +RTE_TRACE_POINT_FP( + rte_eth_trace_timesync_read_rx_timestamp, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *timestamp, + uint32_t flags, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(timestamp); + rte_trace_point_emit_size_t(timestamp->tv_sec); + rte_trace_point_emit_long(timestamp->tv_nsec); + rte_trace_point_emit_u32(flags); + rte_trace_point_emit_int(ret); +) + +/* Called in loop in examples/ptpclient */ +RTE_TRACE_POINT_FP( + rte_eth_trace_timesync_read_tx_timestamp, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *timestamp, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(timestamp); + rte_trace_point_emit_size_t(timestamp->tv_sec); + rte_trace_point_emit_long(timestamp->tv_nsec); + rte_trace_point_emit_int(ret); +) + +/* Called in loop in examples/ptpclient */ +RTE_TRACE_POINT_FP( + rte_eth_trace_timesync_read_time, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *time, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(time); + rte_trace_point_emit_size_t(time->tv_sec); + rte_trace_point_emit_long(time->tv_nsec); + rte_trace_point_emit_int(ret); +) + +/* Called in loop in examples/ptpclient */ +RTE_TRACE_POINT_FP( + rte_eth_trace_timesync_adjust_time, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int64_t delta, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_i64(delta); + rte_trace_point_emit_int(ret); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index 3e58c679c3..7a08104dc9 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -222,3 +222,255 @@ RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_rx_queue_stats_mapping, RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_fw_version_get, lib.ethdev.fw_version_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_info_get, + lib.ethdev.info_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_conf_get, + lib.ethdev.conf_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_supported_ptypes, + lib.ethdev.get_supported_ptypes) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_ptypes, + lib.ethdev.set_ptypes) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_macaddrs_get, + lib.ethdev.macaddrs_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_macaddr_get, + lib.ethdev.macaddr_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_mtu, + lib.ethdev.get_mtu) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_mtu, + lib.ethdev.set_mtu) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_vlan_filter, + lib.ethdev.vlan_filter) + +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_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_get_vlan_offload, + lib.ethdev.get_vlan_offload) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_pvid, + lib.ethdev.set_vlan_pvid) + +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_priority_flow_ctrl_set, + lib.ethdev.priority_flow_ctrl_set) + +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_priority_flow_ctrl_queue_configure, + lib.ethdev.priority_flow_ctrl_queue_configure) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_reta_update, + lib.ethdev.rss_reta_update) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_reta_query, + lib.ethdev.rss_reta_query) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_hash_update, + lib.ethdev.rss_hash_update) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_hash_conf_get, + lib.ethdev.rss_hash_conf_get) + +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_eth_trace_led_on, + lib.ethdev.led_on) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_led_off, + lib.ethdev.led_off) + +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_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_default_mac_addr_set, + lib.ethdev.default_mac_addr_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_uc_all_hash_table_set, + lib.ethdev.uc_all_hash_table_set) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_set_queue_rate_limit, + lib.ethdev.set_queue_rate_limit) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_set, + lib.ethdev.rx_avail_thresh_set) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_query, + lib.ethdev.rx_avail_thresh_query) + +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_rx_intr_ctl, + lib.ethdev.rx_intr_ctl) + +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_ctl_q, + lib.ethdev.rx_intr_ctl_q) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_enable, + lib.ethdev.rx_intr_enable) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_disable, + lib.ethdev.rx_intr_disable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_add_rx_callback, + lib.ethdev.add_rx_callback) + +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_tx_callback, + lib.ethdev.add_tx_callback) + +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_queue_info_get, + lib.ethdev.rx_queue_info_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_queue_info_get, + lib.ethdev.tx_queue_info_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_burst_mode_get, + lib.ethdev.rx_burst_mode_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_burst_mode_get, + lib.ethdev.tx_burst_mode_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_get_monitor_addr, + lib.ethdev.get_monitor_addr) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_mc_addr_list, + lib.ethdev.set_mc_addr_list) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_enable, + lib.ethdev.timesync_enable) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_disable, + lib.ethdev.timesync_disable) + +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_tx_timestamp, + lib.ethdev.timesync_read_tx_timestamp) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_adjust_time, + lib.ethdev.timesync_adjust_time) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_read_time, + lib.ethdev.timesync_read_time) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_write_time, + lib.ethdev.timesync_write_time) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_read_clock, + lib.ethdev.read_clock) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_reg_info, + lib.ethdev.get_reg_info) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_eeprom_length, + lib.ethdev.get_eeprom_length) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_eeprom, + lib.ethdev.get_eeprom) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_eeprom, + lib.ethdev.set_eeprom) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_module_info, + lib.ethdev.get_module_info) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_module_eeprom, + lib.ethdev.get_module_eeprom) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_dcb_info, + lib.ethdev.get_dcb_info) + +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_hairpin_capability_get, + lib.ethdev.hairpin_capability_get) + +RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_pool_ops_supported, + lib.ethdev.pool_ops_supported) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_representor_info_get, + lib.ethdev.representor_info_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_metadata_negotiate, + lib.ethdev.rx_metadata_negotiate) + +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_buffer_split_get_supported_hdr_ptypes, + lib.ethdev.buffer_split_get_supported_hdr_ptypes) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_info_get, + lib.ethdev.cman_info_get) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_init, + lib.ethdev.cman_config_init) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_set, + lib.ethdev.cman_config_set) + +RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_get, + lib.ethdev.cman_config_get) diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c index 731ce7f27e..233de4e7f5 100644 --- a/lib/ethdev/rte_ethdev.c +++ b/lib/ethdev/rte_ethdev.c @@ -3626,6 +3626,8 @@ 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; } @@ -3646,6 +3648,8 @@ rte_eth_dev_conf_get(uint16_t port_id, struct rte_eth_conf *dev_conf) memcpy(dev_conf, &dev->data->dev_conf, sizeof(struct rte_eth_conf)); + rte_ethdev_trace_conf_get(port_id, dev_conf); + return 0; } @@ -3676,8 +3680,12 @@ rte_eth_dev_get_supported_ptypes(uint16_t port_id, uint32_t ptype_mask, for (i = 0, j = 0; all_ptypes[i] != RTE_PTYPE_UNKNOWN; ++i) if (all_ptypes[i] & ptype_mask) { - if (j < num) + if (j < num) { ptypes[j] = all_ptypes[i]; + + rte_ethdev_trace_get_supported_ptypes(port_id, + j, num, ptypes[j]); + } j++; } @@ -3755,6 +3763,10 @@ rte_eth_dev_set_ptypes(uint16_t port_id, uint32_t ptype_mask, if (ptype_mask & all_ptypes[i]) { if (j < num - 1) { set_ptypes[j] = all_ptypes[i]; + + rte_ethdev_trace_set_ptypes(port_id, j, num, + set_ptypes[j]); + j++; continue; } @@ -3796,6 +3808,8 @@ rte_eth_macaddrs_get(uint16_t port_id, struct rte_ether_addr *ma, num = RTE_MIN(dev_info.max_mac_addrs, num); memcpy(ma, dev->data->mac_addrs, num * sizeof(ma[0])); + rte_eth_trace_macaddrs_get(port_id, num); + return num; } @@ -3816,6 +3830,8 @@ rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr) rte_ether_addr_copy(&dev->data->mac_addrs[0], mac_addr); + rte_eth_trace_macaddr_get(port_id, mac_addr); + return 0; } @@ -3834,6 +3850,9 @@ 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; } @@ -3876,7 +3895,11 @@ rte_eth_dev_set_mtu(uint16_t port_id, uint16_t mtu) if (ret == 0) dev->data->mtu = mtu; - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_ethdev_trace_set_mtu(port_id, mtu, ret); + + return ret; } int @@ -3919,7 +3942,11 @@ rte_eth_dev_vlan_filter(uint16_t port_id, uint16_t vlan_id, int on) vfc->ids[vidx] &= ~RTE_BIT64(vbit); } - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_ethdev_trace_vlan_filter(port_id, vlan_id, on, ret); + + return ret; } int @@ -3940,6 +3967,8 @@ rte_eth_dev_set_vlan_strip_on_queue(uint16_t port_id, uint16_t rx_queue_id, return -ENOTSUP; (*dev->dev_ops->vlan_strip_queue_set)(dev, rx_queue_id, on); + rte_ethdev_trace_set_vlan_strip_on_queue(port_id, rx_queue_id, on); + return 0; } @@ -3949,14 +3978,19 @@ rte_eth_dev_set_vlan_ether_type(uint16_t port_id, uint16_t tpid) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->vlan_tpid_set == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->vlan_tpid_set)(dev, vlan_type, - tpid)); + ret = eth_err(port_id, (*dev->dev_ops->vlan_tpid_set)(dev, vlan_type, + tpid)); + + rte_ethdev_trace_set_vlan_ether_type(port_id, vlan_type, tpid, ret); + + return ret; } int @@ -4048,7 +4082,11 @@ rte_eth_dev_set_vlan_offload(uint16_t port_id, int offload_mask) dev->data->dev_conf.rxmode.offloads = orig_offloads; } - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_ethdev_trace_set_vlan_offload(port_id, offload_mask, ret); + + return ret; } int @@ -4074,6 +4112,8 @@ 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; } @@ -4081,19 +4121,25 @@ int rte_eth_dev_set_vlan_pvid(uint16_t port_id, uint16_t pvid, int on) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->vlan_pvid_set == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->vlan_pvid_set)(dev, pvid, on)); + ret = eth_err(port_id, (*dev->dev_ops->vlan_pvid_set)(dev, pvid, on)); + + rte_ethdev_trace_set_vlan_pvid(port_id, pvid, on, ret); + + return ret; } int rte_eth_dev_flow_ctrl_get(uint16_t port_id, struct rte_eth_fc_conf *fc_conf) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4108,13 +4154,18 @@ rte_eth_dev_flow_ctrl_get(uint16_t port_id, struct rte_eth_fc_conf *fc_conf) if (*dev->dev_ops->flow_ctrl_get == NULL) return -ENOTSUP; memset(fc_conf, 0, sizeof(*fc_conf)); - return eth_err(port_id, (*dev->dev_ops->flow_ctrl_get)(dev, fc_conf)); + ret = eth_err(port_id, (*dev->dev_ops->flow_ctrl_get)(dev, fc_conf)); + + rte_ethdev_trace_flow_ctrl_get(port_id, fc_conf, ret); + + return ret; } int rte_eth_dev_flow_ctrl_set(uint16_t port_id, struct rte_eth_fc_conf *fc_conf) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4133,7 +4184,11 @@ rte_eth_dev_flow_ctrl_set(uint16_t port_id, struct rte_eth_fc_conf *fc_conf) if (*dev->dev_ops->flow_ctrl_set == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->flow_ctrl_set)(dev, fc_conf)); + ret = eth_err(port_id, (*dev->dev_ops->flow_ctrl_set)(dev, fc_conf)); + + rte_ethdev_trace_flow_ctrl_set(port_id, fc_conf, ret); + + return ret; } int @@ -4141,6 +4196,7 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id, struct rte_eth_pfc_conf *pfc_conf) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4158,9 +4214,15 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id, } /* High water, low water validation are device specific */ - if (*dev->dev_ops->priority_flow_ctrl_set) - return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set) - (dev, pfc_conf)); + if (*dev->dev_ops->priority_flow_ctrl_set) { + ret = eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set) + (dev, pfc_conf)); + + rte_ethdev_trace_priority_flow_ctrl_set(port_id, pfc_conf, ret); + + return ret; + } + return -ENOTSUP; } @@ -4219,6 +4281,7 @@ rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id, struct rte_eth_pfc_queue_info *pfc_queue_info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4229,9 +4292,15 @@ rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id, return -EINVAL; } - if (*dev->dev_ops->priority_flow_ctrl_queue_info_get) - return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_queue_info_get) + if (*dev->dev_ops->priority_flow_ctrl_queue_info_get) { + ret = eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_queue_info_get) (dev, pfc_queue_info)); + + rte_ethdev_trace_priority_flow_ctrl_queue_info_get(port_id, + pfc_queue_info, ret); + + return ret; + } return -ENOTSUP; } @@ -4300,10 +4369,17 @@ rte_eth_dev_priority_flow_ctrl_queue_configure(uint16_t port_id, return ret; } - if (*dev->dev_ops->priority_flow_ctrl_queue_config) - return eth_err(port_id, - (*dev->dev_ops->priority_flow_ctrl_queue_config)( - dev, pfc_queue_conf)); + if (*dev->dev_ops->priority_flow_ctrl_queue_config) { + ret = eth_err(port_id, + (*dev->dev_ops->priority_flow_ctrl_queue_config)( + dev, pfc_queue_conf)); + + rte_ethdev_trace_priority_flow_ctrl_queue_configure(port_id, + pfc_queue_conf, ret); + + return ret; + } + return -ENOTSUP; } @@ -4395,8 +4471,12 @@ rte_eth_dev_rss_reta_update(uint16_t port_id, if (*dev->dev_ops->reta_update == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->reta_update)(dev, reta_conf, - reta_size)); + ret = eth_err(port_id, (*dev->dev_ops->reta_update)(dev, reta_conf, + reta_size)); + + rte_ethdev_trace_rss_reta_update(port_id, reta_conf, reta_size, ret); + + return ret; } int @@ -4424,8 +4504,12 @@ rte_eth_dev_rss_reta_query(uint16_t port_id, if (*dev->dev_ops->reta_query == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->reta_query)(dev, reta_conf, - reta_size)); + ret = eth_err(port_id, (*dev->dev_ops->reta_query)(dev, reta_conf, + reta_size)); + + rte_ethdev_trace_rss_reta_query(port_id, reta_conf, reta_size, ret); + + return ret; } int @@ -4469,8 +4553,12 @@ rte_eth_dev_rss_hash_update(uint16_t port_id, if (*dev->dev_ops->rss_hash_update == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->rss_hash_update)(dev, - rss_conf)); + ret = eth_err(port_id, (*dev->dev_ops->rss_hash_update)(dev, + rss_conf)); + + rte_ethdev_trace_rss_hash_update(port_id, rss_conf, ret); + + return ret; } int @@ -4478,6 +4566,7 @@ rte_eth_dev_rss_hash_conf_get(uint16_t port_id, struct rte_eth_rss_conf *rss_conf) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4491,8 +4580,12 @@ rte_eth_dev_rss_hash_conf_get(uint16_t port_id, if (*dev->dev_ops->rss_hash_conf_get == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->rss_hash_conf_get)(dev, - rss_conf)); + ret = eth_err(port_id, (*dev->dev_ops->rss_hash_conf_get)(dev, + rss_conf)); + + rte_ethdev_trace_rss_hash_conf_get(port_id, rss_conf, ret); + + return ret; } int @@ -4500,6 +4593,7 @@ rte_eth_dev_udp_tunnel_port_add(uint16_t port_id, struct rte_eth_udp_tunnel *udp_tunnel) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4518,8 +4612,12 @@ rte_eth_dev_udp_tunnel_port_add(uint16_t port_id, if (*dev->dev_ops->udp_tunnel_port_add == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_add)(dev, + ret = eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_add)(dev, udp_tunnel)); + + rte_ethdev_trace_udp_tunnel_port_add(port_id, udp_tunnel, ret); + + return ret; } int @@ -4527,6 +4625,7 @@ rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id, struct rte_eth_udp_tunnel *udp_tunnel) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4545,34 +4644,48 @@ rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id, if (*dev->dev_ops->udp_tunnel_port_del == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_del)(dev, + ret = eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_del)(dev, udp_tunnel)); + + rte_ethdev_trace_udp_tunnel_port_delete(port_id, udp_tunnel, ret); + + return ret; } int rte_eth_led_on(uint16_t port_id) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->dev_led_on == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->dev_led_on)(dev)); + ret = eth_err(port_id, (*dev->dev_ops->dev_led_on)(dev)); + + rte_eth_trace_led_on(port_id, ret); + + return ret; } int rte_eth_led_off(uint16_t port_id) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->dev_led_off == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->dev_led_off)(dev)); + ret = eth_err(port_id, (*dev->dev_ops->dev_led_off)(dev)); + + rte_eth_trace_led_off(port_id, ret); + + return ret; } int @@ -4597,6 +4710,8 @@ rte_eth_fec_get_capability(uint16_t port_id, return -ENOTSUP; ret = (*dev->dev_ops->fec_get_capability)(dev, speed_fec_capa, num); + rte_eth_trace_fec_get_capability(port_id, speed_fec_capa, num, ret); + return ret; } @@ -4604,6 +4719,7 @@ int rte_eth_fec_get(uint16_t port_id, uint32_t *fec_capa) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4617,20 +4733,29 @@ rte_eth_fec_get(uint16_t port_id, uint32_t *fec_capa) if (*dev->dev_ops->fec_get == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->fec_get)(dev, fec_capa)); + ret = eth_err(port_id, (*dev->dev_ops->fec_get)(dev, fec_capa)); + + rte_eth_trace_fec_get(port_id, fec_capa, ret); + + return ret; } int rte_eth_fec_set(uint16_t port_id, uint32_t fec_capa) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->fec_set == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->fec_set)(dev, fec_capa)); + ret = eth_err(port_id, (*dev->dev_ops->fec_set)(dev, fec_capa)); + + rte_eth_trace_fec_set(port_id, fec_capa, ret); + + return ret; } /* @@ -4718,7 +4843,11 @@ rte_eth_dev_mac_addr_add(uint16_t port_id, struct rte_ether_addr *addr, dev->data->mac_pool_sel[index] |= RTE_BIT64(pool); } - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_ethdev_trace_mac_addr_add(port_id, addr, pool, ret); + + return ret; } int @@ -4758,6 +4887,8 @@ rte_eth_dev_mac_addr_remove(uint16_t port_id, struct rte_ether_addr *addr) /* reset pool bitmap */ dev->data->mac_pool_sel[index] = 0; + rte_ethdev_trace_mac_addr_remove(port_id, addr); + return 0; } @@ -4790,6 +4921,8 @@ rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct rte_ether_addr *addr) /* Update default address in NIC data structure */ rte_ether_addr_copy(addr, &dev->data->mac_addrs[0]); + rte_ethdev_trace_default_mac_addr_set(port_id, addr); + return 0; } @@ -4880,21 +5013,29 @@ rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct rte_ether_addr *addr, &dev->data->hash_mac_addrs[index]); } - return eth_err(port_id, ret); + ret = eth_err(port_id, ret); + + rte_ethdev_trace_uc_hash_table_set(port_id, on, ret); + + return ret; } int rte_eth_dev_uc_all_hash_table_set(uint16_t port_id, uint8_t on) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->uc_all_hash_table_set == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->uc_all_hash_table_set)(dev, - on)); + ret = eth_err(port_id, (*dev->dev_ops->uc_all_hash_table_set)(dev, on)); + + rte_ethdev_trace_uc_all_hash_table_set(port_id, on, ret); + + return ret; } int rte_eth_set_queue_rate_limit(uint16_t port_id, uint16_t queue_idx, @@ -4930,14 +5071,19 @@ int rte_eth_set_queue_rate_limit(uint16_t port_id, uint16_t queue_idx, if (*dev->dev_ops->set_queue_rate_limit == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->set_queue_rate_limit)(dev, + ret = eth_err(port_id, (*dev->dev_ops->set_queue_rate_limit)(dev, queue_idx, tx_rate)); + + rte_eth_trace_set_queue_rate_limit(port_id, queue_idx, tx_rate, ret); + + return ret; } int rte_eth_rx_avail_thresh_set(uint16_t port_id, uint16_t queue_id, uint8_t avail_thresh) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4957,14 +5103,19 @@ int rte_eth_rx_avail_thresh_set(uint16_t port_id, uint16_t queue_id, } if (*dev->dev_ops->rx_queue_avail_thresh_set == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_set)(dev, + ret = eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_set)(dev, queue_id, avail_thresh)); + + rte_eth_trace_rx_avail_thresh_set(port_id, queue_id, avail_thresh, ret); + + return ret; } int rte_eth_rx_avail_thresh_query(uint16_t port_id, uint16_t *queue_id, uint8_t *avail_thresh) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4976,8 +5127,12 @@ int rte_eth_rx_avail_thresh_query(uint16_t port_id, uint16_t *queue_id, if (*dev->dev_ops->rx_queue_avail_thresh_query == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_query)(dev, + ret = eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_query)(dev, queue_id, avail_thresh)); + + rte_eth_trace_rx_avail_thresh_query(port_id, *queue_id, ret); + + return ret; } RTE_INIT(eth_dev_init_fp_ops) @@ -5059,6 +5214,10 @@ rte_eth_dev_callback_register(uint16_t port_id, } while (++next_port <= last_port); rte_spinlock_unlock(ð_dev_cb_lock); + + rte_ethdev_trace_callback_register(port_id, event, cb_fn, cb_arg, + next_port, last_port); + return 0; } @@ -5120,6 +5279,10 @@ rte_eth_dev_callback_unregister(uint16_t port_id, } while (++next_port <= last_port); rte_spinlock_unlock(ð_dev_cb_lock); + + rte_ethdev_trace_callback_unregister(port_id, event, cb_fn, cb_arg, + ret); + return ret; } @@ -5149,6 +5312,9 @@ rte_eth_dev_rx_intr_ctl(uint16_t port_id, int epfd, int op, void *data) for (qid = 0; qid < dev->data->nb_rx_queues; qid++) { vec = rte_intr_vec_list_index_get(intr_handle, qid); rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data); + + rte_ethdev_trace_rx_intr_ctl(port_id, qid, epfd, op, data, rc); + if (rc && rc != -EEXIST) { RTE_ETHDEV_LOG(ERR, "p %u q %u Rx ctl error op %d epfd %d vec %u\n", @@ -5192,6 +5358,8 @@ 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; } @@ -5225,6 +5393,9 @@ rte_eth_dev_rx_intr_ctl_q(uint16_t port_id, uint16_t queue_id, vec = rte_intr_vec_list_index_get(intr_handle, queue_id); rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data); + + rte_ethdev_trace_rx_intr_ctl_q(port_id, queue_id, epfd, op, data, rc); + if (rc && rc != -EEXIST) { RTE_ETHDEV_LOG(ERR, "p %u q %u Rx ctl error op %d epfd %d vec %u\n", @@ -5251,7 +5422,11 @@ rte_eth_dev_rx_intr_enable(uint16_t port_id, if (*dev->dev_ops->rx_queue_intr_enable == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->rx_queue_intr_enable)(dev, queue_id)); + ret = eth_err(port_id, (*dev->dev_ops->rx_queue_intr_enable)(dev, queue_id)); + + rte_ethdev_trace_rx_intr_enable(port_id, queue_id, ret); + + return ret; } int @@ -5270,7 +5445,11 @@ rte_eth_dev_rx_intr_disable(uint16_t port_id, if (*dev->dev_ops->rx_queue_intr_disable == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->rx_queue_intr_disable)(dev, queue_id)); + ret = eth_err(port_id, (*dev->dev_ops->rx_queue_intr_disable)(dev, queue_id)); + + rte_ethdev_trace_rx_intr_disable(port_id, queue_id, ret); + + return ret; } @@ -5328,6 +5507,8 @@ rte_eth_add_rx_callback(uint16_t port_id, uint16_t queue_id, } rte_spinlock_unlock(ð_dev_rx_cb_lock); + rte_eth_trace_add_rx_callback(port_id, queue_id, fn, user_param, cb); + return cb; } @@ -5367,6 +5548,9 @@ rte_eth_add_first_rx_callback(uint16_t port_id, uint16_t queue_id, cb, __ATOMIC_RELEASE); rte_spinlock_unlock(ð_dev_rx_cb_lock); + rte_eth_trace_add_first_rx_callback(port_id, queue_id, fn, user_param, + cb); + return cb; } @@ -5426,6 +5610,8 @@ rte_eth_add_tx_callback(uint16_t port_id, uint16_t queue_id, } rte_spinlock_unlock(ð_dev_tx_cb_lock); + rte_eth_trace_add_tx_callback(port_id, queue_id, fn, user_param, cb); + return cb; } @@ -5460,6 +5646,8 @@ rte_eth_remove_rx_callback(uint16_t port_id, uint16_t queue_id, } rte_spinlock_unlock(ð_dev_rx_cb_lock); + rte_eth_trace_remove_rx_callback(port_id, queue_id, user_cb, ret); + return ret; } @@ -5494,6 +5682,8 @@ rte_eth_remove_tx_callback(uint16_t port_id, uint16_t queue_id, } rte_spinlock_unlock(ð_dev_tx_cb_lock); + rte_eth_trace_remove_tx_callback(port_id, queue_id, user_cb, ret); + return ret; } @@ -5540,6 +5730,8 @@ 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; } @@ -5586,6 +5778,8 @@ 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; } @@ -5594,6 +5788,7 @@ rte_eth_rx_burst_mode_get(uint16_t port_id, uint16_t queue_id, struct rte_eth_burst_mode *mode) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5613,8 +5808,12 @@ rte_eth_rx_burst_mode_get(uint16_t port_id, uint16_t queue_id, if (*dev->dev_ops->rx_burst_mode_get == NULL) return -ENOTSUP; memset(mode, 0, sizeof(*mode)); - return eth_err(port_id, - dev->dev_ops->rx_burst_mode_get(dev, queue_id, mode)); + ret = eth_err(port_id, + dev->dev_ops->rx_burst_mode_get(dev, queue_id, mode)); + + rte_eth_trace_rx_burst_mode_get(port_id, queue_id, mode, ret); + + return ret; } int @@ -5622,6 +5821,7 @@ rte_eth_tx_burst_mode_get(uint16_t port_id, uint16_t queue_id, struct rte_eth_burst_mode *mode) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5641,8 +5841,12 @@ rte_eth_tx_burst_mode_get(uint16_t port_id, uint16_t queue_id, if (*dev->dev_ops->tx_burst_mode_get == NULL) return -ENOTSUP; memset(mode, 0, sizeof(*mode)); - return eth_err(port_id, - dev->dev_ops->tx_burst_mode_get(dev, queue_id, mode)); + ret = eth_err(port_id, + dev->dev_ops->tx_burst_mode_get(dev, queue_id, mode)); + + rte_eth_trace_tx_burst_mode_get(port_id, queue_id, mode, ret); + + return ret; } int @@ -5650,6 +5854,7 @@ rte_eth_get_monitor_addr(uint16_t port_id, uint16_t queue_id, struct rte_power_monitor_cond *pmc) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5668,8 +5873,12 @@ rte_eth_get_monitor_addr(uint16_t port_id, uint16_t queue_id, if (*dev->dev_ops->get_monitor_addr == NULL) return -ENOTSUP; - return eth_err(port_id, + ret = eth_err(port_id, dev->dev_ops->get_monitor_addr(dev->data->rx_queues[queue_id], pmc)); + + rte_eth_trace_get_monitor_addr(port_id, queue_id, pmc, ret); + + return ret; } int @@ -5678,40 +5887,56 @@ rte_eth_dev_set_mc_addr_list(uint16_t port_id, uint32_t nb_mc_addr) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->set_mc_addr_list == NULL) return -ENOTSUP; - return eth_err(port_id, dev->dev_ops->set_mc_addr_list(dev, + ret = eth_err(port_id, dev->dev_ops->set_mc_addr_list(dev, mc_addr_set, nb_mc_addr)); + + rte_ethdev_trace_set_mc_addr_list(port_id, mc_addr_set, nb_mc_addr, + ret); + + return ret; } int rte_eth_timesync_enable(uint16_t port_id) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->timesync_enable == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->timesync_enable)(dev)); + ret = eth_err(port_id, (*dev->dev_ops->timesync_enable)(dev)); + + rte_eth_trace_timesync_enable(port_id, ret); + + return ret; } int rte_eth_timesync_disable(uint16_t port_id) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->timesync_disable == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->timesync_disable)(dev)); + ret = eth_err(port_id, (*dev->dev_ops->timesync_disable)(dev)); + + rte_eth_trace_timesync_disable(port_id, ret); + + return ret; } int @@ -5719,6 +5944,7 @@ rte_eth_timesync_read_rx_timestamp(uint16_t port_id, struct timespec *timestamp, uint32_t flags) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5732,8 +5958,14 @@ rte_eth_timesync_read_rx_timestamp(uint16_t port_id, struct timespec *timestamp, if (*dev->dev_ops->timesync_read_rx_timestamp == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->timesync_read_rx_timestamp) - (dev, timestamp, flags)); + + ret = eth_err(port_id, (*dev->dev_ops->timesync_read_rx_timestamp) + (dev, timestamp, flags)); + + rte_eth_trace_timesync_read_rx_timestamp(port_id, timestamp, flags, + ret); + + return ret; } int @@ -5741,6 +5973,7 @@ rte_eth_timesync_read_tx_timestamp(uint16_t port_id, struct timespec *timestamp) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5754,27 +5987,39 @@ rte_eth_timesync_read_tx_timestamp(uint16_t port_id, if (*dev->dev_ops->timesync_read_tx_timestamp == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->timesync_read_tx_timestamp) - (dev, timestamp)); + + ret = eth_err(port_id, (*dev->dev_ops->timesync_read_tx_timestamp) + (dev, timestamp)); + + rte_eth_trace_timesync_read_tx_timestamp(port_id, timestamp, ret); + + return ret; + } int rte_eth_timesync_adjust_time(uint16_t port_id, int64_t delta) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->timesync_adjust_time == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->timesync_adjust_time)(dev, delta)); + ret = eth_err(port_id, (*dev->dev_ops->timesync_adjust_time)(dev, delta)); + + rte_eth_trace_timesync_adjust_time(port_id, delta, ret); + + return ret; } int rte_eth_timesync_read_time(uint16_t port_id, struct timespec *timestamp) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5788,14 +6033,19 @@ rte_eth_timesync_read_time(uint16_t port_id, struct timespec *timestamp) if (*dev->dev_ops->timesync_read_time == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->timesync_read_time)(dev, + ret = eth_err(port_id, (*dev->dev_ops->timesync_read_time)(dev, timestamp)); + + rte_eth_trace_timesync_read_time(port_id, timestamp, ret); + + return ret; } int rte_eth_timesync_write_time(uint16_t port_id, const struct timespec *timestamp) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5809,14 +6059,19 @@ rte_eth_timesync_write_time(uint16_t port_id, const struct timespec *timestamp) if (*dev->dev_ops->timesync_write_time == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->timesync_write_time)(dev, + ret = eth_err(port_id, (*dev->dev_ops->timesync_write_time)(dev, timestamp)); + + rte_eth_trace_timesync_write_time(port_id, timestamp, ret); + + return ret; } int rte_eth_read_clock(uint16_t port_id, uint64_t *clock) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5829,13 +6084,18 @@ rte_eth_read_clock(uint16_t port_id, uint64_t *clock) if (*dev->dev_ops->read_clock == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->read_clock)(dev, clock)); + ret = eth_err(port_id, (*dev->dev_ops->read_clock)(dev, clock)); + + rte_eth_trace_read_clock(port_id, clock, ret); + + return ret; } int rte_eth_dev_get_reg_info(uint16_t port_id, struct rte_dev_reg_info *info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5849,26 +6109,36 @@ rte_eth_dev_get_reg_info(uint16_t port_id, struct rte_dev_reg_info *info) if (*dev->dev_ops->get_reg == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->get_reg)(dev, info)); + ret = eth_err(port_id, (*dev->dev_ops->get_reg)(dev, info)); + + rte_ethdev_trace_get_reg_info(port_id, info, ret); + + return ret; } int rte_eth_dev_get_eeprom_length(uint16_t port_id) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->get_eeprom_length == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->get_eeprom_length)(dev)); + ret = eth_err(port_id, (*dev->dev_ops->get_eeprom_length)(dev)); + + rte_ethdev_trace_get_eeprom_length(port_id, ret); + + return ret; } int rte_eth_dev_get_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5882,13 +6152,18 @@ rte_eth_dev_get_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info) if (*dev->dev_ops->get_eeprom == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->get_eeprom)(dev, info)); + ret = eth_err(port_id, (*dev->dev_ops->get_eeprom)(dev, info)); + + rte_ethdev_trace_get_eeprom(port_id, info, ret); + + return ret; } int rte_eth_dev_set_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5902,7 +6177,11 @@ rte_eth_dev_set_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info) if (*dev->dev_ops->set_eeprom == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->set_eeprom)(dev, info)); + ret = eth_err(port_id, (*dev->dev_ops->set_eeprom)(dev, info)); + + rte_ethdev_trace_set_eeprom(port_id, info, ret); + + return ret; } int @@ -5910,6 +6189,7 @@ rte_eth_dev_get_module_info(uint16_t port_id, struct rte_eth_dev_module_info *modinfo) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5923,7 +6203,11 @@ rte_eth_dev_get_module_info(uint16_t port_id, if (*dev->dev_ops->get_module_info == NULL) return -ENOTSUP; - return (*dev->dev_ops->get_module_info)(dev, modinfo); + ret = (*dev->dev_ops->get_module_info)(dev, modinfo); + + rte_ethdev_trace_get_module_info(port_id, modinfo, ret); + + return ret; } int @@ -5931,6 +6215,7 @@ rte_eth_dev_get_module_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5958,7 +6243,11 @@ rte_eth_dev_get_module_eeprom(uint16_t port_id, if (*dev->dev_ops->get_module_eeprom == NULL) return -ENOTSUP; - return (*dev->dev_ops->get_module_eeprom)(dev, info); + ret = (*dev->dev_ops->get_module_eeprom)(dev, info); + + rte_ethdev_trace_get_module_eeprom(port_id, info, ret); + + return ret; } int @@ -5966,6 +6255,7 @@ rte_eth_dev_get_dcb_info(uint16_t port_id, struct rte_eth_dcb_info *dcb_info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -5981,7 +6271,11 @@ rte_eth_dev_get_dcb_info(uint16_t port_id, if (*dev->dev_ops->get_dcb_info == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->get_dcb_info)(dev, dcb_info)); + ret = eth_err(port_id, (*dev->dev_ops->get_dcb_info)(dev, dcb_info)); + + rte_ethdev_trace_get_dcb_info(port_id, dcb_info, ret); + + return ret; } static void @@ -6017,6 +6311,8 @@ 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); + return 0; } @@ -6025,6 +6321,7 @@ rte_eth_dev_hairpin_capability_get(uint16_t port_id, struct rte_eth_hairpin_cap *cap) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -6039,13 +6336,18 @@ rte_eth_dev_hairpin_capability_get(uint16_t port_id, if (*dev->dev_ops->hairpin_cap_get == NULL) return -ENOTSUP; memset(cap, 0, sizeof(*cap)); - return eth_err(port_id, (*dev->dev_ops->hairpin_cap_get)(dev, cap)); + ret = eth_err(port_id, (*dev->dev_ops->hairpin_cap_get)(dev, cap)); + + rte_ethdev_trace_hairpin_capability_get(port_id, cap, ret); + + return ret; } int rte_eth_dev_pool_ops_supported(uint16_t port_id, const char *pool) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -6060,7 +6362,11 @@ rte_eth_dev_pool_ops_supported(uint16_t port_id, const char *pool) if (*dev->dev_ops->pool_ops_supported == NULL) return 1; /* all pools are supported */ - return (*dev->dev_ops->pool_ops_supported)(dev, pool); + ret = (*dev->dev_ops->pool_ops_supported)(dev, pool); + + rte_ethdev_trace_pool_ops_supported(port_id, pool, ret); + + return ret; } static int @@ -6350,19 +6656,25 @@ rte_eth_representor_info_get(uint16_t port_id, struct rte_eth_representor_info *info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; if (*dev->dev_ops->representor_info_get == NULL) return -ENOTSUP; - return eth_err(port_id, (*dev->dev_ops->representor_info_get)(dev, info)); + ret = eth_err(port_id, (*dev->dev_ops->representor_info_get)(dev, info)); + + rte_eth_trace_representor_info_get(port_id, info, ret); + + return ret; } int rte_eth_rx_metadata_negotiate(uint16_t port_id, uint64_t *features) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -6381,8 +6693,12 @@ rte_eth_rx_metadata_negotiate(uint16_t port_id, uint64_t *features) if (*dev->dev_ops->rx_metadata_negotiate == NULL) return -ENOTSUP; - return eth_err(port_id, - (*dev->dev_ops->rx_metadata_negotiate)(dev, features)); + ret = eth_err(port_id, + (*dev->dev_ops->rx_metadata_negotiate)(dev, features)); + + rte_eth_trace_rx_metadata_negotiate(port_id, features, *features, ret); + + return ret; } int @@ -6390,6 +6706,7 @@ rte_eth_ip_reassembly_capability_get(uint16_t port_id, struct rte_eth_ip_reassembly_params *reassembly_capa) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -6411,8 +6728,13 @@ rte_eth_ip_reassembly_capability_get(uint16_t port_id, return -ENOTSUP; memset(reassembly_capa, 0, sizeof(struct rte_eth_ip_reassembly_params)); - return eth_err(port_id, (*dev->dev_ops->ip_reassembly_capability_get) + ret = eth_err(port_id, (*dev->dev_ops->ip_reassembly_capability_get) (dev, reassembly_capa)); + + rte_eth_trace_ip_reassembly_capability_get(port_id, reassembly_capa, + ret); + + return ret; } int @@ -6420,6 +6742,7 @@ rte_eth_ip_reassembly_conf_get(uint16_t port_id, struct rte_eth_ip_reassembly_params *conf) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -6440,8 +6763,12 @@ rte_eth_ip_reassembly_conf_get(uint16_t port_id, if (*dev->dev_ops->ip_reassembly_conf_get == NULL) return -ENOTSUP; memset(conf, 0, sizeof(struct rte_eth_ip_reassembly_params)); - return eth_err(port_id, - (*dev->dev_ops->ip_reassembly_conf_get)(dev, conf)); + ret = eth_err(port_id, + (*dev->dev_ops->ip_reassembly_conf_get)(dev, conf)); + + rte_eth_trace_ip_reassembly_conf_get(port_id, conf, ret); + + return ret; } int @@ -6449,6 +6776,7 @@ rte_eth_ip_reassembly_conf_set(uint16_t port_id, const struct rte_eth_ip_reassembly_params *conf) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -6477,8 +6805,12 @@ rte_eth_ip_reassembly_conf_set(uint16_t port_id, if (*dev->dev_ops->ip_reassembly_conf_set == NULL) return -ENOTSUP; - return eth_err(port_id, - (*dev->dev_ops->ip_reassembly_conf_set)(dev, conf)); + ret = eth_err(port_id, + (*dev->dev_ops->ip_reassembly_conf_set)(dev, conf)); + + rte_eth_trace_ip_reassembly_conf_set(port_id, conf, ret); + + return ret; } int @@ -6576,8 +6908,12 @@ rte_eth_buffer_split_get_supported_hdr_ptypes(uint16_t port_id, uint32_t *ptypes return 0; for (i = 0, j = 0; all_types[i] != RTE_PTYPE_UNKNOWN; ++i) { - if (j < num) + if (j < num) { ptypes[j] = all_types[i]; + + rte_eth_trace_buffer_split_get_supported_hdr_ptypes( + port_id, j, ptypes[j]); + } j++; } diff --git a/lib/ethdev/rte_ethdev_cman.c b/lib/ethdev/rte_ethdev_cman.c index 4a1bdd7bd0..a9c4637521 100644 --- a/lib/ethdev/rte_ethdev_cman.c +++ b/lib/ethdev/rte_ethdev_cman.c @@ -8,12 +8,14 @@ #include "rte_ethdev.h" #include "ethdev_driver.h" #include "ethdev_private.h" +#include "ethdev_trace.h" /* Get congestion management information for a port */ int rte_eth_cman_info_get(uint16_t port_id, struct rte_eth_cman_info *info) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -29,7 +31,11 @@ rte_eth_cman_info_get(uint16_t port_id, struct rte_eth_cman_info *info) } memset(info, 0, sizeof(struct rte_eth_cman_info)); - return eth_err(port_id, (*dev->dev_ops->cman_info_get)(dev, info)); + ret = eth_err(port_id, (*dev->dev_ops->cman_info_get)(dev, info)); + + rte_eth_trace_cman_info_get(port_id, info, ret); + + return ret; } /* Initialize congestion management structure with default values */ @@ -37,6 +43,7 @@ int rte_eth_cman_config_init(uint16_t port_id, struct rte_eth_cman_config *config) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -52,7 +59,11 @@ rte_eth_cman_config_init(uint16_t port_id, struct rte_eth_cman_config *config) } memset(config, 0, sizeof(struct rte_eth_cman_config)); - return eth_err(port_id, (*dev->dev_ops->cman_config_init)(dev, config)); + ret = eth_err(port_id, (*dev->dev_ops->cman_config_init)(dev, config)); + + rte_eth_trace_cman_config_init(port_id, config, ret); + + return ret; } /* Configure congestion management on a port */ @@ -60,6 +71,7 @@ int rte_eth_cman_config_set(uint16_t port_id, const struct rte_eth_cman_config *config) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -74,7 +86,11 @@ rte_eth_cman_config_set(uint16_t port_id, const struct rte_eth_cman_config *conf return -ENOTSUP; } - return eth_err(port_id, (*dev->dev_ops->cman_config_set)(dev, config)); + ret = eth_err(port_id, (*dev->dev_ops->cman_config_set)(dev, config)); + + rte_eth_trace_cman_config_set(port_id, config, ret); + + return ret; } /* Retrieve congestion management configuration of a port */ @@ -82,6 +98,7 @@ int rte_eth_cman_config_get(uint16_t port_id, struct rte_eth_cman_config *config) { struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -97,5 +114,9 @@ rte_eth_cman_config_get(uint16_t port_id, struct rte_eth_cman_config *config) } memset(config, 0, sizeof(struct rte_eth_cman_config)); - return eth_err(port_id, (*dev->dev_ops->cman_config_get)(dev, config)); + ret = eth_err(port_id, (*dev->dev_ops->cman_config_get)(dev, config)); + + rte_eth_trace_cman_config_get(port_id, config, ret); + + return ret; } From patchwork Tue Feb 7 06:32:52 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 123201 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id ED6B141C2A; Tue, 7 Feb 2023 07:37:42 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id DC1D4427E9; Tue, 7 Feb 2023 07:37:42 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 5DAA742B8E for ; Tue, 7 Feb 2023 07:37:41 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 3171EnXe013612; Mon, 6 Feb 2023 22:35:14 -0800 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=Tg4TkRINtsCM99im8162k0IiunHvMs3UPq4Q9vGJws8=; b=cPAq8rGkBBy4xYoGI/qtkPwSRRhGR5ocTEHkg+vD9UkWzzfb1x13V2g+cKFKnQa6N39c otgqEtnl41FEtnk8TDk+dfkElg4APhsGviRlVIRWdetxayiTpCwFtGYCiYpJK+sHjE6S ap6iNaGapFDT8zApyy8SX3knx/0uAjpJVy+VOBH1dWS6J0sdIoMnhySok61uvFrfelxK sAD661B45J1FCaPASGOGkMl5XTe7qc5rF8Qz+SQHfICvCags9PNSZ1ZgTgL+MOSJJvg7 Q225Ofe70ceXqf3yoUQl1Pu9GGPlx/knrqRFEv4+dw4Ckdl5WhdFFYGVLpRay//KsdGm Gg== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrth9t7-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 06 Feb 2023 22:35:13 -0800 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.42; Mon, 6 Feb 2023 22:35:11 -0800 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.42 via Frontend Transport; Mon, 6 Feb 2023 22:35:10 -0800 Received: from localhost.localdomain (unknown [10.28.36.185]) by maili.marvell.com (Postfix) with ESMTP id D1E943F7043; Mon, 6 Feb 2023 22:34:48 -0800 (PST) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH v9 4/6] ethdev: add trace points for flow Date: Tue, 7 Feb 2023 12:02:52 +0530 Message-ID: <20230207063254.401538-5-adwivedi@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230207063254.401538-1-adwivedi@marvell.com> References: <20230206115810.308574-1-adwivedi@marvell.com> <20230207063254.401538-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: nVk2me607dkKFwWmOsG5IUXeVVHBKkbr X-Proofpoint-ORIG-GUID: nVk2me607dkKFwWmOsG5IUXeVVHBKkbr X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-06_07,2023-02-06_03,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.h | 502 +++++++++++++++++++++++++++++++ lib/ethdev/ethdev_trace_points.c | 117 +++++++ lib/ethdev/rte_flow.c | 356 +++++++++++++++++----- 3 files changed, 896 insertions(+), 79 deletions(-) diff --git a/lib/ethdev/ethdev_trace.h b/lib/ethdev/ethdev_trace.h index 9039446b5f..0604c0290e 100644 --- a/lib/ethdev/ethdev_trace.h +++ b/lib/ethdev/ethdev_trace.h @@ -1401,6 +1401,277 @@ RTE_TRACE_POINT( rte_trace_point_emit_int(ret); ) +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_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, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_flow_trace_flush, + 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_flow_trace_conv, + RTE_TRACE_POINT_ARGS(enum rte_flow_conv_op op, const void *dst, + size_t size, const void *src, int ret), + 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_emit_int(ret); +) + +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, int ret), + 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_int(items->type); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_int(actions->type); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_decap_set, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_tunnel *tunnel, + struct rte_flow_action **actions, + const uint32_t *num_of_actions, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_match, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_tunnel *tunnel, + struct rte_flow_item **items, + const uint32_t *num_of_items, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_action_decap_release, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_action *actions, uint32_t num_of_actions, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_u32(num_of_actions); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_flow_trace_tunnel_item_release, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_item *items, uint32_t num_of_items, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(items); + rte_trace_point_emit_u32(num_of_items); + rte_trace_point_emit_int(ret); +) + +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, + const struct rte_flow_item_flex_handle *handle), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); + rte_trace_point_emit_int(conf->tunnel); + rte_trace_point_emit_int(conf->nb_samples); + rte_trace_point_emit_int(conf->nb_inputs); + rte_trace_point_emit_int(conf->nb_outputs); + rte_trace_point_emit_ptr(handle); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_flow_trace_info_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_port_info *port_info, + const struct rte_flow_queue_info *queue_info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(port_info); + rte_trace_point_emit_u32(port_info->max_nb_queues); + rte_trace_point_emit_u32(port_info->max_nb_counters); + rte_trace_point_emit_u32(port_info->max_nb_aging_objects); + rte_trace_point_emit_u32(port_info->max_nb_meters); + rte_trace_point_emit_u32(port_info->max_nb_conn_tracks); + rte_trace_point_emit_u32(port_info->supported_flags); + rte_trace_point_emit_ptr(queue_info); + rte_trace_point_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(port_attr); + rte_trace_point_emit_u32(port_attr->nb_counters); + rte_trace_point_emit_u32(port_attr->nb_aging_objects); + rte_trace_point_emit_u32(port_attr->nb_meters); + rte_trace_point_emit_u32(port_attr->nb_conn_tracks); + rte_trace_point_emit_u32(port_attr->flags); + rte_trace_point_emit_u16(nb_queue); + rte_trace_point_emit_ptr(queue_attr); + rte_trace_point_emit_int(ret); +) + +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, const void *tmplate), + uint8_t relaxed_matching = template_attr->relaxed_matching; + uint8_t ingress = template_attr->ingress; + uint8_t egress = template_attr->egress; + uint8_t transfer = template_attr->transfer; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(template_attr); + rte_trace_point_emit_u8(relaxed_matching); + rte_trace_point_emit_u8(ingress); + rte_trace_point_emit_u8(egress); + rte_trace_point_emit_u8(transfer); + rte_trace_point_emit_ptr(pattern); + rte_trace_point_emit_ptr(tmplate); +) + +RTE_TRACE_POINT( + rte_flow_trace_pattern_template_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_pattern_template *pattern_template, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(pattern_template); + rte_trace_point_emit_int(ret); +) + +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, const void *tmplate), + uint8_t ingress = template_attr->ingress; + uint8_t egress = template_attr->egress; + uint8_t transfer = template_attr->transfer; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(template_attr); + rte_trace_point_emit_u8(ingress); + rte_trace_point_emit_u8(egress); + rte_trace_point_emit_u8(transfer); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_ptr(masks); + rte_trace_point_emit_ptr(tmplate); +) + +RTE_TRACE_POINT( + rte_flow_trace_actions_template_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_actions_template *actions_template, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(actions_template); + rte_trace_point_emit_int(ret); +) + +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, + const struct rte_flow_template_table *table), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(table_attr); + rte_trace_point_emit_u32(table_attr->nb_flows); + 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_emit_ptr(table); +) + +RTE_TRACE_POINT( + rte_flow_trace_template_table_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_template_table *template_table, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(template_table); + rte_trace_point_emit_int(ret); +) + +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, + const struct rte_flow *flow, const void *user_data, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_flow_trace_push, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_int(ret); +) + /* Fast path trace points */ /* Called in loop in examples/qos_sched and examples/distributor */ @@ -1528,6 +1799,237 @@ RTE_TRACE_POINT_FP( rte_trace_point_emit_int(ret); ) +/* Called in loop in app/test-flow-perf */ +RTE_TRACE_POINT_FP( + 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, + const struct rte_flow *flow), + 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_emit_ptr(flow); +) + +/* Called in loop in app/test-flow-perf */ +RTE_TRACE_POINT_FP( + rte_flow_trace_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct rte_flow *flow, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(flow); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct rte_flow *flow, + const struct rte_flow_action *action, const void *data, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(flow); + rte_trace_point_emit_ptr(action); + rte_trace_point_emit_int(action->type); + rte_trace_point_emit_ptr(data); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_isolate, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int set, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(set); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_get_aged_flows, + RTE_TRACE_POINT_ARGS(uint16_t port_id, void **contexts, + uint32_t nb_contexts, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(contexts); + rte_trace_point_emit_u32(nb_contexts); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_get_q_aged_flows, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + void **contexts, uint32_t nb_contexts, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(queue_id); + rte_trace_point_emit_ptr(contexts); + rte_trace_point_emit_u32(nb_contexts); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + 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, + const struct rte_flow_action_handle *handle), + uint8_t ingress = conf->ingress; + uint8_t egress = conf->egress; + uint8_t transfer = conf->transfer; + + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(conf); + rte_trace_point_emit_u8(ingress); + rte_trace_point_emit_u8(egress); + rte_trace_point_emit_u8(transfer); + rte_trace_point_emit_ptr(action); + rte_trace_point_emit_int(action->type); + rte_trace_point_emit_ptr(handle); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_action_handle_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_action_handle *handle, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_action_handle_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_action_handle *handle, + const void *update, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); + rte_trace_point_emit_ptr(update); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_action_handle_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_flow_action_handle *handle, + const void *data, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(handle); + rte_trace_point_emit_ptr(data); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_get_restore_info, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct rte_mbuf *m, + const struct rte_flow_restore_info *info, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(m); + rte_trace_point_emit_ptr(info); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_pick_transfer_proxy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint16_t *proxy_port_id, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(proxy_port_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + 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, + const 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, + const void *user_data, const struct rte_flow *flow), + 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_emit_ptr(flow); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_pull, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + const struct rte_flow_op_result *res, uint16_t n_res, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + 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, + const void *user_data, + const struct rte_flow_action_handle *handle), + 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_emit_ptr(handle); +) + +RTE_TRACE_POINT_FP( + 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, + const struct rte_flow_action_handle *action_handle, + const void *user_data, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + 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, + const struct rte_flow_action_handle *action_handle, + const void *update, const void *user_data, int ret), + 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); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT_FP( + rte_flow_trace_async_action_handle_query, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t queue_id, + const struct rte_flow_op_attr *op_attr, + const struct rte_flow_action_handle *action_handle, + const void *data, const void *user_data, int ret), + 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(data); + rte_trace_point_emit_ptr(user_data); + rte_trace_point_emit_int(ret); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index 7a08104dc9..b8cbb285de 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -474,3 +474,120 @@ RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_set, RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_get, lib.ethdev.cman_config_get) + +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_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_get_aged_flows, + lib.ethdev.flow.get_aged_flows) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_get_q_aged_flows, + lib.ethdev.flow.get_q_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) + +RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_query, + lib.ethdev.flow.async.action.handle.query) diff --git a/lib/ethdev/rte_flow.c b/lib/ethdev/rte_flow.c index 4da581146e..e52dcb1760 100644 --- a/lib/ethdev/rte_flow.c +++ b/lib/ethdev/rte_flow.c @@ -16,6 +16,8 @@ #include "rte_flow_driver.h" #include "rte_flow.h" +#include "ethdev_trace.h" + /* Mbuf dynamic field name for metadata. */ int32_t rte_flow_dynf_metadata_offs = -1; @@ -277,6 +279,9 @@ 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: @@ -363,7 +368,11 @@ rte_flow_validate(uint16_t port_id, fts_enter(dev); ret = ops->validate(dev, attr, pattern, actions, error); fts_exit(dev); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_validate(port_id, attr, pattern, actions, ret); + + return ret; } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -390,6 +399,9 @@ rte_flow_create(uint16_t port_id, fts_exit(dev); if (flow == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_create(port_id, attr, pattern, actions, flow); + return flow; } rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -413,7 +425,11 @@ rte_flow_destroy(uint16_t port_id, fts_enter(dev); ret = ops->destroy(dev, flow, error); fts_exit(dev); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_destroy(port_id, flow, ret); + + return ret; } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -435,7 +451,11 @@ rte_flow_flush(uint16_t port_id, fts_enter(dev); ret = ops->flush(dev, error); fts_exit(dev); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_flush(port_id, ret); + + return ret; } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -460,7 +480,11 @@ rte_flow_query(uint16_t port_id, fts_enter(dev); ret = ops->query(dev, flow, action, data, error); fts_exit(dev); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_query(port_id, flow, action, data, ret); + + return ret; } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -483,7 +507,11 @@ rte_flow_isolate(uint16_t port_id, fts_enter(dev); ret = ops->isolate(dev, set, error); fts_exit(dev); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_isolate(port_id, set, ret); + + return ret; } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1004,39 +1032,57 @@ rte_flow_conv(enum rte_flow_conv_op op, const void *src, struct rte_flow_error *error) { + int ret; + switch (op) { const struct rte_flow_attr *attr; case RTE_FLOW_CONV_OP_NONE: - return 0; + ret = 0; + break; case RTE_FLOW_CONV_OP_ATTR: attr = src; if (size > sizeof(*attr)) size = sizeof(*attr); rte_memcpy(dst, attr, size); - return sizeof(*attr); + ret = sizeof(*attr); + break; case RTE_FLOW_CONV_OP_ITEM: - return rte_flow_conv_pattern(dst, size, src, 1, error); + ret = rte_flow_conv_pattern(dst, size, src, 1, error); + break; case RTE_FLOW_CONV_OP_ACTION: - return rte_flow_conv_actions(dst, size, src, 1, error); + ret = rte_flow_conv_actions(dst, size, src, 1, error); + break; case RTE_FLOW_CONV_OP_PATTERN: - return rte_flow_conv_pattern(dst, size, src, 0, error); + ret = rte_flow_conv_pattern(dst, size, src, 0, error); + break; case RTE_FLOW_CONV_OP_ACTIONS: - return rte_flow_conv_actions(dst, size, src, 0, error); + ret = rte_flow_conv_actions(dst, size, src, 0, error); + break; case RTE_FLOW_CONV_OP_RULE: - return rte_flow_conv_rule(dst, size, src, error); + ret = rte_flow_conv_rule(dst, size, src, error); + break; case RTE_FLOW_CONV_OP_ITEM_NAME: - return rte_flow_conv_name(0, 0, dst, size, src, error); + ret = rte_flow_conv_name(0, 0, dst, size, src, error); + break; case RTE_FLOW_CONV_OP_ACTION_NAME: - return rte_flow_conv_name(1, 0, dst, size, src, error); + ret = rte_flow_conv_name(1, 0, dst, size, src, error); + break; case RTE_FLOW_CONV_OP_ITEM_NAME_PTR: - return rte_flow_conv_name(0, 1, dst, size, src, error); + ret = rte_flow_conv_name(0, 1, dst, size, src, error); + break; case RTE_FLOW_CONV_OP_ACTION_NAME_PTR: - return rte_flow_conv_name(1, 1, dst, size, src, error); - } - return rte_flow_error_set + ret = rte_flow_conv_name(1, 1, dst, size, src, error); + break; + default: + ret = rte_flow_error_set (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, "unknown object conversion operation"); + } + + rte_flow_trace_conv(op, dst, size, src, ret); + + return ret; } /** Store a full rte_flow description. */ @@ -1088,6 +1134,9 @@ rte_flow_copy(struct rte_flow_desc *desc, size_t len, .actions = dst_size ? dst->actions : NULL, }), len > sizeof(*desc) ? sizeof(*desc) : len); + + rte_flow_trace_copy(desc, len, attr, items, actions, ret); + return ret; } @@ -1126,7 +1175,11 @@ rte_flow_get_aged_flows(uint16_t port_id, void **contexts, fts_enter(dev); ret = ops->get_aged_flows(dev, contexts, nb_contexts, error); fts_exit(dev); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_get_aged_flows(port_id, contexts, nb_contexts, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1148,7 +1201,12 @@ rte_flow_get_q_aged_flows(uint16_t port_id, uint32_t queue_id, void **contexts, ret = ops->get_q_aged_flows(dev, queue_id, contexts, nb_contexts, error); fts_exit(dev); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_get_q_aged_flows(port_id, queue_id, contexts, + nb_contexts, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1176,6 +1234,9 @@ rte_flow_action_handle_create(uint16_t port_id, conf, action, error); if (handle == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_action_handle_create(port_id, conf, action, handle); + return handle; } @@ -1195,7 +1256,11 @@ rte_flow_action_handle_destroy(uint16_t port_id, NULL, rte_strerror(ENOSYS)); ret = ops->action_handle_destroy(&rte_eth_devices[port_id], handle, error); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_action_handle_destroy(port_id, handle, ret); + + return ret; } int @@ -1215,7 +1280,11 @@ rte_flow_action_handle_update(uint16_t port_id, NULL, rte_strerror(ENOSYS)); ret = ops->action_handle_update(&rte_eth_devices[port_id], handle, update, error); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_action_handle_update(port_id, handle, update, ret); + + return ret; } int @@ -1235,7 +1304,11 @@ rte_flow_action_handle_query(uint16_t port_id, NULL, rte_strerror(ENOSYS)); ret = ops->action_handle_query(&rte_eth_devices[port_id], handle, data, error); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_action_handle_query(port_id, handle, data, ret); + + return ret; } int @@ -1247,14 +1320,20 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_decap_set)) { - return flow_err(port_id, - ops->tunnel_decap_set(dev, tunnel, actions, - num_of_actions, error), - error); + ret = flow_err(port_id, + ops->tunnel_decap_set(dev, tunnel, actions, + num_of_actions, error), + error); + + rte_flow_trace_tunnel_decap_set(port_id, tunnel, actions, + num_of_actions, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1270,14 +1349,20 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_match)) { - return flow_err(port_id, - ops->tunnel_match(dev, tunnel, items, - num_of_items, error), - error); + ret = flow_err(port_id, + ops->tunnel_match(dev, tunnel, items, + num_of_items, error), + error); + + rte_flow_trace_tunnel_match(port_id, tunnel, items, num_of_items, + ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1292,14 +1377,19 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->get_restore_info)) { - return flow_err(port_id, - ops->get_restore_info(dev, m, restore_info, - error), - error); + ret = flow_err(port_id, + ops->get_restore_info(dev, m, restore_info, + error), + error); + + rte_flow_trace_get_restore_info(port_id, m, restore_info, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1314,15 +1404,21 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_action_decap_release)) { - return flow_err(port_id, - ops->tunnel_action_decap_release(dev, actions, - num_of_actions, - error), - error); + ret = flow_err(port_id, + ops->tunnel_action_decap_release(dev, actions, + num_of_actions, + error), + error); + + rte_flow_trace_tunnel_action_decap_release(port_id, actions, + num_of_actions, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1337,14 +1433,19 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (likely(!!ops->tunnel_item_release)) { - return flow_err(port_id, - ops->tunnel_item_release(dev, items, - num_of_items, error), - error); + ret = flow_err(port_id, + ops->tunnel_item_release(dev, items, + num_of_items, error), + error); + + rte_flow_trace_tunnel_item_release(port_id, items, num_of_items, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1357,6 +1458,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; + int ret; if (unlikely(ops == NULL)) return -rte_errno; @@ -1368,9 +1470,13 @@ rte_flow_pick_transfer_proxy(uint16_t port_id, uint16_t *proxy_port_id, dev = &rte_eth_devices[port_id]; - return flow_err(port_id, - ops->pick_transfer_proxy(dev, proxy_port_id, error), - error); + ret = flow_err(port_id, + ops->pick_transfer_proxy(dev, proxy_port_id, error), + error); + + rte_flow_trace_pick_transfer_proxy(port_id, proxy_port_id, ret); + + return ret; } struct rte_flow_item_flex_handle * @@ -1393,6 +1499,9 @@ rte_flow_flex_item_create(uint16_t port_id, handle = ops->flex_item_create(dev, conf, error); if (handle == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_flex_item_create(port_id, conf, handle); + return handle; } @@ -1410,7 +1519,11 @@ rte_flow_flex_item_release(uint16_t port_id, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, rte_strerror(ENOTSUP)); ret = ops->flex_item_release(dev, handle, error); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_flex_item_release(port_id, handle, ret); + + return ret; } int @@ -1421,6 +1534,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); + int ret; if (unlikely(!ops)) return -rte_errno; @@ -1435,9 +1549,13 @@ rte_flow_info_get(uint16_t port_id, return -EINVAL; } if (likely(!!ops->info_get)) { - return flow_err(port_id, - ops->info_get(dev, port_info, queue_info, error), - error); + ret = flow_err(port_id, + ops->info_get(dev, port_info, queue_info, error), + error); + + rte_flow_trace_info_get(port_id, port_info, queue_info, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1481,7 +1599,11 @@ rte_flow_configure(uint16_t port_id, ret = ops->configure(dev, port_attr, nb_queue, queue_attr, error); if (ret == 0) dev->data->flow_configured = 1; - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_configure(port_id, port_attr, nb_queue, queue_attr, ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1532,6 +1654,10 @@ rte_flow_pattern_template_create(uint16_t port_id, pattern, error); if (template == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_pattern_template_create(port_id, template_attr, + pattern, template); + return template; } rte_flow_error_set(error, ENOTSUP, @@ -1547,17 +1673,23 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (unlikely(pattern_template == NULL)) return 0; if (likely(!!ops->pattern_template_destroy)) { - return flow_err(port_id, - ops->pattern_template_destroy(dev, - pattern_template, - error), - error); + ret = flow_err(port_id, + ops->pattern_template_destroy(dev, + pattern_template, + error), + error); + + rte_flow_trace_pattern_template_destroy(port_id, pattern_template, + ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1618,6 +1750,10 @@ rte_flow_actions_template_create(uint16_t port_id, actions, masks, error); if (template == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_actions_template_create(port_id, template_attr, actions, + masks, template); + return template; } rte_flow_error_set(error, ENOTSUP, @@ -1633,17 +1769,23 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (unlikely(actions_template == NULL)) return 0; if (likely(!!ops->actions_template_destroy)) { - return flow_err(port_id, - ops->actions_template_destroy(dev, - actions_template, - error), - error); + ret = flow_err(port_id, + ops->actions_template_destroy(dev, + actions_template, + error), + error); + + rte_flow_trace_actions_template_destroy(port_id, actions_template, + ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1708,6 +1850,13 @@ rte_flow_template_table_create(uint16_t port_id, error); if (table == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_template_table_create(port_id, table_attr, + pattern_templates, + nb_pattern_templates, + actions_templates, + nb_actions_templates, table); + return table; } rte_flow_error_set(error, ENOTSUP, @@ -1723,17 +1872,23 @@ 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); + int ret; if (unlikely(!ops)) return -rte_errno; if (unlikely(template_table == NULL)) return 0; if (likely(!!ops->template_table_destroy)) { - return flow_err(port_id, - ops->template_table_destroy(dev, - template_table, - error), - error); + ret = flow_err(port_id, + ops->template_table_destroy(dev, + template_table, + error), + error); + + rte_flow_trace_template_table_destroy(port_id, template_table, + ret); + + return ret; } return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, @@ -1763,6 +1918,11 @@ rte_flow_async_create(uint16_t port_id, user_data, error); if (flow == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_async_create(port_id, queue_id, op_attr, template_table, + pattern, pattern_template_index, actions, + actions_template_index, user_data, flow); + return flow; } @@ -1776,12 +1936,18 @@ 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); + int ret; - return flow_err(port_id, - ops->async_destroy(dev, queue_id, - op_attr, flow, - user_data, error), - error); + ret = flow_err(port_id, + ops->async_destroy(dev, queue_id, + op_attr, flow, + user_data, error), + error); + + rte_flow_trace_async_destroy(port_id, queue_id, op_attr, flow, + user_data, ret); + + return ret; } int @@ -1791,10 +1957,15 @@ 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); + int ret; - return flow_err(port_id, - ops->push(dev, queue_id, error), - error); + ret = flow_err(port_id, + ops->push(dev, queue_id, error), + error); + + rte_flow_trace_push(port_id, queue_id, ret); + + return ret; } int @@ -1807,9 +1978,14 @@ rte_flow_pull(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); int ret; + int rc; ret = ops->pull(dev, queue_id, res, n_res, error); - return ret ? ret : flow_err(port_id, ret, error); + rc = ret ? ret : flow_err(port_id, ret, error); + + rte_flow_trace_pull(port_id, queue_id, res, n_res, rc); + + return rc; } struct rte_flow_action_handle * @@ -1829,6 +2005,11 @@ rte_flow_async_action_handle_create(uint16_t port_id, indir_action_conf, action, user_data, error); if (handle == NULL) flow_err(port_id, -rte_errno, error); + + rte_flow_trace_async_action_handle_create(port_id, queue_id, op_attr, + indir_action_conf, action, + user_data, handle); + return handle; } @@ -1846,7 +2027,12 @@ rte_flow_async_action_handle_destroy(uint16_t port_id, ret = ops->async_action_handle_destroy(dev, queue_id, op_attr, action_handle, user_data, error); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_async_action_handle_destroy(port_id, queue_id, op_attr, + action_handle, user_data, ret); + + return ret; } int @@ -1864,7 +2050,13 @@ rte_flow_async_action_handle_update(uint16_t port_id, ret = ops->async_action_handle_update(dev, queue_id, op_attr, action_handle, update, user_data, error); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_async_action_handle_update(port_id, queue_id, op_attr, + action_handle, update, + user_data, ret); + + return ret; } int @@ -1882,5 +2074,11 @@ rte_flow_async_action_handle_query(uint16_t port_id, ret = ops->async_action_handle_query(dev, queue_id, op_attr, action_handle, data, user_data, error); - return flow_err(port_id, ret, error); + ret = flow_err(port_id, ret, error); + + rte_flow_trace_async_action_handle_query(port_id, queue_id, op_attr, + action_handle, data, user_data, + ret); + + return ret; } From patchwork Tue Feb 7 06:32:53 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 123202 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 5EDCE41C2A; Tue, 7 Feb 2023 07:38:14 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 4994841148; Tue, 7 Feb 2023 07:38:14 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 60B3B40ED9 for ; Tue, 7 Feb 2023 07:38:13 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 3174aF3l017823; Mon, 6 Feb 2023 22:35:40 -0800 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=Z4to5VwdlQs3gL9rSc3ypBVXU5hsx2Xbcw1f//SSF7Q=; b=Zz8DnyI4YT4rLx9RYwGB0uqCnQw0lMzMfulh6RhvuEIhDTZpUfMypahTf0IX0VH9ZPEq 67Cgw29ySBTQ0wK993I2PqFCZ9XUPvReCpXw86bCg+fqCY666Rms/6G1kew5QLY1z8xb YTGFhfHR/W4c4lNBH9iYOFxxPklleawtaPtvRusVCJS8vFYPjP/ZGDVn1nfC0dVtMf01 VWbjSV5jed/KGEsiqLX3jdS6f2wllWbEpvZrTKguBwIv90FHJ3oaKZK+N6U28sLfZkmb sXuXLdBzb/h1KreDkvAlI66AkYfm7yAiFjtpmXA9WSS2yqvT4JACgj1m8m3DLquu+pXx Vg== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrth9uu-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 06 Feb 2023 22:35:39 -0800 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.42; Mon, 6 Feb 2023 22:35:37 -0800 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.42 via Frontend Transport; Mon, 6 Feb 2023 22:35:37 -0800 Received: from localhost.localdomain (unknown [10.28.36.185]) by maili.marvell.com (Postfix) with ESMTP id 59F0F3F704A; Mon, 6 Feb 2023 22:35:15 -0800 (PST) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH v9 5/6] ethdev: add trace points for mtr Date: Tue, 7 Feb 2023 12:02:53 +0530 Message-ID: <20230207063254.401538-6-adwivedi@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230207063254.401538-1-adwivedi@marvell.com> References: <20230206115810.308574-1-adwivedi@marvell.com> <20230207063254.401538-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: jJ15Kz9SqCfaZgYGDn-BYIzaVrFn7NZk X-Proofpoint-ORIG-GUID: jJ15Kz9SqCfaZgYGDn-BYIzaVrFn7NZk X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-06_07,2023-02-06_03,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 Acked-by: Sunil Kumar Kori --- lib/ethdev/ethdev_trace.h | 223 +++++++++++++++++++++++++++++++ lib/ethdev/ethdev_trace_points.c | 63 +++++++++ lib/ethdev/rte_mtr.c | 156 ++++++++++++++++++--- 3 files changed, 421 insertions(+), 21 deletions(-) diff --git a/lib/ethdev/ethdev_trace.h b/lib/ethdev/ethdev_trace.h index 0604c0290e..5285a04c67 100644 --- a/lib/ethdev/ethdev_trace.h +++ b/lib/ethdev/ethdev_trace.h @@ -19,6 +19,7 @@ extern "C" { #include #include "rte_ethdev.h" +#include "rte_mtr.h" RTE_TRACE_POINT( rte_ethdev_trace_configure, @@ -1672,6 +1673,192 @@ RTE_TRACE_POINT( rte_trace_point_emit_int(ret); ) +RTE_TRACE_POINT( + rte_mtr_trace_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_mtr_capabilities *cap, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(cap); + rte_trace_point_emit_u32(cap->n_max); + rte_trace_point_emit_u32(cap->n_shared_max); + rte_trace_point_emit_int(cap->identical); + rte_trace_point_emit_int(cap->shared_identical); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_profile_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + uint32_t meter_profile_id, + const struct rte_mtr_meter_profile *profile, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_profile_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + uint32_t meter_profile_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(meter_profile_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_profile_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + uint32_t meter_profile_id, const void *ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(meter_profile_id); + rte_trace_point_emit_ptr(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_policy_validate, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int i, + const struct rte_flow_action *actions, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(i); + rte_trace_point_emit_ptr(actions); + rte_trace_point_emit_int(actions->type); + rte_trace_point_emit_ptr(actions->conf); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_policy_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t policy_id, int i, + const struct rte_flow_action *actions, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(i); + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_policy_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t policy_id, + const void *ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(policy_id); + rte_trace_point_emit_ptr(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_enable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_disable, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_ptr(dscp_table); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_meter_vlan_table_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + const enum rte_color *vlan_table, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_ptr(vlan_table); + rte_trace_point_emit_int(ret); +) + +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, + int ret), + 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); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_color_in_protocol_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_int(proto); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_stats_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + uint64_t stats_mask, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_u64(stats_mask); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_mtr_trace_stats_read, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + const struct rte_mtr_stats *stats, uint64_t stats_mask, + int clear, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_ptr(stats); + rte_trace_point_emit_u64(stats_mask); + rte_trace_point_emit_int(clear); + rte_trace_point_emit_int(ret); +) + /* Fast path trace points */ /* Called in loop in examples/qos_sched and examples/distributor */ @@ -2030,6 +2217,42 @@ RTE_TRACE_POINT_FP( rte_trace_point_emit_int(ret); ) +/* Called in loop in app/test-flow-perf */ +RTE_TRACE_POINT_FP( + rte_mtr_trace_create, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, + const struct rte_mtr_params *params, int shared, int ret), + 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_emit_int(ret); +) + +/* Called in loop in app/test-flow-perf */ +RTE_TRACE_POINT_FP( + rte_mtr_trace_destroy, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t mtr_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(mtr_id); + rte_trace_point_emit_int(ret); +) + +/* Called in loop in app/test-flow-perf */ +RTE_TRACE_POINT_FP( + rte_mtr_trace_meter_policy_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t policy_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(policy_id); + rte_trace_point_emit_int(ret); +) + #ifdef __cplusplus } #endif diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index b8cbb285de..c34c06941c 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -591,3 +591,66 @@ RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_update, RTE_TRACE_POINT_REGISTER(rte_flow_trace_async_action_handle_query, lib.ethdev.flow.async.action.handle.query) + +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_get, + lib.ethdev.mtr.meter_profile_get) + +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_get, + lib.ethdev.mtr.meter_policy_get) + +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_mtr.c b/lib/ethdev/rte_mtr.c index 3954839531..e957f52db5 100644 --- a/lib/ethdev/rte_mtr.c +++ b/lib/ethdev/rte_mtr.c @@ -5,6 +5,7 @@ #include #include +#include "ethdev_trace.h" #include "rte_ethdev.h" #include "rte_mtr_driver.h" #include "rte_mtr.h" @@ -82,8 +83,13 @@ rte_mtr_capabilities_get(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, capabilities_get)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, capabilities_get)(dev, cap, error); + + rte_mtr_trace_capabilities_get(port_id, cap, ret); + + return ret; } /* MTR meter profile add */ @@ -94,8 +100,14 @@ rte_mtr_meter_profile_add(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_profile_add)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_profile_add)(dev, meter_profile_id, profile, error); + + rte_mtr_trace_meter_profile_add(port_id, meter_profile_id, profile, + ret); + + return ret; } /** MTR meter profile delete */ @@ -105,8 +117,13 @@ rte_mtr_meter_profile_delete(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_profile_delete)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_profile_delete)(dev, meter_profile_id, error); + + rte_mtr_trace_meter_profile_delete(port_id, meter_profile_id, ret); + + return ret; } /** MTR meter profile get */ @@ -116,8 +133,13 @@ rte_mtr_meter_profile_get(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_HNDL_FUNC(port_id, meter_profile_get)(dev, + struct rte_flow_meter_profile *ret; + ret = RTE_MTR_HNDL_FUNC(port_id, meter_profile_get)(dev, meter_profile_id, error); + + rte_mtr_trace_meter_profile_get(port_id, meter_profile_id, ret); + + return ret; } /* MTR meter policy validate */ @@ -127,8 +149,16 @@ rte_mtr_meter_policy_validate(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_policy_validate)(dev, + int ret; + int i; + ret = RTE_MTR_FUNC(port_id, meter_policy_validate)(dev, policy, error); + + for (i = 0; i < RTE_COLORS; i++) + rte_mtr_trace_meter_policy_validate(port_id, i, + policy->actions[i], ret); + + return ret; } /* MTR meter policy add */ @@ -139,8 +169,16 @@ rte_mtr_meter_policy_add(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_policy_add)(dev, + int ret; + int i; + ret = RTE_MTR_FUNC(port_id, meter_policy_add)(dev, policy_id, policy, error); + + for (i = 0; i < RTE_COLORS; i++) + rte_mtr_trace_meter_policy_add(port_id, policy_id, i, + policy->actions[i], ret); + + return ret; } /** MTR meter policy delete */ @@ -150,8 +188,13 @@ rte_mtr_meter_policy_delete(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_policy_delete)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_policy_delete)(dev, policy_id, error); + + rte_mtr_trace_meter_policy_delete(port_id, policy_id, ret); + + return ret; } /** MTR meter policy get */ @@ -161,8 +204,13 @@ rte_mtr_meter_policy_get(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_HNDL_FUNC(port_id, meter_policy_get)(dev, + struct rte_flow_meter_policy *ret; + ret = RTE_MTR_HNDL_FUNC(port_id, meter_policy_get)(dev, policy_id, error); + + rte_mtr_trace_meter_policy_get(port_id, policy_id, ret); + + return ret; } /** MTR object create */ @@ -174,8 +222,13 @@ rte_mtr_create(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, create)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, create)(dev, mtr_id, params, shared, error); + + rte_mtr_trace_create(port_id, mtr_id, params, shared, ret); + + return ret; } /** MTR object destroy */ @@ -185,8 +238,13 @@ rte_mtr_destroy(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, destroy)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, destroy)(dev, mtr_id, error); + + rte_mtr_trace_destroy(port_id, mtr_id, ret); + + return ret; } /** MTR object meter enable */ @@ -196,8 +254,13 @@ rte_mtr_meter_enable(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_enable)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_enable)(dev, mtr_id, error); + + rte_mtr_trace_meter_enable(port_id, mtr_id, ret); + + return ret; } /** MTR object meter disable */ @@ -207,8 +270,13 @@ rte_mtr_meter_disable(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_disable)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_disable)(dev, mtr_id, error); + + rte_mtr_trace_meter_disable(port_id, mtr_id, ret); + + return ret; } /** MTR object meter profile update */ @@ -219,8 +287,13 @@ rte_mtr_meter_profile_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_profile_update)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_profile_update)(dev, mtr_id, meter_profile_id, error); + + rte_mtr_trace_meter_profile_update(port_id, mtr_id, meter_profile_id, ret); + + return ret; } /** MTR object meter policy update */ @@ -231,8 +304,13 @@ rte_mtr_meter_policy_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, meter_policy_update)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_policy_update)(dev, mtr_id, meter_policy_id, error); + + rte_mtr_trace_meter_policy_update(port_id, mtr_id, meter_policy_id, ret); + + return ret; } /** MTR object meter DSCP table update */ @@ -243,8 +321,13 @@ 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]; - return RTE_MTR_FUNC(port_id, meter_dscp_table_update)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_dscp_table_update)(dev, mtr_id, proto, dscp_table, error); + + rte_mtr_trace_meter_dscp_table_update(port_id, mtr_id, dscp_table, ret); + + return ret; } /** MTR object meter VLAN table update */ @@ -255,8 +338,13 @@ 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]; - return RTE_MTR_FUNC(port_id, meter_vlan_table_update)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, meter_vlan_table_update)(dev, mtr_id, proto, vlan_table, error); + + rte_mtr_trace_meter_vlan_table_update(port_id, mtr_id, vlan_table, ret); + + return ret; } /** Set the input color protocol on MTR object */ @@ -268,8 +356,13 @@ 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]; - return RTE_MTR_FUNC(port_id, in_proto_set)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, in_proto_set)(dev, mtr_id, proto, priority, error); + + rte_mtr_trace_color_in_protocol_set(port_id, mtr_id, proto, priority, ret); + + return ret; } /** Get input color protocols of MTR object */ @@ -280,8 +373,13 @@ 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]; - return RTE_MTR_FUNC(port_id, in_proto_get)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, in_proto_get)(dev, mtr_id, proto_mask, error); + + rte_mtr_trace_color_in_protocol_get(port_id, mtr_id, ret); + + return ret; } /** Get input color protocol priority of MTR object */ @@ -293,8 +391,13 @@ 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]; - return RTE_MTR_FUNC(port_id, in_proto_prio_get)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, in_proto_prio_get)(dev, mtr_id, proto, priority, error); + + rte_mtr_trace_color_in_protocol_priority_get(port_id, mtr_id, proto, ret); + + return ret; } /** MTR object enabled stats update */ @@ -305,8 +408,13 @@ rte_mtr_stats_update(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, stats_update)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, stats_update)(dev, mtr_id, stats_mask, error); + + rte_mtr_trace_stats_update(port_id, mtr_id, stats_mask, ret); + + return ret; } /** MTR object stats read */ @@ -319,6 +427,12 @@ rte_mtr_stats_read(uint16_t port_id, struct rte_mtr_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_MTR_FUNC(port_id, stats_read)(dev, + int ret; + ret = RTE_MTR_FUNC(port_id, stats_read)(dev, mtr_id, stats, stats_mask, clear, error); + + rte_mtr_trace_stats_read(port_id, mtr_id, stats, *stats_mask, clear, + ret); + + return ret; } From patchwork Tue Feb 7 06:32:54 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ankur Dwivedi X-Patchwork-Id: 123203 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 7FC9041C2A; Tue, 7 Feb 2023 07:38:25 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 66C63427E9; Tue, 7 Feb 2023 07:38:25 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id C6668427E9 for ; Tue, 7 Feb 2023 07:38:23 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 3174aF3p017823; Mon, 6 Feb 2023 22:36:06 -0800 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=mIh07e3yR6bCd/AznD0hC9skXlfZMVgBAzTc8gAq73Q=; b=dLTx8Dc+eqnA0JBXKfpJG3uTQ1K6gi9QIRdEWHqDV4xflgfgiK6FjWaouO2Cz7OkUrQ+ C/+Z4cA5yNESDAwbPiH44vZOKzfmnIlxfjsnCey38DGV7o3aSt8VZ8IWa3gbAXHYwOUU QJPR8R65C14b/flFfmQp5o9l+uq7AFTm9pvuhmj2CXOE1uISeJADa2aWLmUW23GPyDkv VG6EOVrH0VTfr6AkGIfjFySHLLOn2OK1Yjxrz4rhLOxIOHn2zhDXg1Lz/5dQAEXRSdu6 vyqIBE8Jqvv3xLHoE/D703mNSgz9BqTEXhHu/lpi+Ucwsyy3mtAVlWlwn3bWeFF8/Q5r nQ== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrth9wd-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 06 Feb 2023 22:36:06 -0800 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.42; Mon, 6 Feb 2023 22:36:03 -0800 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.42 via Frontend Transport; Mon, 6 Feb 2023 22:36:03 -0800 Received: from localhost.localdomain (unknown [10.28.36.185]) by maili.marvell.com (Postfix) with ESMTP id E22C43F7043; Mon, 6 Feb 2023 22:35:41 -0800 (PST) From: Ankur Dwivedi To: CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Ankur Dwivedi Subject: [PATCH v9 6/6] ethdev: add trace points for tm Date: Tue, 7 Feb 2023 12:02:54 +0530 Message-ID: <20230207063254.401538-7-adwivedi@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230207063254.401538-1-adwivedi@marvell.com> References: <20230206115810.308574-1-adwivedi@marvell.com> <20230207063254.401538-1-adwivedi@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: Om01RrPw5TNW3C2fKxkfMMofA1hTAhEc X-Proofpoint-ORIG-GUID: Om01RrPw5TNW3C2fKxkfMMofA1hTAhEc X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-06_07,2023-02-06_03,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.h | 332 +++++++++++++++++++++++++++++++ lib/ethdev/ethdev_trace_points.c | 90 +++++++++ lib/ethdev/rte_tm.c | 225 ++++++++++++++++++--- 3 files changed, 618 insertions(+), 29 deletions(-) diff --git a/lib/ethdev/ethdev_trace.h b/lib/ethdev/ethdev_trace.h index 5285a04c67..ffad9fd872 100644 --- a/lib/ethdev/ethdev_trace.h +++ b/lib/ethdev/ethdev_trace.h @@ -20,6 +20,7 @@ extern "C" { #include "rte_ethdev.h" #include "rte_mtr.h" +#include "rte_tm.h" RTE_TRACE_POINT( rte_ethdev_trace_configure, @@ -1859,6 +1860,337 @@ RTE_TRACE_POINT( rte_trace_point_emit_int(ret); ) +RTE_TRACE_POINT( + rte_tm_trace_get_number_of_leaf_nodes, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t n_leaf_nodes), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(n_leaf_nodes); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_type_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, int is_leaf, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_int(is_leaf); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, + const struct rte_tm_capabilities *cap, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_ptr(cap); + rte_trace_point_emit_u32(cap->n_nodes_max); + rte_trace_point_emit_u32(cap->n_levels_max); + rte_trace_point_emit_int(cap->non_leaf_nodes_identical); + rte_trace_point_emit_int(cap->leaf_nodes_identical); + rte_trace_point_emit_u32(cap->shaper_n_max); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_level_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t level_id, + const struct rte_tm_level_capabilities *cap, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(level_id); + rte_trace_point_emit_ptr(cap); + rte_trace_point_emit_u32(cap->n_nodes_max); + rte_trace_point_emit_u32(cap->n_nodes_nonleaf_max); + rte_trace_point_emit_u32(cap->n_nodes_leaf_max); + rte_trace_point_emit_u32(cap->non_leaf_nodes_identical); + rte_trace_point_emit_u32(cap->leaf_nodes_identical); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_capabilities_get, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + const struct rte_tm_node_capabilities *cap, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_ptr(cap); + rte_trace_point_emit_int(cap->shaper_private_supported); + rte_trace_point_emit_int(cap->shaper_private_dual_rate_supported); + rte_trace_point_emit_int(cap->shaper_private_packet_mode_supported); + rte_trace_point_emit_int(cap->shaper_private_byte_mode_supported); + rte_trace_point_emit_u32(cap->shaper_shared_n_max); + rte_trace_point_emit_u64(cap->stats_mask); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_wred_profile_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t wred_profile_id, + const struct rte_tm_wred_params *profile, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_wred_profile_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t wred_profile_id, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(wred_profile_id); + rte_trace_point_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_shared_wred_context_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shared_wred_context_id, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shared_wred_context_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_shaper_profile_add, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shaper_profile_id, + const struct rte_tm_shaper_params *profile, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_shaper_profile_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shaper_profile_id, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shaper_profile_id); + rte_trace_point_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_shared_shaper_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t shared_shaper_id, + int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(shared_shaper_id); + rte_trace_point_emit_int(ret); +) + +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, + const struct rte_tm_node_params *params, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_delete, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_suspend, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_resume, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_hierarchy_commit, + RTE_TRACE_POINT_ARGS(uint16_t port_id, int clear_on_fail, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_int(clear_on_fail); + rte_trace_point_emit_int(ret); +) + +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, int ret), + 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_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_u64(stats_mask); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_wfq_weight_mode_update, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + const int *wfq_weight_mode, uint32_t n_sp_priorities, + int ret), + 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_emit_int(ret); +) + +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, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_int(cman); + rte_trace_point_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_tm_trace_node_stats_read, + RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t node_id, + const struct rte_tm_node_stats *stats, + uint64_t stats_mask, int clear, int ret), + rte_trace_point_emit_u16(port_id); + rte_trace_point_emit_u32(node_id); + rte_trace_point_emit_ptr(stats); + rte_trace_point_emit_u64(stats->n_pkts); + rte_trace_point_emit_u64(stats->n_bytes); + rte_trace_point_emit_u64(stats_mask); + rte_trace_point_emit_int(clear); + rte_trace_point_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + +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, int ret), + 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_emit_int(ret); +) + /* Fast path trace points */ /* Called in loop in examples/qos_sched and examples/distributor */ diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c index c34c06941c..34d12e2859 100644 --- a/lib/ethdev/ethdev_trace_points.c +++ b/lib/ethdev/ethdev_trace_points.c @@ -654,3 +654,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_tm.c b/lib/ethdev/rte_tm.c index 9709454f35..2d08141133 100644 --- a/lib/ethdev/rte_tm.c +++ b/lib/ethdev/rte_tm.c @@ -5,6 +5,7 @@ #include #include +#include "ethdev_trace.h" #include "rte_ethdev.h" #include "rte_tm_driver.h" #include "rte_tm.h" @@ -79,6 +80,9 @@ 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); + return 0; } @@ -90,8 +94,13 @@ rte_tm_node_type_get(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_TM_FUNC(port_id, node_type_get)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_type_get)(dev, node_id, is_leaf, error); + + rte_tm_trace_node_type_get(port_id, node_id, *is_leaf, ret); + + return ret; } /* Get capabilities */ @@ -100,8 +109,13 @@ int rte_tm_capabilities_get(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_TM_FUNC(port_id, capabilities_get)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, capabilities_get)(dev, cap, error); + + rte_tm_trace_capabilities_get(port_id, cap, ret); + + return ret; } /* Get level capabilities */ @@ -111,8 +125,13 @@ 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]; - return RTE_TM_FUNC(port_id, level_capabilities_get)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, level_capabilities_get)(dev, level_id, cap, error); + + rte_tm_trace_level_capabilities_get(port_id, level_id, cap, ret); + + return ret; } /* Get node capabilities */ @@ -122,8 +141,13 @@ 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]; - return RTE_TM_FUNC(port_id, node_capabilities_get)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_capabilities_get)(dev, node_id, cap, error); + + rte_tm_trace_node_capabilities_get(port_id, node_id, cap, ret); + + return ret; } /* Add WRED profile */ @@ -133,8 +157,13 @@ 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]; - return RTE_TM_FUNC(port_id, wred_profile_add)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, wred_profile_add)(dev, wred_profile_id, profile, error); + + rte_tm_trace_wred_profile_add(port_id, wred_profile_id, profile, ret); + + return ret; } /* Delete WRED profile */ @@ -143,8 +172,13 @@ 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]; - return RTE_TM_FUNC(port_id, wred_profile_delete)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, wred_profile_delete)(dev, wred_profile_id, error); + + rte_tm_trace_wred_profile_delete(port_id, wred_profile_id, ret); + + return ret; } /* Add/update shared WRED context */ @@ -154,8 +188,15 @@ 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]; - return RTE_TM_FUNC(port_id, shared_wred_context_add_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, shared_wred_context_add_update)(dev, shared_wred_context_id, wred_profile_id, error); + + rte_tm_trace_shared_wred_context_add_update(port_id, + shared_wred_context_id, + wred_profile_id, ret); + + return ret; } /* Delete shared WRED context */ @@ -164,8 +205,14 @@ 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]; - return RTE_TM_FUNC(port_id, shared_wred_context_delete)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, shared_wred_context_delete)(dev, shared_wred_context_id, error); + + rte_tm_trace_shared_wred_context_delete(port_id, + shared_wred_context_id, ret); + + return ret; } /* Add shaper profile */ @@ -175,8 +222,14 @@ 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]; - return RTE_TM_FUNC(port_id, shaper_profile_add)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, shaper_profile_add)(dev, shaper_profile_id, profile, error); + + rte_tm_trace_shaper_profile_add(port_id, shaper_profile_id, profile, + ret); + + return ret; } /* Delete WRED profile */ @@ -185,8 +238,13 @@ 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]; - return RTE_TM_FUNC(port_id, shaper_profile_delete)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, shaper_profile_delete)(dev, shaper_profile_id, error); + + rte_tm_trace_shaper_profile_delete(port_id, shaper_profile_id, ret); + + return ret; } /* Add shared shaper */ @@ -196,8 +254,14 @@ 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]; - return RTE_TM_FUNC(port_id, shared_shaper_add_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, shared_shaper_add_update)(dev, shared_shaper_id, shaper_profile_id, error); + + rte_tm_trace_shared_shaper_add_update(port_id, shared_shaper_id, + shaper_profile_id, ret); + + return ret; } /* Delete shared shaper */ @@ -206,8 +270,13 @@ 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]; - return RTE_TM_FUNC(port_id, shared_shaper_delete)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, shared_shaper_delete)(dev, shared_shaper_id, error); + + rte_tm_trace_shared_shaper_delete(port_id, shared_shaper_id, ret); + + return ret; } /* Add node to port traffic manager hierarchy */ @@ -221,9 +290,15 @@ int rte_tm_node_add(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_TM_FUNC(port_id, node_add)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_add)(dev, node_id, parent_node_id, priority, weight, level_id, params, error); + + rte_tm_trace_node_add(port_id, node_id, parent_node_id, priority, + weight, level_id, params, ret); + + return ret; } /* Delete node from traffic manager hierarchy */ @@ -232,8 +307,13 @@ int rte_tm_node_delete(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_TM_FUNC(port_id, node_delete)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_delete)(dev, node_id, error); + + rte_tm_trace_node_delete(port_id, node_id, ret); + + return ret; } /* Suspend node */ @@ -242,8 +322,13 @@ int rte_tm_node_suspend(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_TM_FUNC(port_id, node_suspend)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_suspend)(dev, node_id, error); + + rte_tm_trace_node_suspend(port_id, node_id, ret); + + return ret; } /* Resume node */ @@ -252,8 +337,13 @@ int rte_tm_node_resume(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_TM_FUNC(port_id, node_resume)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_resume)(dev, node_id, error); + + rte_tm_trace_node_resume(port_id, node_id, ret); + + return ret; } /* Commit the initial port traffic manager hierarchy */ @@ -262,8 +352,13 @@ int rte_tm_hierarchy_commit(uint16_t port_id, struct rte_tm_error *error) { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; - return RTE_TM_FUNC(port_id, hierarchy_commit)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, hierarchy_commit)(dev, clear_on_fail, error); + + rte_tm_trace_hierarchy_commit(port_id, clear_on_fail, ret); + + return ret; } /* Update node parent */ @@ -275,8 +370,14 @@ 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]; - return RTE_TM_FUNC(port_id, node_parent_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_parent_update)(dev, node_id, parent_node_id, priority, weight, error); + + rte_tm_trace_node_parent_update(port_id, node_id, parent_node_id, + priority, weight, ret); + + return ret; } /* Update node private shaper */ @@ -286,8 +387,14 @@ 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]; - return RTE_TM_FUNC(port_id, node_shaper_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_shaper_update)(dev, node_id, shaper_profile_id, error); + + rte_tm_trace_node_shaper_update(port_id, node_id, shaper_profile_id, + ret); + + return ret; } /* Update node shared shapers */ @@ -298,8 +405,14 @@ 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]; - return RTE_TM_FUNC(port_id, node_shared_shaper_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_shared_shaper_update)(dev, node_id, shared_shaper_id, add, error); + + rte_tm_trace_node_shared_shaper_update(port_id, node_id, + shared_shaper_id, add, ret); + + return ret; } /* Update node stats */ @@ -309,8 +422,13 @@ 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]; - return RTE_TM_FUNC(port_id, node_stats_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_stats_update)(dev, node_id, stats_mask, error); + + rte_tm_trace_node_stats_update(port_id, node_id, stats_mask, ret); + + return ret; } /* Update WFQ weight mode */ @@ -321,8 +439,15 @@ 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]; - return RTE_TM_FUNC(port_id, node_wfq_weight_mode_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_wfq_weight_mode_update)(dev, node_id, wfq_weight_mode, n_sp_priorities, error); + + rte_tm_trace_node_wfq_weight_mode_update(port_id, node_id, + wfq_weight_mode, + n_sp_priorities, ret); + + return ret; } /* Update node congestion management mode */ @@ -332,8 +457,13 @@ 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]; - return RTE_TM_FUNC(port_id, node_cman_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_cman_update)(dev, node_id, cman, error); + + rte_tm_trace_node_cman_update(port_id, node_id, cman, ret); + + return ret; } /* Update node private WRED context */ @@ -343,8 +473,14 @@ 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]; - return RTE_TM_FUNC(port_id, node_wred_context_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_wred_context_update)(dev, node_id, wred_profile_id, error); + + rte_tm_trace_node_wred_context_update(port_id, node_id, wred_profile_id, + ret); + + return ret; } /* Update node shared WRED context */ @@ -355,8 +491,15 @@ 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]; - return RTE_TM_FUNC(port_id, node_shared_wred_context_update)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_shared_wred_context_update)(dev, node_id, shared_wred_context_id, add, error); + + rte_tm_trace_node_shared_wred_context_update(port_id, node_id, + shared_wred_context_id, + add, ret); + + return ret; } /* Read and/or clear stats counters for specific node */ @@ -368,8 +511,14 @@ 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]; - return RTE_TM_FUNC(port_id, node_stats_read)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, node_stats_read)(dev, node_id, stats, stats_mask, clear, error); + + rte_tm_trace_node_stats_read(port_id, node_id, stats, *stats_mask, + clear, ret); + + return ret; } /* Packet marking - VLAN DEI */ @@ -380,8 +529,14 @@ 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]; - return RTE_TM_FUNC(port_id, mark_vlan_dei)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, mark_vlan_dei)(dev, mark_green, mark_yellow, mark_red, error); + + rte_tm_trace_mark_vlan_dei(port_id, mark_green, mark_yellow, mark_red, + ret); + + return ret; } /* Packet marking - IPv4/IPv6 ECN */ @@ -392,8 +547,14 @@ 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]; - return RTE_TM_FUNC(port_id, mark_ip_ecn)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, mark_ip_ecn)(dev, mark_green, mark_yellow, mark_red, error); + + rte_tm_trace_mark_ip_ecn(port_id, mark_green, mark_yellow, mark_red, + ret); + + return ret; } /* Packet marking - IPv4/IPv6 DSCP */ @@ -404,6 +565,12 @@ 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]; - return RTE_TM_FUNC(port_id, mark_ip_dscp)(dev, + int ret; + ret = RTE_TM_FUNC(port_id, mark_ip_dscp)(dev, mark_green, mark_yellow, mark_red, error); + + rte_tm_trace_mark_ip_dscp(port_id, mark_green, mark_yellow, mark_red, + ret); + + return ret; }