From patchwork Tue Jan 31 13:44:33 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Amit Prakash Shukla X-Patchwork-Id: 122759 X-Patchwork-Delegate: jerinj@marvell.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 18F2141B8F; Tue, 31 Jan 2023 14:44:57 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 07351410E6; Tue, 31 Jan 2023 14:44:57 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id AAA0B4067B for ; Tue, 31 Jan 2023 14:44:47 +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 30VDKrVZ022854; Tue, 31 Jan 2023 05:44:47 -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=DNy1Ynp8cH4wQ3S1yMqZkVQ3D+YvhSRoPoh7vPqX2TQ=; b=iija2KssEquFTdCxcLEQ3c0T1d0ZDnPaN9IyJntRDDY5XuGT7L0ULSF/FeoyirngdXg4 zd5LLc3rV5m7327NSc+meOycEyKSsDoc06mUmXlQZnAuxS09YBoE6X9UadbjFIoQxlRX dgnr8pNOKnW1iszyhSYVOzob/nCboA3o6mqz63AXvTN/Aq6JljJS4XJF+tekFJYxPM7c gLWwopNKd5KobjVIeZGrftfh8gN9NzUiqoCWz+4HoymSysm+9RA6D7V82PqSyopUDm+M Jx3o1vha8dK44z1MNzV5ZfYb90PA1gYjr1n1Xq9BofdWCzv9hNURgslSs3/DFFcHNFI5 jQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nd442r8ph-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 31 Jan 2023 05:44:41 -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; Tue, 31 Jan 2023 05:44:38 -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; Tue, 31 Jan 2023 05:44:38 -0800 Received: from localhost.localdomain (unknown [10.28.36.157]) by maili.marvell.com (Postfix) with ESMTP id 6C6803F704D; Tue, 31 Jan 2023 05:44:36 -0800 (PST) From: Amit Prakash Shukla To: Jerin Jacob , Abhinandan Gujjar , Naga Harish K S V , Erik Gabriel Carrillo CC: , Amit Prakash Shukla Subject: [PATCH v5] eventdev: add trace points Date: Tue, 31 Jan 2023 19:14:33 +0530 Message-ID: <20230131134433.2021568-1-amitprakashs@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230131133042.2019506-1-amitprakashs@marvell.com> References: <20230131133042.2019506-1-amitprakashs@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: 9A8eY-W4fQf1-mteTiTRrzzNTsk1He7- X-Proofpoint-ORIG-GUID: 9A8eY-W4fQf1-mteTiTRrzzNTsk1He7- 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-01-31_08,2023-01-31_01,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Add trace points for eventdev functions. Signed-off-by: Amit Prakash Shukla --- v2: - Fixed CI test failure - Code review suggestion from Abhinandan v3: - Removed trace symbols from version.map v4: - Fixed CI test failure - Cleaned-up unwanted includes and trace functions - Added traces to pending functions v5: - Fixed coding style issue lib/eventdev/eventdev_trace.h | 495 +++++++++++++++++++++++- lib/eventdev/eventdev_trace_points.c | 159 ++++++++ lib/eventdev/rte_event_crypto_adapter.c | 18 +- lib/eventdev/rte_event_eth_rx_adapter.c | 31 +- lib/eventdev/rte_event_eth_tx_adapter.c | 21 +- lib/eventdev/rte_event_ring.c | 9 + lib/eventdev/rte_event_timer_adapter.c | 15 + lib/eventdev/rte_eventdev.c | 49 ++- 8 files changed, 784 insertions(+), 13 deletions(-) diff --git a/lib/eventdev/eventdev_trace.h b/lib/eventdev/eventdev_trace.h index d48cd58850..71e996e562 100644 --- a/lib/eventdev/eventdev_trace.h +++ b/lib/eventdev/eventdev_trace.h @@ -63,6 +63,7 @@ RTE_TRACE_POINT( rte_trace_point_emit_u16(port_conf->enqueue_depth); rte_trace_point_emit_u32(port_conf->event_port_cfg); rte_trace_point_emit_int(rc); + rte_trace_point_emit_ptr(port_conf); ) RTE_TRACE_POINT( @@ -250,16 +251,17 @@ RTE_TRACE_POINT( RTE_TRACE_POINT( rte_eventdev_trace_crypto_adapter_create, - RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint8_t dev_id, void *adapter, - struct rte_event_port_conf *port_conf, uint8_t mode), + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint8_t dev_id, + struct rte_event_port_conf *port_config, int mode, int ret), rte_trace_point_emit_u8(adptr_id); rte_trace_point_emit_u8(dev_id); - rte_trace_point_emit_ptr(adapter); - rte_trace_point_emit_u8(mode); - rte_trace_point_emit_i32(port_conf->new_event_threshold); - rte_trace_point_emit_u16(port_conf->dequeue_depth); - rte_trace_point_emit_u16(port_conf->enqueue_depth); - rte_trace_point_emit_u32(port_conf->event_port_cfg); + rte_trace_point_emit_ptr(port_config); + rte_trace_point_emit_i32(port_config->new_event_threshold); + rte_trace_point_emit_u16(port_config->dequeue_depth); + rte_trace_point_emit_u16(port_config->enqueue_depth); + rte_trace_point_emit_u32(port_config->event_port_cfg); + rte_trace_point_emit_int(mode); + rte_trace_point_emit_int(ret); ) RTE_TRACE_POINT( @@ -303,6 +305,483 @@ RTE_TRACE_POINT( rte_trace_point_emit_u8(adptr_id); ) +RTE_TRACE_POINT( + rte_eventdev_trace_crypto_adapter_event_port_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint8_t event_port_id), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u8(event_port_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_crypto_adapter_service_id_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint32_t service_id), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u32(service_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_attr_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint32_t attr_id, + uint32_t attr_value), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u32(attr_id); + rte_trace_point_emit_u32(attr_value); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_get_dev_id, + RTE_TRACE_POINT_ARGS(const char *name, int dev_id), + rte_trace_point_emit_string(name); + rte_trace_point_emit_int(dev_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_info_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev_info, const void *dev), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev_info); + rte_trace_point_emit_ptr(dev); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_service_id_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint32_t service_id), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u32(service_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_socket_id, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, int socket_id), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_int(socket_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_stop_flush_callback_register, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *callback, const void *userdata), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(callback); + rte_trace_point_emit_ptr(userdata); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_caps_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t eth_port_id), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(eth_port_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_cb_register, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint16_t eth_dev_id, const void *cb_fn, + const void *cb_arg), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_ptr(cb_fn); + rte_trace_point_emit_ptr(cb_arg); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_create_with_params, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint8_t dev_id, + const struct rte_event_port_conf *port_config, + const struct rte_event_eth_rx_adapter_params *rxa_params, + int ret), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(port_config); + rte_trace_point_emit_i32(port_config->new_event_threshold); + rte_trace_point_emit_u16(port_config->dequeue_depth); + rte_trace_point_emit_u16(port_config->enqueue_depth); + rte_trace_point_emit_u32(port_config->event_port_cfg); + rte_trace_point_emit_ptr(rxa_params); + rte_trace_point_emit_u16(rxa_params->event_buf_size); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_service_id_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint32_t service_id), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u32(service_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_event_port_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint8_t event_port_id), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u8(event_port_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_vector_limits_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t eth_port_id, + uint16_t min_sz, uint16_t max_sz, uint8_t log2_sz, + uint64_t min_timeout_ns, uint64_t max_timeout_ns, int ret), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(eth_port_id); + rte_trace_point_emit_u16(min_sz); + rte_trace_point_emit_u16(max_sz); + rte_trace_point_emit_u8(log2_sz); + rte_trace_point_emit_u64(min_timeout_ns); + rte_trace_point_emit_u64(max_timeout_ns); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_caps_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint16_t eth_port_id, + const void *eth_dev), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u16(eth_port_id); + rte_trace_point_emit_ptr(eth_dev); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_event_port_get, + RTE_TRACE_POINT_ARGS(uint8_t id), + rte_trace_point_emit_u8(id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_service_id_get, + RTE_TRACE_POINT_ARGS(uint8_t id, uint32_t service_id), + rte_trace_point_emit_u8(id); + rte_trace_point_emit_u32(service_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_port_attr_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint8_t port_id, + uint32_t attr_id, uint32_t attr_value), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u8(port_id); + rte_trace_point_emit_u32(attr_id); + rte_trace_point_emit_u32(attr_value); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_port_default_conf_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint8_t port_id, + const struct rte_event_port_conf *port_conf), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u8(port_id); + rte_trace_point_emit_ptr(port_conf); + rte_trace_point_emit_i32(port_conf->new_event_threshold); + rte_trace_point_emit_u16(port_conf->dequeue_depth); + rte_trace_point_emit_u16(port_conf->enqueue_depth); + rte_trace_point_emit_u32(port_conf->event_port_cfg); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_port_links_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint8_t port_id, int count), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u8(port_id); + rte_trace_point_emit_int(count); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_port_unlinks_in_progress, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint8_t port_id), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u8(port_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_queue_attr_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint8_t queue_id, + uint32_t attr_id, uint32_t attr_value), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u8(queue_id); + rte_trace_point_emit_u32(attr_id); + rte_trace_point_emit_u32(attr_value); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_queue_default_conf_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint8_t queue_id, + const struct rte_event_queue_conf *queue_conf), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u8(queue_id); + rte_trace_point_emit_ptr(queue_conf); + rte_trace_point_emit_u32(queue_conf->nb_atomic_flows); + rte_trace_point_emit_u32(queue_conf->nb_atomic_order_sequences); + rte_trace_point_emit_u32(queue_conf->event_queue_cfg); + rte_trace_point_emit_u8(queue_conf->schedule_type); + rte_trace_point_emit_u8(queue_conf->priority); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_ring_create, + RTE_TRACE_POINT_ARGS(const char *name, unsigned int count, + int socket_id, unsigned int flags), + rte_trace_point_emit_string(name); + rte_trace_point_emit_u32(count); + rte_trace_point_emit_int(socket_id); + rte_trace_point_emit_u32(flags); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_ring_free, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_ring_init, + RTE_TRACE_POINT_ARGS(const void *r, const char *name, + unsigned int count, unsigned int flags), + rte_trace_point_emit_ptr(r); + rte_trace_point_emit_string(name); + rte_trace_point_emit_u32(count); + rte_trace_point_emit_u32(flags); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_ring_lookup, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_timer_adapter_caps_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id), + rte_trace_point_emit_u8(dev_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_timer_adapter_get_info, + RTE_TRACE_POINT_ARGS(const void *adapter, + const struct rte_event_timer_adapter_info *adapter_info), + rte_trace_point_emit_ptr(adapter); + rte_trace_point_emit_ptr(adapter_info); + rte_trace_point_emit_u64(adapter_info->min_resolution_ns); + rte_trace_point_emit_u64(adapter_info->max_tmo_ns); + rte_trace_point_emit_u32(adapter_info->caps); + rte_trace_point_emit_u16(adapter_info->event_dev_port_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_timer_adapter_lookup, + RTE_TRACE_POINT_ARGS(uint16_t adapter_id, const void *adapter), + rte_trace_point_emit_u16(adapter_id); + rte_trace_point_emit_ptr(adapter); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_timer_adapter_service_id_get, + RTE_TRACE_POINT_ARGS(const struct rte_event_timer_adapter *adapter, + uint32_t service_id), + rte_trace_point_emit_ptr(adapter); + rte_trace_point_emit_u32(service_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_vector_pool_create, + RTE_TRACE_POINT_ARGS(const void *mp, const char *name, int socket_id, + uint32_t size, uint32_t cache_size, uint32_t elt_size), + rte_trace_point_emit_ptr(mp); + rte_trace_point_emit_string(name); + rte_trace_point_emit_int(socket_id); + rte_trace_point_emit_u32(size); + rte_trace_point_emit_u32(cache_size); + rte_trace_point_emit_u32(elt_size); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_queue_conf_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint16_t eth_dev_id, + uint16_t rx_queue_id, const void *queue_conf), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_ptr(queue_conf); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_queue_attr_set, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint8_t queue_id, uint32_t attr_id, + uint32_t attr_value), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u8(queue_id); + rte_trace_point_emit_u32(attr_id); + rte_trace_point_emit_u32(attr_value); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_port_quiesce, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint8_t port_id, const void *args), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u8(port_id); + rte_trace_point_emit_ptr(args); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_crypto_adapter_caps_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, uint8_t cdev_id, + const void *cdev), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_u8(cdev_id); + rte_trace_point_emit_ptr(cdev); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_dequeue_timeout_ticks, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint64_t ns, + const void *timeout_ticks), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u64(ns); + rte_trace_point_emit_ptr(timeout_ticks); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_crypto_adapter_stats_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, const void *stats, + uint64_t event_poll_count, uint64_t event_deq_count, + uint64_t crypto_enq_count, uint64_t crypto_enq_fail, + uint64_t crypto_deq_count, uint64_t event_enq_count, + uint64_t event_enq_retry_count, uint64_t event_enq_fail_count), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_ptr(stats); + rte_trace_point_emit_u64(event_poll_count); + rte_trace_point_emit_u64(event_deq_count); + rte_trace_point_emit_u64(crypto_enq_count); + rte_trace_point_emit_u64(crypto_enq_fail); + rte_trace_point_emit_u64(crypto_deq_count); + rte_trace_point_emit_u64(event_enq_count); + rte_trace_point_emit_u64(event_enq_retry_count); + rte_trace_point_emit_u64(event_enq_fail_count); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_crypto_adapter_stats_reset, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id), + rte_trace_point_emit_u8(adptr_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_stats_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, const void *stats), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_ptr(stats); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_crypto_adapter_vector_limits_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t cdev_id, + const void *limits), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(cdev_id); + rte_trace_point_emit_ptr(limits); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_queue_stats_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint16_t eth_dev_id, + uint16_t rx_queue_id, const void *stats), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_ptr(stats); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_stats_reset, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id), + rte_trace_point_emit_u8(adptr_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_queue_stats_reset, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint16_t eth_dev_id, + uint16_t rx_queue_id), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_u16(rx_queue_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_rx_adapter_instance_get, + RTE_TRACE_POINT_ARGS(uint16_t eth_dev_id, uint16_t rx_queue_id, + uint8_t rxa_inst_id), + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_u16(rx_queue_id); + rte_trace_point_emit_u8(rxa_inst_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_stats_get, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint64_t tx_retry, + uint64_t tx_packets, uint64_t tx_dropped, int ret), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_u64(tx_retry); + rte_trace_point_emit_u64(tx_packets); + rte_trace_point_emit_u64(tx_dropped); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_stats_reset, + RTE_TRACE_POINT_ARGS(uint8_t adptr_id, int ret), + rte_trace_point_emit_u8(adptr_id); + rte_trace_point_emit_int(ret); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_instance_get, + RTE_TRACE_POINT_ARGS(uint16_t eth_dev_id, uint16_t tx_queue_id, + uint8_t txa_inst_id), + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_u16(tx_queue_id); + rte_trace_point_emit_u8(txa_inst_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_queue_start, + RTE_TRACE_POINT_ARGS(uint16_t eth_dev_id, uint16_t tx_queue_id), + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_u16(tx_queue_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_eth_tx_adapter_queue_stop, + RTE_TRACE_POINT_ARGS(uint16_t eth_dev_id, uint16_t tx_queue_id), + rte_trace_point_emit_u16(eth_dev_id); + rte_trace_point_emit_u16(tx_queue_id); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_timer_adapter_stats_get, + RTE_TRACE_POINT_ARGS(const void *adapter, const void *stats), + rte_trace_point_emit_ptr(adapter); + rte_trace_point_emit_ptr(stats); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_timer_adapter_stats_reset, + RTE_TRACE_POINT_ARGS(const void *adapter), + rte_trace_point_emit_ptr(adapter); +) + +RTE_TRACE_POINT( + rte_eventdev_trace_timer_remaining_ticks_get, + RTE_TRACE_POINT_ARGS(const void *adapter, const void *evtim, const void *ticks_remaining), + rte_trace_point_emit_ptr(adapter); + rte_trace_point_emit_ptr(evtim); + rte_trace_point_emit_ptr(ticks_remaining); +) + #ifdef __cplusplus } #endif diff --git a/lib/eventdev/eventdev_trace_points.c b/lib/eventdev/eventdev_trace_points.c index de6b1f4417..76144cfe75 100644 --- a/lib/eventdev/eventdev_trace_points.c +++ b/lib/eventdev/eventdev_trace_points.c @@ -124,3 +124,162 @@ RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_stop, RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_enqueue, lib.eventdev.crypto.enq) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_event_port_get, + lib.eventdev.crypto.adapter_event_port_get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_service_id_get, + lib.eventdev.crypto.adapter_service_id_get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_vector_limits_get, + lib.eventdev.crypto.adapter_vector_limits_get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_attr_get, + lib.eventdev.attr_get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_get_dev_id, + lib.eventdev.get_dev_id) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_info_get, + lib.eventdev.info_get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_service_id_get, + lib.eventdev.service_id_get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_socket_id, + lib.eventdev.socket.id) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_stop_flush_callback_register, + lib.eventdev.stop.flush.callback.register) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_caps_get, + lib.eventdev.eth.rx.adapter.caps.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_cb_register, + lib.eventdev.eth.rx.adapter.cb.register) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_service_id_get, + lib.eventdev.eth.rx.adapter.service.id.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_event_port_get, + lib.eventdev.eth.rx.adapter.event.port.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_vector_limits_get, + lib.eventdev.eth.rx.adapter.vector.limits.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_queue_stats_get, + lib.eventdev.eth.rx.adapter.queue.stats.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_stats_reset, + lib.eventdev.eth.rx.adapter.stats.reset) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_queue_stats_reset, + lib.eventdev.eth.rx.adapter.queue.stats.reset) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_instance_get, + lib.eventdev.eth.rx.adapter.instance.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_caps_get, + lib.eventdev.eth.tx.adapter.caps.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_event_port_get, + lib.eventdev.eth.tx.adapter.event.port.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_service_id_get, + lib.eventdev.eth.tx.adapter.service.id.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_stats_get, + lib.eventdev.eth.tx.adapter.stats.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_stats_reset, + lib.eventdev.eth.tx.adapter.stats.reset) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_instance_get, + lib.eventdev.eth.tx.adapter.instance.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_port_attr_get, + lib.eventdev.port.attr.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_port_default_conf_get, + lib.eventdev.port.default.conf.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_port_links_get, + lib.eventdev.port.links.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_port_unlinks_in_progress, + lib.eventdev.port.unlinks.in.progress) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_queue_attr_get, + lib.eventdev.queue.attr.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_queue_default_conf_get, + lib.eventdev.queue.default.conf.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_ring_create, + lib.eventdev.ring.create) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_ring_free, + lib.eventdev.ring.free) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_ring_init, + lib.eventdev.ring.init) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_ring_lookup, + lib.eventdev.ring.lookup) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_timer_adapter_caps_get, + lib.eventdev.timer.adapter.caps.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_timer_adapter_get_info, + lib.eventdev.timer.adapter.get.info) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_timer_adapter_lookup, + lib.eventdev.timer.adapter.lookup) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_timer_adapter_service_id_get, + lib.eventdev.timer.adapter.service.id.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_vector_pool_create, + lib.eventdev.vector.pool.create) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_create_with_params, + lib.eventdev.eth.rx.adapter.create.with.params) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_queue_conf_get, + lib.eventdev.eth.rx.adapter.queue.conf.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_queue_attr_set, + lib.eventdev.queue.attr.set) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_port_quiesce, + lib.eventdev.port.quiesce) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_caps_get, + lib.eventdev.crypto.adapter.caps.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_dequeue_timeout_ticks, + lib.eventdev.dequeue.timeout.ticks) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_stats_get, + lib.eventdev.crypto.adapter.stats.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_crypto_adapter_stats_reset, + lib.eventdev.crypto.adapter.stats.reset) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_stats_get, + lib.eventdev.rx.adapter.stats.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_queue_start, + lib.eventdev.tx.adapter.queue.start) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_tx_adapter_queue_stop, + lib.eventdev.tx.adapter.queue.stop) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_timer_adapter_stats_get, + lib.eventdev.timer.adapter.stats.get) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_timer_adapter_stats_reset, + lib.eventdev.timer.adapter.stats.reset) + +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_timer_remaining_ticks_get, + lib.eventdev.timer.remaining.ticks.get) diff --git a/lib/eventdev/rte_event_crypto_adapter.c b/lib/eventdev/rte_event_crypto_adapter.c index bb782208f0..7f0a25a4cc 100644 --- a/lib/eventdev/rte_event_crypto_adapter.c +++ b/lib/eventdev/rte_event_crypto_adapter.c @@ -386,8 +386,6 @@ rte_event_crypto_adapter_create_ext(uint8_t id, uint8_t dev_id, event_crypto_adapter[id] = adapter; - rte_eventdev_trace_crypto_adapter_create(id, dev_id, adapter, conf_arg, - mode); return 0; } @@ -415,6 +413,8 @@ rte_event_crypto_adapter_create(uint8_t id, uint8_t dev_id, if (ret) rte_free(pc); + rte_eventdev_trace_crypto_adapter_create(id, dev_id, port_config, mode, ret); + return ret; } @@ -1293,6 +1293,12 @@ rte_event_crypto_adapter_stats_get(uint8_t id, stats->crypto_deq_count += dev_stats_sum.crypto_deq_count; stats->event_enq_count += dev_stats_sum.event_enq_count; + rte_eventdev_trace_crypto_adapter_stats_get(id, stats, + stats->event_poll_count, stats->event_deq_count, + stats->crypto_enq_count, stats->crypto_enq_fail, + stats->crypto_deq_count, stats->event_enq_count, + stats->event_enq_retry_count, stats->event_enq_fail_count); + return 0; } @@ -1304,6 +1310,8 @@ rte_event_crypto_adapter_stats_reset(uint8_t id) struct rte_eventdev *dev; uint32_t i; + rte_eventdev_trace_crypto_adapter_stats_reset(id); + if (eca_memzone_lookup()) return -ENOMEM; @@ -1341,6 +1349,8 @@ rte_event_crypto_adapter_service_id_get(uint8_t id, uint32_t *service_id) if (adapter->service_inited) *service_id = adapter->service_id; + rte_eventdev_trace_crypto_adapter_service_id_get(id, *service_id); + return adapter->service_inited ? 0 : -ESRCH; } @@ -1357,6 +1367,8 @@ rte_event_crypto_adapter_event_port_get(uint8_t id, uint8_t *event_port_id) *event_port_id = adapter->event_port_id; + rte_eventdev_trace_crypto_adapter_event_port_get(id, *event_port_id); + return 0; } @@ -1370,6 +1382,8 @@ rte_event_crypto_adapter_vector_limits_get( uint32_t cap; int ret; + rte_eventdev_trace_crypto_adapter_vector_limits_get(dev_id, cdev_id, limits); + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); if (!rte_cryptodev_is_valid_dev(cdev_id)) { diff --git a/lib/eventdev/rte_event_eth_rx_adapter.c b/lib/eventdev/rte_event_eth_rx_adapter.c index 34aa87379e..91bbba715b 100644 --- a/lib/eventdev/rte_event_eth_rx_adapter.c +++ b/lib/eventdev/rte_event_eth_rx_adapter.c @@ -2541,6 +2541,9 @@ rte_event_eth_rx_adapter_create_with_params(uint8_t id, uint8_t dev_id, if (ret) rte_free(pc); + rte_eventdev_trace_eth_rx_adapter_create_with_params(id, dev_id, + port_config, rxa_params, ret); + return ret; } @@ -2929,6 +2932,9 @@ rte_event_eth_rx_adapter_vector_limits_get( ret = rxa_sw_vector_limits(limits); } + rte_eventdev_trace_eth_rx_adapter_vector_limits_get(dev_id, eth_port_id, + limits->min_sz, limits->max_sz, limits->log2_sz, + limits->min_timeout_ns, limits->max_timeout_ns, ret); return ret; } @@ -2970,6 +2976,8 @@ rte_event_eth_rx_adapter_stats_get(uint8_t id, uint32_t i, j; int ret; + rte_eventdev_trace_eth_rx_adapter_stats_get(id, stats); + if (rxa_memzone_lookup()) return -ENOMEM; @@ -3041,6 +3049,9 @@ rte_event_eth_rx_adapter_queue_stats_get(uint8_t id, struct rte_event_eth_rx_adapter_stats *q_stats; struct rte_eventdev *dev; + rte_eventdev_trace_eth_rx_adapter_queue_stats_get(id, eth_dev_id, + rx_queue_id, stats); + if (rxa_memzone_lookup()) return -ENOMEM; @@ -3098,6 +3109,8 @@ rte_event_eth_rx_adapter_stats_reset(uint8_t id) struct eth_rx_queue_info *queue_info; uint32_t i, j; + rte_eventdev_trace_eth_rx_adapter_stats_reset(id); + if (rxa_memzone_lookup()) return -ENOMEM; @@ -3145,6 +3158,9 @@ rte_event_eth_rx_adapter_queue_stats_reset(uint8_t id, struct eth_rx_queue_info *queue_info; struct rte_eventdev *dev; + rte_eventdev_trace_eth_rx_adapter_queue_stats_reset(id, eth_dev_id, + rx_queue_id); + if (rxa_memzone_lookup()) return -ENOMEM; @@ -3203,6 +3219,8 @@ rte_event_eth_rx_adapter_service_id_get(uint8_t id, uint32_t *service_id) if (rx_adapter->service_inited) *service_id = rx_adapter->service_id; + rte_eventdev_trace_eth_rx_adapter_service_id_get(id, *service_id); + return rx_adapter->service_inited ? 0 : -ESRCH; } @@ -3223,6 +3241,8 @@ rte_event_eth_rx_adapter_event_port_get(uint8_t id, uint8_t *event_port_id) if (rx_adapter->service_inited) *event_port_id = rx_adapter->event_port_id; + rte_eventdev_trace_eth_rx_adapter_event_port_get(id, *event_port_id); + return rx_adapter->service_inited ? 0 : -ESRCH; } @@ -3237,6 +3257,9 @@ rte_event_eth_rx_adapter_cb_register(uint8_t id, uint32_t cap; int ret; + rte_eventdev_trace_eth_rx_adapter_cb_register(id, eth_dev_id, cb_fn, + cb_arg); + RTE_EVENT_ETH_RX_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL); RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_dev_id, -EINVAL); @@ -3284,6 +3307,9 @@ rte_event_eth_rx_adapter_queue_conf_get(uint8_t id, struct eth_rx_queue_info *queue_info; int ret; + rte_eventdev_trace_eth_rx_adapter_queue_conf_get(id, eth_dev_id, + rx_queue_id, queue_conf); + if (rxa_memzone_lookup()) return -ENOMEM; @@ -3429,8 +3455,11 @@ rte_event_eth_rx_adapter_instance_get(uint16_t eth_dev_id, } /* return if entry found */ - if (ret == 0) + if (ret == 0) { + rte_eventdev_trace_eth_rx_adapter_instance_get(eth_dev_id, rx_queue_id, + *rxa_inst_id); return ret; + } } return -EINVAL; diff --git a/lib/eventdev/rte_event_eth_tx_adapter.c b/lib/eventdev/rte_event_eth_tx_adapter.c index 6e9bcb1b79..cce50c3c18 100644 --- a/lib/eventdev/rte_event_eth_tx_adapter.c +++ b/lib/eventdev/rte_event_eth_tx_adapter.c @@ -995,6 +995,8 @@ txa_service_id_get(uint8_t id, uint32_t *service_id) return -EINVAL; *service_id = txa->service_id; + + rte_eventdev_trace_eth_tx_adapter_service_id_get(id, *service_id); return 0; } @@ -1123,6 +1125,8 @@ rte_event_eth_tx_adapter_create_ext(uint8_t id, uint8_t dev_id, int rte_event_eth_tx_adapter_event_port_get(uint8_t id, uint8_t *event_port_id) { + rte_eventdev_trace_eth_tx_adapter_event_port_get(id); + TXA_CHECK_OR_ERR_RET(id); return txa_service_event_port_get(id, event_port_id); @@ -1264,6 +1268,9 @@ rte_event_eth_tx_adapter_stats_get(uint8_t id, ret = txa_service_stats_get(id, stats); } + rte_eventdev_trace_eth_tx_adapter_stats_get(id, stats->tx_retry, stats->tx_packets, + stats->tx_dropped, ret); + return ret; } @@ -1278,6 +1285,9 @@ rte_event_eth_tx_adapter_stats_reset(uint8_t id) txa_dev_stats_reset(id)(id, txa_evdev(id)) : 0; if (ret == 0) ret = txa_service_stats_reset(id); + + rte_eventdev_trace_eth_tx_adapter_stats_reset(id, ret); + return ret; } @@ -1341,8 +1351,11 @@ rte_event_eth_tx_adapter_instance_get(uint16_t eth_dev_id, tx_queue_id, txa_inst_id) : -EINVAL; - if (ret == 0) + if (ret == 0) { + rte_eventdev_trace_eth_tx_adapter_instance_get(eth_dev_id, + tx_queue_id, *txa_inst_id); return ret; + } } else { struct rte_eth_dev *eth_dev; @@ -1351,6 +1364,8 @@ rte_event_eth_tx_adapter_instance_get(uint16_t eth_dev_id, if (txa_service_is_queue_added(txa, eth_dev, tx_queue_id)) { *txa_inst_id = txa->id; + rte_eventdev_trace_eth_tx_adapter_instance_get(eth_dev_id, + tx_queue_id, *txa_inst_id); return 0; } } @@ -1426,11 +1441,15 @@ txa_queue_start_state_set(uint16_t eth_dev_id, uint16_t tx_queue_id, int rte_event_eth_tx_adapter_queue_start(uint16_t eth_dev_id, uint16_t tx_queue_id) { + rte_eventdev_trace_eth_tx_adapter_queue_start(eth_dev_id, tx_queue_id); + return txa_queue_start_state_set(eth_dev_id, tx_queue_id, true); } int rte_event_eth_tx_adapter_queue_stop(uint16_t eth_dev_id, uint16_t tx_queue_id) { + rte_eventdev_trace_eth_tx_adapter_queue_stop(eth_dev_id, tx_queue_id); + return txa_queue_start_state_set(eth_dev_id, tx_queue_id, false); } diff --git a/lib/eventdev/rte_event_ring.c b/lib/eventdev/rte_event_ring.c index c070715148..b965970cf9 100644 --- a/lib/eventdev/rte_event_ring.c +++ b/lib/eventdev/rte_event_ring.c @@ -5,6 +5,7 @@ #include "rte_event_ring.h" +#include "eventdev_trace.h" int rte_event_ring_init(struct rte_event_ring *r, const char *name, @@ -14,6 +15,8 @@ rte_event_ring_init(struct rte_event_ring *r, const char *name, RTE_BUILD_BUG_ON((sizeof(struct rte_event_ring) & RTE_CACHE_LINE_MASK) != 0); + rte_eventdev_trace_ring_init(r, name, count, flags); + /* init the ring structure */ return rte_ring_init(&r->r, name, count, flags); } @@ -23,6 +26,8 @@ struct rte_event_ring * rte_event_ring_create(const char *name, unsigned int count, int socket_id, unsigned int flags) { + rte_eventdev_trace_ring_create(name, count, socket_id, flags); + return (struct rte_event_ring *)rte_ring_create_elem(name, sizeof(struct rte_event), count, socket_id, flags); @@ -32,6 +37,8 @@ rte_event_ring_create(const char *name, unsigned int count, int socket_id, struct rte_event_ring * rte_event_ring_lookup(const char *name) { + rte_eventdev_trace_ring_lookup(name); + return (struct rte_event_ring *)rte_ring_lookup(name); } @@ -39,5 +46,7 @@ rte_event_ring_lookup(const char *name) void rte_event_ring_free(struct rte_event_ring *r) { + rte_eventdev_trace_ring_free(r->r.name); + rte_ring_free((struct rte_ring *)r); } diff --git a/lib/eventdev/rte_event_timer_adapter.c b/lib/eventdev/rte_event_timer_adapter.c index d357f7403a..61712c3bd5 100644 --- a/lib/eventdev/rte_event_timer_adapter.c +++ b/lib/eventdev/rte_event_timer_adapter.c @@ -275,6 +275,8 @@ rte_event_timer_adapter_get_info(const struct rte_event_timer_adapter *adapter, adapter_info->event_dev_port_id = adapter->data->event_port_id; adapter_info->caps = adapter->data->caps; + rte_eventdev_trace_timer_adapter_get_info(adapter, adapter_info); + return 0; } @@ -386,6 +388,8 @@ rte_event_timer_adapter_lookup(uint16_t adapter_id) adapter->allocated = 1; + rte_eventdev_trace_timer_adapter_lookup(adapter_id, adapter); + return adapter; } @@ -436,9 +440,14 @@ rte_event_timer_adapter_service_id_get(struct rte_event_timer_adapter *adapter, { ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL); + if (service_id == NULL) + return -EINVAL; + if (adapter->data->service_inited && service_id != NULL) *service_id = adapter->data->service_id; + rte_eventdev_trace_timer_adapter_service_id_get(adapter, *service_id); + return adapter->data->service_inited ? 0 : -ESRCH; } @@ -446,6 +455,8 @@ int rte_event_timer_adapter_stats_get(struct rte_event_timer_adapter *adapter, struct rte_event_timer_adapter_stats *stats) { + rte_eventdev_trace_timer_adapter_stats_get(adapter, stats); + ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL); FUNC_PTR_OR_ERR_RET(adapter->ops->stats_get, -EINVAL); if (stats == NULL) @@ -457,6 +468,8 @@ rte_event_timer_adapter_stats_get(struct rte_event_timer_adapter *adapter, int rte_event_timer_adapter_stats_reset(struct rte_event_timer_adapter *adapter) { + rte_eventdev_trace_timer_adapter_stats_reset(adapter); + ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL); FUNC_PTR_OR_ERR_RET(adapter->ops->stats_reset, -EINVAL); return adapter->ops->stats_reset(adapter); @@ -468,6 +481,8 @@ rte_event_timer_remaining_ticks_get( const struct rte_event_timer *evtim, uint64_t *ticks_remaining) { + rte_eventdev_trace_timer_remaining_ticks_get(adapter, evtim, ticks_remaining); + ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL); FUNC_PTR_OR_ERR_RET(adapter->ops->remaining_ticks_get, -ENOTSUP); diff --git a/lib/eventdev/rte_eventdev.c b/lib/eventdev/rte_eventdev.c index b0414206d9..245b1d2d4e 100644 --- a/lib/eventdev/rte_eventdev.c +++ b/lib/eventdev/rte_eventdev.c @@ -62,8 +62,10 @@ rte_event_dev_get_dev_id(const char *name) rte_event_devices[i].dev->driver->name, name, RTE_EVENTDEV_NAME_MAX_LEN) == 0) : 0); if (cmp && (rte_event_devices[i].attached == - RTE_EVENTDEV_ATTACHED)) + RTE_EVENTDEV_ATTACHED)) { + rte_eventdev_trace_get_dev_id(name, i); return i; + } } return -ENODEV; } @@ -76,6 +78,8 @@ rte_event_dev_socket_id(uint8_t dev_id) RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); dev = &rte_eventdevs[dev_id]; + rte_eventdev_trace_socket_id(dev_id, dev, dev->data->socket_id); + return dev->data->socket_id; } @@ -99,6 +103,9 @@ rte_event_dev_info_get(uint8_t dev_id, struct rte_event_dev_info *dev_info) dev_info->dequeue_timeout_ns = dev->data->dev_conf.dequeue_timeout_ns; dev_info->dev = dev->dev; + + rte_eventdev_trace_info_get(dev_id, dev_info, dev_info->dev); + return 0; } @@ -108,6 +115,8 @@ rte_event_eth_rx_adapter_caps_get(uint8_t dev_id, uint16_t eth_port_id, { struct rte_eventdev *dev; + rte_eventdev_trace_eth_rx_adapter_caps_get(dev_id, eth_port_id); + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_port_id, -EINVAL); @@ -134,6 +143,8 @@ rte_event_timer_adapter_caps_get(uint8_t dev_id, uint32_t *caps) struct rte_eventdev *dev; const struct event_timer_adapter_ops *ops; + rte_eventdev_trace_timer_adapter_caps_get(dev_id); + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); dev = &rte_eventdevs[dev_id]; @@ -168,6 +179,8 @@ rte_event_crypto_adapter_caps_get(uint8_t dev_id, uint8_t cdev_id, dev = &rte_eventdevs[dev_id]; cdev = rte_cryptodev_pmd_get_dev(cdev_id); + rte_eventdev_trace_crypto_adapter_caps_get(dev_id, dev, cdev_id, cdev); + if (caps == NULL) return -EINVAL; @@ -194,6 +207,8 @@ rte_event_eth_tx_adapter_caps_get(uint8_t dev_id, uint16_t eth_port_id, dev = &rte_eventdevs[dev_id]; eth_dev = &rte_eth_devices[eth_port_id]; + rte_eventdev_trace_eth_tx_adapter_caps_get(dev_id, dev, eth_port_id, eth_dev); + if (caps == NULL) return -EINVAL; @@ -524,6 +539,9 @@ rte_event_queue_default_conf_get(uint8_t dev_id, uint8_t queue_id, return -ENOTSUP; memset(queue_conf, 0, sizeof(struct rte_event_queue_conf)); (*dev->dev_ops->queue_def_conf)(dev, queue_id, queue_conf); + + rte_eventdev_trace_queue_default_conf_get(dev_id, dev, queue_id, queue_conf); + return 0; } @@ -652,6 +670,9 @@ rte_event_port_default_conf_get(uint8_t dev_id, uint8_t port_id, return -ENOTSUP; memset(port_conf, 0, sizeof(struct rte_event_port_conf)); (*dev->dev_ops->port_def_conf)(dev, port_id, port_conf); + + rte_eventdev_trace_port_default_conf_get(dev_id, dev, port_id, port_conf); + return 0; } @@ -754,6 +775,8 @@ rte_event_port_quiesce(uint8_t dev_id, uint8_t port_id, RTE_EVENTDEV_VALID_DEVID_OR_RET(dev_id); dev = &rte_eventdevs[dev_id]; + rte_eventdev_trace_port_quiesce(dev_id, dev, port_id, args); + if (!is_valid_port(dev, port_id)) { RTE_EDEV_LOG_ERR("Invalid port_id=%" PRIu8, port_id); return; @@ -789,6 +812,8 @@ rte_event_dev_attr_get(uint8_t dev_id, uint32_t attr_id, return -EINVAL; } + rte_eventdev_trace_attr_get(dev_id, dev, attr_id, *attr_value); + return 0; } @@ -829,6 +854,9 @@ rte_event_port_attr_get(uint8_t dev_id, uint8_t port_id, uint32_t attr_id, default: return -EINVAL; }; + + rte_eventdev_trace_port_attr_get(dev_id, dev, port_id, attr_id, *attr_value); + return 0; } @@ -885,6 +913,9 @@ rte_event_queue_attr_get(uint8_t dev_id, uint8_t queue_id, uint32_t attr_id, default: return -EINVAL; }; + + rte_eventdev_trace_queue_attr_get(dev_id, dev, queue_id, attr_id, *attr_value); + return 0; } @@ -894,6 +925,8 @@ rte_event_queue_attr_set(uint8_t dev_id, uint8_t queue_id, uint32_t attr_id, { struct rte_eventdev *dev; + rte_eventdev_trace_queue_attr_set(dev_id, queue_id, attr_id, attr_value); + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); dev = &rte_eventdevs[dev_id]; if (!is_valid_queue(dev, queue_id)) { @@ -1048,6 +1081,8 @@ rte_event_port_unlinks_in_progress(uint8_t dev_id, uint8_t port_id) { struct rte_eventdev *dev; + rte_eventdev_trace_port_unlinks_in_progress(dev_id, port_id); + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); dev = &rte_eventdevs[dev_id]; if (!is_valid_port(dev, port_id)) { @@ -1091,6 +1126,9 @@ rte_event_port_links_get(uint8_t dev_id, uint8_t port_id, ++count; } } + + rte_eventdev_trace_port_links_get(dev_id, port_id, count); + return count; } @@ -1100,6 +1138,8 @@ rte_event_dequeue_timeout_ticks(uint8_t dev_id, uint64_t ns, { struct rte_eventdev *dev; + rte_eventdev_trace_dequeue_timeout_ticks(dev_id, ns, timeout_ticks); + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); dev = &rte_eventdevs[dev_id]; if (*dev->dev_ops->timeout_ticks == NULL) @@ -1125,6 +1165,8 @@ rte_event_dev_service_id_get(uint8_t dev_id, uint32_t *service_id) if (dev->data->service_inited) *service_id = dev->data->service_id; + rte_eventdev_trace_service_id_get(dev_id, *service_id); + return dev->data->service_inited ? 0 : -ESRCH; } @@ -1285,6 +1327,9 @@ rte_event_vector_pool_create(const char *name, unsigned int n, if (ret < 0) goto err; + rte_eventdev_trace_vector_pool_create(mp, mp->name, mp->socket_id, + mp->size, mp->cache_size, mp->elt_size); + return mp; err: rte_mempool_free(mp); @@ -1332,6 +1377,8 @@ rte_event_dev_stop_flush_callback_register(uint8_t dev_id, RTE_EDEV_LOG_DEBUG("Stop flush register dev_id=%" PRIu8, dev_id); + rte_eventdev_trace_stop_flush_callback_register(dev_id, callback, userdata); + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL); dev = &rte_eventdevs[dev_id];