From patchwork Fri Sep 16 17:32:27 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Amit Prakash Shukla X-Patchwork-Id: 116402 X-Patchwork-Delegate: gakhil@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 B7704A0032; Fri, 16 Sep 2022 19:34:58 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 5AE5A4021D; Fri, 16 Sep 2022 19:34:58 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 5561840156 for ; Fri, 16 Sep 2022 19:34:57 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 28G68Pxm016620; Fri, 16 Sep 2022 10:32:48 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=CV2Un33YqT6sToujhZw0WAsC+JpG+dgq+6gOJrppLV4=; b=YARW/BaCsGozx41AWzdO6ygdIyKNde727eZhQQZC6kbpaHJI5jLRB4EvbhIqBqNOFLvr tEJapmtMaCx6ezNImSP5LaPV4M9gAmUbpOiMuCA7RjCbDHjSFEK6FWf9zMnAUj16e3M6 OvUhLPi/0v/LOvxgDYu1VTfg4hsse3B5T3yeNb6fpoVvuc5XtNnhg4GMDBCx5NHZ3cwS oC+2zTei15Vauz8IFoZNJO6gHGTFhnpje3MGqQTmYl06lLYrud9Vb9y9/6SCRAoqdDn6 00L/J3+IKwu9I9Pa7ZfcF7sHifIqEd/0NrV68BUETVzr00nrms2vxdfmyjGDySHwnpD6 Gg== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3jm8y74jba-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Fri, 16 Sep 2022 10:32:48 -0700 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 16 Sep 2022 10:32:45 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.18 via Frontend Transport; Fri, 16 Sep 2022 10:32:45 -0700 Received: from localhost.localdomain (unknown [10.28.36.157]) by maili.marvell.com (Postfix) with ESMTP id 940163F7044; Fri, 16 Sep 2022 10:32:43 -0700 (PDT) From: Amit Prakash Shukla To: Akhil Goyal , Fan Zhang , "Ray Kinsella" CC: , , Amit Prakash Shukla Subject: [PATCH] cryptodev: add trace points Date: Fri, 16 Sep 2022 23:02:27 +0530 Message-ID: <20220916173227.27758-1-amitprakashs@marvell.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: zsXNXp7gI4SGgwuVeuc6cQDvl8w0bB54 X-Proofpoint-GUID: zsXNXp7gI4SGgwuVeuc6cQDvl8w0bB54 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.895,Hydra:6.0.528,FMLib:17.11.122.1 definitions=2022-09-16_10,2022-09-16_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 cryptodev functions. Signed-off-by: Amit Prakash Shukla --- lib/cryptodev/cryptodev_pmd.c | 13 + lib/cryptodev/cryptodev_trace_points.c | 165 ++++++++++ lib/cryptodev/rte_cryptodev.c | 109 ++++++- lib/cryptodev/rte_cryptodev_trace.h | 423 +++++++++++++++++++++++++ lib/cryptodev/rte_cryptodev_trace_fp.h | 6 + lib/cryptodev/version.map | 57 ++++ 6 files changed, 772 insertions(+), 1 deletion(-) diff --git a/lib/cryptodev/cryptodev_pmd.c b/lib/cryptodev/cryptodev_pmd.c index 1903ade388..c8829dbebe 100644 --- a/lib/cryptodev/cryptodev_pmd.c +++ b/lib/cryptodev/cryptodev_pmd.c @@ -8,6 +8,7 @@ #include #include "cryptodev_pmd.h" +#include "rte_cryptodev_trace.h" /** * Parse name from argument @@ -84,6 +85,9 @@ rte_cryptodev_pmd_parse_input_args( } free_kvlist: + rte_cryptodev_trace_pmd_parse_input_args(params->name, + params->socket_id, params->max_nb_queue_pairs); + rte_kvargs_free(kvlist); return ret; } @@ -135,6 +139,8 @@ rte_cryptodev_pmd_create(const char *name, /* initialise user call-back tail queue */ TAILQ_INIT(&(cryptodev->link_intr_cbs)); + rte_cryptodev_trace_pmd_create(name, params->socket_id, cryptodev); + return cryptodev; } @@ -144,6 +150,8 @@ rte_cryptodev_pmd_destroy(struct rte_cryptodev *cryptodev) int retval; void *dev_priv = cryptodev->data->dev_private; + rte_cryptodev_trace_pmd_destroy(cryptodev); + CDEV_LOG_INFO("Closing crypto device %s", cryptodev->device->name); /* free crypto device */ @@ -166,6 +174,9 @@ rte_cryptodev_pmd_probing_finish(struct rte_cryptodev *cryptodev) { if (cryptodev == NULL) return; + + rte_cryptodev_trace_pmd_probing_finish(cryptodev); + /* * for secondary process, at that point we expect device * to be already 'usable', so shared data and all function @@ -231,6 +242,8 @@ cryptodev_fp_ops_set(struct rte_crypto_fp_ops *fp_ops, void * rte_cryptodev_session_event_mdata_get(struct rte_crypto_op *op) { + rte_cryptodev_trace_session_event_mdata_get(op->type); + if (op->type == RTE_CRYPTO_OP_TYPE_SYMMETRIC && op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) return rte_cryptodev_sym_session_get_user_data(op->sym->session); diff --git a/lib/cryptodev/cryptodev_trace_points.c b/lib/cryptodev/cryptodev_trace_points.c index c5bfe08b79..bca4deecc2 100644 --- a/lib/cryptodev/cryptodev_trace_points.c +++ b/lib/cryptodev/cryptodev_trace_points.c @@ -50,3 +50,168 @@ RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_enqueue_burst, RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_dequeue_burst, lib.cryptodev.deq.burst) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_callback_register, + lib.cryptodev.callback.register) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_callback_unregister, + lib.cryptodev.callback.unregister) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_device_count_by_driver, + lib.cryptodev.device.count.by.driver) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_devices_get, + lib.cryptodev.devices.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_driver_id_get, + lib.cryptodev.driver.id.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_driver_name_get, + lib.cryptodev.driver.name.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_aead_algo_enum, + lib.cryptodev.get.aead.algo.enum) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_auth_algo_enum, + lib.cryptodev.get.auth.algo.enum) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_cipher_algo_enum, + lib.cryptodev.get.cipher.algo.enum) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_dev_id, + lib.cryptodev.get.dev.id) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_feature_name, + lib.cryptodev.get.feature.name) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_sec_ctx, + lib.cryptodev.get.sec.ctx) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_info_get, + lib.cryptodev.info.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_is_valid_dev, + lib.cryptodev.is.valid.dev) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_name_get, + lib.cryptodev.name.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_queue_pair_count, + lib.cryptodev.queue.pair.count) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_socket_id, + lib.cryptodev.socket.id) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_stats_get, + lib.cryptodev.stats.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_stats_reset, + lib.cryptodev.stats.reset) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_capability_check_aead, + lib.cryptodev.sym.capability.check.aead) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_capability_check_auth, + lib.cryptodev.sym.capability.check.auth) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_capability_check_cipher, + lib.cryptodev.sym.capability.check.cipher) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_capability_get, + lib.cryptodev.sym.capability.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_get_private_session_size, + lib.cryptodev.sym.get.private.session.size) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_capability_get, + lib.cryptodev.asym.capability.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_get_private_session_size, + lib.cryptodev.asym.get.private.session.size) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_get_xform_enum, + lib.cryptodev.asym.get.xform.enum) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_xform_capability_check_modlen, + lib.cryptodev.asym.xform.capability.check.modlen) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_cpu_crypto_process, + lib.cryptodev.sym.cpu.crypto.process) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_get_existing_header_session_size, + lib.cryptodev.sym.get.existing.header.session.size) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_session_get_user_data, + lib.cryptodev.sym.session.get.user.data) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_session_set_user_data, + lib.cryptodev.sym.session.set.user.data) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_qp_status, + lib.cryptodev.get.qp.status) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_configure_raw_dp_ctx, + lib.cryptodev.configure.raw.dp.ctx) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_get_raw_dp_ctx_size, + lib.cryptodev.get.raw.dp.ctx.size) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_add_deq_callback, + lib.cryptodev.add.deq.callback) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_add_enq_callback, + lib.cryptodev.add.enq.callback) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_remove_deq_callback, + lib.cryptodev.remove.deq.callback) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_remove_enq_callback, + lib.cryptodev.remove.enq.callback) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_session_get_user_data, + lib.cryptodev.asym.session.get.user.data) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_session_set_user_data, + lib.cryptodev.asym.session.set.user.data) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_session_event_mdata_set, + lib.cryptodev.session.event.mdata.set) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_allocate_driver, + lib.cryptodev.allocate.driver) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_allocate, + lib.cryptodev.pmd.allocate) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_callback_process, + lib.cryptodev.pmd.callback.process) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_create, + lib.cryptodev.pmd.create) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_create_dev_name, + lib.cryptodev.pmd.create.dev.name) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_destroy, + lib.cryptodev.pmd.destroy) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_get_dev, + lib.cryptodev.pmd.get.dev) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_get_named_dev, + lib.cryptodev.pmd.get.named.dev) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_parse_input_args, + lib.cryptodev.pmd.parse.input.args) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_probing_finish, + lib.cryptodev.pmd.probing.finish) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_pmd_release_device, + lib.cryptodev.pmd.release.device) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_session_event_mdata_get, + lib.cryptodev.session.event.mdata.get) + +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_op_pool_create, + lib.cryptodev.op.pool.create) diff --git a/lib/cryptodev/rte_cryptodev.c b/lib/cryptodev/rte_cryptodev.c index 42f3221052..b712315674 100644 --- a/lib/cryptodev/rte_cryptodev.c +++ b/lib/cryptodev/rte_cryptodev.c @@ -216,6 +216,8 @@ rte_cryptodev_get_cipher_algo_enum(enum rte_crypto_cipher_algorithm *algo_enum, { unsigned int i; + rte_cryptodev_trace_get_cipher_algo_enum(algo_string); + for (i = 1; i < RTE_DIM(rte_crypto_cipher_algorithm_strings); i++) { if (strcmp(algo_string, rte_crypto_cipher_algorithm_strings[i]) == 0) { *algo_enum = (enum rte_crypto_cipher_algorithm) i; @@ -233,6 +235,8 @@ rte_cryptodev_get_auth_algo_enum(enum rte_crypto_auth_algorithm *algo_enum, { unsigned int i; + rte_cryptodev_trace_get_auth_algo_enum(algo_string); + for (i = 1; i < RTE_DIM(rte_crypto_auth_algorithm_strings); i++) { if (strcmp(algo_string, rte_crypto_auth_algorithm_strings[i]) == 0) { *algo_enum = (enum rte_crypto_auth_algorithm) i; @@ -250,6 +254,8 @@ rte_cryptodev_get_aead_algo_enum(enum rte_crypto_aead_algorithm *algo_enum, { unsigned int i; + rte_cryptodev_trace_get_aead_algo_enum(algo_string); + for (i = 1; i < RTE_DIM(rte_crypto_aead_algorithm_strings); i++) { if (strcmp(algo_string, rte_crypto_aead_algorithm_strings[i]) == 0) { *algo_enum = (enum rte_crypto_aead_algorithm) i; @@ -267,6 +273,8 @@ rte_cryptodev_asym_get_xform_enum(enum rte_crypto_asym_xform_type *xform_enum, { unsigned int i; + rte_cryptodev_trace_asym_get_xform_enum(xform_string); + for (i = 1; i < RTE_DIM(rte_crypto_asym_xform_strings); i++) { if (strcmp(xform_string, rte_crypto_asym_xform_strings[i]) == 0) { @@ -299,6 +307,9 @@ rte_cryptodev_sym_capability_get(uint8_t dev_id, rte_cryptodev_info_get(dev_id, &dev_info); + rte_cryptodev_trace_sym_capability_get(dev_id, dev_info.driver_name, + dev_info.driver_id, idx->type); + while ((capability = &dev_info.capabilities[i++])->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) { if (capability->op != RTE_CRYPTO_OP_TYPE_SYMMETRIC) @@ -359,6 +370,9 @@ rte_cryptodev_asym_capability_get(uint8_t dev_id, memset(&dev_info, 0, sizeof(struct rte_cryptodev_info)); rte_cryptodev_info_get(dev_id, &dev_info); + rte_cryptodev_trace_asym_capability_get(dev_info.driver_name, + dev_info.driver_id, idx->type); + while ((capability = &dev_info.capabilities[i++])->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) { if (capability->op != RTE_CRYPTO_OP_TYPE_ASYMMETRIC) @@ -375,6 +389,9 @@ rte_cryptodev_sym_capability_check_cipher( const struct rte_cryptodev_symmetric_capability *capability, uint16_t key_size, uint16_t iv_size) { + rte_cryptodev_trace_sym_capability_check_cipher(capability, key_size, + iv_size); + if (param_range_check(key_size, &capability->cipher.key_size) != 0) return -1; @@ -389,6 +406,9 @@ rte_cryptodev_sym_capability_check_auth( const struct rte_cryptodev_symmetric_capability *capability, uint16_t key_size, uint16_t digest_size, uint16_t iv_size) { + rte_cryptodev_trace_sym_capability_check_auth(capability, key_size, + digest_size, iv_size); + if (param_range_check(key_size, &capability->auth.key_size) != 0) return -1; @@ -407,6 +427,9 @@ rte_cryptodev_sym_capability_check_aead( uint16_t key_size, uint16_t digest_size, uint16_t aad_size, uint16_t iv_size) { + rte_cryptodev_trace_sym_capability_check_aead(capability, key_size, + digest_size, aad_size, iv_size); + if (param_range_check(key_size, &capability->aead.key_size) != 0) return -1; @@ -437,6 +460,9 @@ rte_cryptodev_asym_xform_capability_check_modlen( const struct rte_cryptodev_asymmetric_xform_capability *capability, uint16_t modlen) { + rte_cryptodev_trace_asym_xform_capability_check_modlen(capability, + modlen); + /* no need to check for limits, if min or max = 0 */ if (capability->modlen.min != 0) { if (modlen < capability->modlen.min) @@ -577,6 +603,8 @@ cryptodev_cb_init(struct rte_cryptodev *dev) const char * rte_cryptodev_get_feature_name(uint64_t flag) { + rte_cryptodev_trace_get_feature_name(flag); + switch (flag) { case RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO: return "SYMMETRIC_CRYPTO"; @@ -638,6 +666,8 @@ rte_cryptodev_get_feature_name(uint64_t flag) struct rte_cryptodev * rte_cryptodev_pmd_get_dev(uint8_t dev_id) { + rte_cryptodev_trace_pmd_get_dev(dev_id); + return &cryptodev_globals.devs[dev_id]; } @@ -650,6 +680,8 @@ rte_cryptodev_pmd_get_named_dev(const char *name) if (name == NULL) return NULL; + rte_cryptodev_trace_pmd_get_named_dev(name); + for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) { dev = &cryptodev_globals.devs[i]; @@ -676,6 +708,8 @@ rte_cryptodev_is_valid_dev(uint8_t dev_id) { struct rte_cryptodev *dev = NULL; + rte_cryptodev_trace_is_valid_dev(dev_id); + if (!rte_cryptodev_is_valid_device_data(dev_id)) return 0; @@ -695,6 +729,8 @@ rte_cryptodev_get_dev_id(const char *name) if (name == NULL) return -1; + rte_cryptodev_trace_get_dev_id(name); + for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) { if (!rte_cryptodev_is_valid_device_data(i)) continue; @@ -725,6 +761,8 @@ rte_cryptodev_device_count_by_driver(uint8_t driver_id) RTE_CRYPTODEV_ATTACHED) dev_count++; + rte_cryptodev_trace_device_count_by_driver(driver_id, dev_count); + return dev_count; } @@ -751,12 +789,16 @@ rte_cryptodev_devices_get(const char *driver_name, uint8_t *devices, } } + rte_cryptodev_trace_devices_get(driver_name, count); + return count; } void * rte_cryptodev_get_sec_ctx(uint8_t dev_id) { + rte_cryptodev_trace_get_sec_ctx(dev_id); + if (dev_id < RTE_CRYPTO_MAX_DEVS && (rte_crypto_devices[dev_id].feature_flags & RTE_CRYPTODEV_FF_SECURITY)) @@ -775,6 +817,8 @@ rte_cryptodev_socket_id(uint8_t dev_id) dev = rte_cryptodev_pmd_get_dev(dev_id); + rte_cryptodev_trace_socket_id(dev_id, dev->data->name, + dev->data->socket_id); return dev->data->socket_id; } @@ -913,6 +957,7 @@ rte_cryptodev_pmd_allocate(const char *name, int socket_id) cryptodev_globals.nb_devs++; } + rte_cryptodev_trace_pmd_allocate(cryptodev); return cryptodev; } @@ -925,6 +970,8 @@ rte_cryptodev_pmd_release_device(struct rte_cryptodev *cryptodev) if (cryptodev == NULL) return -EINVAL; + rte_cryptodev_trace_pmd_release_device(cryptodev); + dev_id = cryptodev->data->dev_id; cryptodev_fp_ops_reset(rte_crypto_fp_ops + dev_id); @@ -956,6 +1003,8 @@ rte_cryptodev_queue_pair_count(uint8_t dev_id) } dev = &rte_crypto_devices[dev_id]; + rte_cryptodev_trace_queue_pair_count(dev); + return dev->data->nb_queue_pairs; } @@ -1178,6 +1227,8 @@ rte_cryptodev_get_qp_status(uint8_t dev_id, uint16_t queue_pair_id) { struct rte_cryptodev *dev; + rte_cryptodev_trace_get_qp_status(dev_id, queue_pair_id); + if (!rte_cryptodev_is_valid_dev(dev_id)) { CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id); return -EINVAL; @@ -1331,6 +1382,7 @@ rte_cryptodev_add_enq_callback(uint8_t dev_id, rte_spinlock_unlock(&rte_cryptodev_callback_lock); + rte_cryptodev_trace_add_enq_callback(dev_id, qp_id, cb_fn); return cb; } @@ -1356,6 +1408,8 @@ rte_cryptodev_remove_enq_callback(uint8_t dev_id, return -ENODEV; } + rte_cryptodev_trace_remove_enq_callback(dev_id, qp_id, cb->fn); + dev = &rte_crypto_devices[dev_id]; if (qp_id >= dev->data->nb_queue_pairs) { CDEV_LOG_ERR("Invalid queue_pair_id=%d", qp_id); @@ -1466,6 +1520,8 @@ rte_cryptodev_add_deq_callback(uint8_t dev_id, rte_spinlock_unlock(&rte_cryptodev_callback_lock); + rte_cryptodev_trace_add_deq_callback(dev_id, qp_id, cb_fn); + return cb; } @@ -1491,6 +1547,8 @@ rte_cryptodev_remove_deq_callback(uint8_t dev_id, return -ENODEV; } + rte_cryptodev_trace_remove_deq_callback(dev_id, qp_id, cb->fn); + dev = &rte_crypto_devices[dev_id]; if (qp_id >= dev->data->nb_queue_pairs) { CDEV_LOG_ERR("Invalid queue_pair_id=%d", qp_id); @@ -1559,6 +1617,8 @@ rte_cryptodev_stats_get(uint8_t dev_id, struct rte_cryptodev_stats *stats) RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP); (*dev->dev_ops->stats_get)(dev, stats); + + rte_cryptodev_trace_stats_get(dev_id, stats); return 0; } @@ -1567,6 +1627,8 @@ rte_cryptodev_stats_reset(uint8_t dev_id) { struct rte_cryptodev *dev; + rte_cryptodev_trace_stats_reset(dev_id); + if (!rte_cryptodev_is_valid_dev(dev_id)) { CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id); return; @@ -1597,6 +1659,9 @@ rte_cryptodev_info_get(uint8_t dev_id, struct rte_cryptodev_info *dev_info) dev_info->driver_name = dev->device->driver->name; dev_info->device = dev->device; + + rte_cryptodev_trace_info_get(dev_id); + } int @@ -1639,6 +1704,8 @@ rte_cryptodev_callback_register(uint8_t dev_id, } rte_spinlock_unlock(&rte_cryptodev_cb_lock); + + rte_cryptodev_trace_callback_register(dev_id, event, cb_fn); return (user_cb == NULL) ? -ENOMEM : 0; } @@ -1685,6 +1752,8 @@ rte_cryptodev_callback_unregister(uint8_t dev_id, } rte_spinlock_unlock(&rte_cryptodev_cb_lock); + + rte_cryptodev_trace_callback_unregister(dev_id, event, cb_fn); return ret; } @@ -1695,6 +1764,7 @@ rte_cryptodev_pmd_callback_process(struct rte_cryptodev *dev, struct rte_cryptodev_callback *cb_lst; struct rte_cryptodev_callback dev_cb; + rte_cryptodev_trace_pmd_callback_process(dev, event); rte_spinlock_lock(&rte_cryptodev_cb_lock); TAILQ_FOREACH(cb_lst, &(dev->link_intr_cbs), next) { if (cb_lst->cb_fn == NULL || cb_lst->event != event) @@ -2117,6 +2187,9 @@ rte_cryptodev_sym_get_private_session_size(uint8_t dev_id) priv_sess_size = (*dev->dev_ops->sym_session_get_size)(dev); + rte_cryptodev_trace_sym_get_private_session_size(dev_id, + priv_sess_size); + return priv_sess_size; } @@ -2136,6 +2209,9 @@ rte_cryptodev_asym_get_private_session_size(uint8_t dev_id) priv_sess_size = (*dev->dev_ops->asym_session_get_size)(dev); + rte_cryptodev_trace_asym_get_private_session_size(dev_id, + priv_sess_size); + return priv_sess_size; } @@ -2152,6 +2228,9 @@ rte_cryptodev_sym_session_set_user_data( return -ENOMEM; rte_memcpy(sess->sess_data + sess->nb_drivers, data, size); + + rte_cryptodev_trace_sym_session_set_user_data(sess, data, size); + return 0; } @@ -2162,6 +2241,8 @@ rte_cryptodev_sym_session_get_user_data( if (sess == NULL || sess->user_data_sz == 0) return NULL; + rte_cryptodev_trace_sym_session_get_user_data(sess); + return (void *)(sess->sess_data + sess->nb_drivers); } @@ -2178,6 +2259,9 @@ rte_cryptodev_asym_session_set_user_data(void *session, void *data, uint16_t siz rte_memcpy(sess->sess_private_data + sess->max_priv_data_sz, data, size); + + rte_cryptodev_trace_asym_session_set_user_data(sess, data, size); + return 0; } @@ -2188,6 +2272,8 @@ rte_cryptodev_asym_session_get_user_data(void *session) if (sess == NULL || sess->user_data_sz == 0) return NULL; + rte_cryptodev_trace_asym_session_get_user_data(sess); + return (void *)(sess->sess_private_data + sess->max_priv_data_sz); } @@ -2207,6 +2293,8 @@ rte_cryptodev_sym_cpu_crypto_process(uint8_t dev_id, { struct rte_cryptodev *dev; + rte_cryptodev_trace_sym_cpu_crypto_process(dev_id, sess); + if (!rte_cryptodev_is_valid_dev(dev_id)) { sym_crypto_fill_status(vec, EINVAL); return 0; @@ -2230,6 +2318,8 @@ rte_cryptodev_get_raw_dp_ctx_size(uint8_t dev_id) int32_t size = sizeof(struct rte_crypto_raw_dp_ctx); int32_t priv_size; + rte_cryptodev_trace_get_raw_dp_ctx_size(dev_id); + if (!rte_cryptodev_is_valid_dev(dev_id)) return -EINVAL; @@ -2256,6 +2346,8 @@ rte_cryptodev_configure_raw_dp_ctx(uint8_t dev_id, uint16_t qp_id, { struct rte_cryptodev *dev; + rte_cryptodev_trace_configure_raw_dp_ctx(dev_id, qp_id, sess_type); + if (!rte_cryptodev_get_qp_status(dev_id, qp_id)) return -EINVAL; @@ -2280,6 +2372,9 @@ rte_cryptodev_session_event_mdata_set(uint8_t dev_id, void *sess, if (sess == NULL || ev_mdata == NULL) return -EINVAL; + rte_cryptodev_trace_session_event_mdata_set(dev_id, sess, op_type, + sess_type, ev_mdata, size); + if (!rte_cryptodev_is_valid_dev(dev_id)) goto skip_pmd_op; @@ -2429,6 +2524,7 @@ rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type, priv->priv_size = priv_size; priv->type = type; + rte_cryptodev_trace_op_pool_create(name, socket_id, type, nb_elts, mp); return mp; } @@ -2441,6 +2537,8 @@ rte_cryptodev_pmd_create_dev_name(char *name, const char *dev_name_prefix) if (name == NULL) return -EINVAL; + rte_cryptodev_trace_pmd_create_dev_name(dev_name_prefix); + for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) { int ret = snprintf(name, RTE_CRYPTODEV_NAME_MAX_LEN, "%s_%u", dev_name_prefix, i); @@ -2467,6 +2565,8 @@ rte_cryptodev_driver_id_get(const char *name) struct cryptodev_driver *driver; const char *driver_name; + rte_cryptodev_trace_driver_id_get(name); + if (name == NULL) { RTE_LOG(DEBUG, CRYPTODEV, "name pointer NULL"); return -1; @@ -2494,6 +2594,8 @@ rte_cryptodev_name_get(uint8_t dev_id) if (dev == NULL) return NULL; + rte_cryptodev_trace_name_get(dev_id, dev->data->name); + return dev->data->name; } @@ -2503,8 +2605,11 @@ rte_cryptodev_driver_name_get(uint8_t driver_id) struct cryptodev_driver *driver; TAILQ_FOREACH(driver, &cryptodev_driver_list, next) - if (driver->id == driver_id) + if (driver->id == driver_id) { + rte_cryptodev_trace_driver_name_get(driver_id, + driver->driver->name); return driver->driver->name; + } return NULL; } @@ -2517,6 +2622,8 @@ rte_cryptodev_allocate_driver(struct cryptodev_driver *crypto_drv, TAILQ_INSERT_TAIL(&cryptodev_driver_list, crypto_drv, next); + rte_cryptodev_trace_allocate_driver(drv->name); + return nb_drivers++; } diff --git a/lib/cryptodev/rte_cryptodev_trace.h b/lib/cryptodev/rte_cryptodev_trace.h index a3f6048e7d..84991c5b0a 100644 --- a/lib/cryptodev/rte_cryptodev_trace.h +++ b/lib/cryptodev/rte_cryptodev_trace.h @@ -18,6 +18,7 @@ extern "C" { #include #include "rte_cryptodev.h" +#include "cryptodev_pmd.h" RTE_TRACE_POINT( rte_cryptodev_trace_configure, @@ -138,6 +139,428 @@ RTE_TRACE_POINT( rte_trace_point_emit_ptr(sess); ) +RTE_TRACE_POINT( + rte_cryptodev_trace_callback_register, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, + enum rte_cryptodev_event_type event, const void *cb_fn), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_int(event); + rte_trace_point_emit_ptr(cb_fn); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_callback_unregister, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, + enum rte_cryptodev_event_type event, const void *cb_fn), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_int(event); + rte_trace_point_emit_ptr(cb_fn); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_device_count_by_driver, + RTE_TRACE_POINT_ARGS(uint8_t driver_id, uint8_t dev_count), + rte_trace_point_emit_u8(driver_id); + rte_trace_point_emit_u8(dev_count); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_devices_get, + RTE_TRACE_POINT_ARGS(const char *driver_name, uint8_t count), + rte_trace_point_emit_string(driver_name); + rte_trace_point_emit_u8(count); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_driver_id_get, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_driver_name_get, + RTE_TRACE_POINT_ARGS(uint8_t driver_id, const char *name), + rte_trace_point_emit_u8(driver_id); + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_aead_algo_enum, + RTE_TRACE_POINT_ARGS(const char *algo_string), + rte_trace_point_emit_string(algo_string); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_auth_algo_enum, + RTE_TRACE_POINT_ARGS(const char *algo_string), + rte_trace_point_emit_string(algo_string); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_cipher_algo_enum, + RTE_TRACE_POINT_ARGS(const char *algo_string), + rte_trace_point_emit_string(algo_string); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_dev_id, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_feature_name, + RTE_TRACE_POINT_ARGS(uint64_t flag), + rte_trace_point_emit_u64(flag); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_sec_ctx, + RTE_TRACE_POINT_ARGS(uint8_t dev_id), + rte_trace_point_emit_u8(dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_info_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id), + rte_trace_point_emit_u8(dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_is_valid_dev, + RTE_TRACE_POINT_ARGS(uint8_t dev_id), + rte_trace_point_emit_u8(dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_name_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const char *name), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_queue_pair_count, + RTE_TRACE_POINT_ARGS(const struct rte_cryptodev *dev), + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_string(dev->data->name); + rte_trace_point_emit_u8(dev->data->socket_id); + rte_trace_point_emit_u8(dev->data->dev_id); + rte_trace_point_emit_u16(dev->data->nb_queue_pairs); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_socket_id, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const char *name, int socket_id), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_string(name); + rte_trace_point_emit_int(socket_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_stats_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, + const struct rte_cryptodev_stats *stats), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u64(stats->enqueued_count); + rte_trace_point_emit_u64(stats->dequeued_count); + rte_trace_point_emit_u64(stats->enqueue_err_count); + rte_trace_point_emit_u64(stats->dequeue_err_count); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_stats_reset, + RTE_TRACE_POINT_ARGS(uint8_t dev_id), + rte_trace_point_emit_u8(dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_capability_check_aead, + RTE_TRACE_POINT_ARGS( + const struct rte_cryptodev_symmetric_capability *capability, + uint16_t key_size, uint16_t digest_size, uint16_t aad_size, + uint16_t iv_size), + rte_trace_point_emit_ptr(capability); + rte_trace_point_emit_int(capability->xform_type); + rte_trace_point_emit_u16(key_size); + rte_trace_point_emit_u16(digest_size); + rte_trace_point_emit_u16(aad_size); + rte_trace_point_emit_u16(iv_size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_capability_check_auth, + RTE_TRACE_POINT_ARGS( + const struct rte_cryptodev_symmetric_capability *capability, + uint16_t key_size, uint16_t digest_size, uint16_t iv_size), + rte_trace_point_emit_ptr(capability); + rte_trace_point_emit_int(capability->xform_type); + rte_trace_point_emit_u16(key_size); + rte_trace_point_emit_u16(digest_size); + rte_trace_point_emit_u16(iv_size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_capability_check_cipher, + RTE_TRACE_POINT_ARGS( + const struct rte_cryptodev_symmetric_capability *capability, + uint16_t key_size, uint16_t iv_size), + rte_trace_point_emit_ptr(capability); + rte_trace_point_emit_int(capability->xform_type); + rte_trace_point_emit_u16(key_size); + rte_trace_point_emit_u16(iv_size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_capability_get, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const char *driver_name, + uint8_t driver_id, int idx_type), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_string(driver_name); + rte_trace_point_emit_u8(driver_id); + rte_trace_point_emit_int(idx_type); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_get_private_session_size, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint32_t priv_sess_size), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u32(priv_sess_size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_asym_capability_get, + RTE_TRACE_POINT_ARGS(const char *driver_name, uint8_t driver_id, + int idx_type), + rte_trace_point_emit_string(driver_name); + rte_trace_point_emit_u8(driver_id); + rte_trace_point_emit_int(idx_type); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_asym_get_private_session_size, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint32_t priv_sess_size), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u32(priv_sess_size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_asym_get_xform_enum, + RTE_TRACE_POINT_ARGS(const char *xform_string), + rte_trace_point_emit_string(xform_string); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_asym_xform_capability_check_modlen, + RTE_TRACE_POINT_ARGS(const void *capability, uint16_t modlen), + rte_trace_point_emit_ptr(capability); + rte_trace_point_emit_u16(modlen); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_cpu_crypto_process, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *sess), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(sess); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_get_existing_header_session_size, + RTE_TRACE_POINT_ARGS(struct rte_cryptodev_sym_session *sess), + rte_trace_point_emit_ptr(sess); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_session_get_user_data, + RTE_TRACE_POINT_ARGS(const void *sess), + rte_trace_point_emit_ptr(sess); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_sym_session_set_user_data, + RTE_TRACE_POINT_ARGS(const void *sess, const void *data, uint16_t size), + rte_trace_point_emit_ptr(sess); + rte_trace_point_emit_ptr(data); + rte_trace_point_emit_u16(size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_qp_status, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t queue_pair_id), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(queue_pair_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_configure_raw_dp_ctx, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t qp_id, int sess_type), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(qp_id); + rte_trace_point_emit_int(sess_type); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_get_raw_dp_ctx_size, + RTE_TRACE_POINT_ARGS(uint8_t dev_id), + rte_trace_point_emit_u8(dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_add_deq_callback, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t qp_id, const void *cb_fn), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(qp_id); + rte_trace_point_emit_ptr(cb_fn); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_add_enq_callback, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t qp_id, const void *cb_fn), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(qp_id); + rte_trace_point_emit_ptr(cb_fn); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_remove_deq_callback, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t qp_id, const void *fn), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(qp_id); + rte_trace_point_emit_ptr(fn); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_remove_enq_callback, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint16_t qp_id, const void *fn), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u16(qp_id); + rte_trace_point_emit_ptr(fn); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_asym_session_get_user_data, + RTE_TRACE_POINT_ARGS(const void *sess), + rte_trace_point_emit_ptr(sess); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_asym_session_set_user_data, + RTE_TRACE_POINT_ARGS(const void *sess, const void *data, uint16_t size), + rte_trace_point_emit_ptr(sess); + rte_trace_point_emit_ptr(data); + rte_trace_point_emit_u16(size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_session_event_mdata_set, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *sess, int op_type, + int sess_type, const void *ev_mdata, uint16_t size), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_ptr(sess); + rte_trace_point_emit_int(op_type); + rte_trace_point_emit_int(sess_type); + rte_trace_point_emit_ptr(ev_mdata); + rte_trace_point_emit_u16(size); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_allocate_driver, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_allocate, + RTE_TRACE_POINT_ARGS(const struct rte_cryptodev *cryptodev), + rte_trace_point_emit_ptr(cryptodev); + rte_trace_point_emit_string(cryptodev->data->name); + rte_trace_point_emit_u8(cryptodev->data->socket_id); + rte_trace_point_emit_u8(cryptodev->data->dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_callback_process, + RTE_TRACE_POINT_ARGS(struct rte_cryptodev *dev, + enum rte_cryptodev_event_type event), + rte_trace_point_emit_ptr(dev); + rte_trace_point_emit_string(dev->data->name); + rte_trace_point_emit_u8(dev->data->socket_id); + rte_trace_point_emit_u8(dev->data->dev_id); + rte_trace_point_emit_int(event); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_create, + RTE_TRACE_POINT_ARGS(const char *name, int socket_id, + const void *cryptodev), + rte_trace_point_emit_string(name); + rte_trace_point_emit_int(socket_id); + rte_trace_point_emit_ptr(cryptodev); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_create_dev_name, + RTE_TRACE_POINT_ARGS(const char *dev_name_prefix), + rte_trace_point_emit_string(dev_name_prefix); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_destroy, + RTE_TRACE_POINT_ARGS(const struct rte_cryptodev *cryptodev), + rte_trace_point_emit_ptr(cryptodev); + rte_trace_point_emit_string(cryptodev->data->name); + rte_trace_point_emit_u8(cryptodev->data->socket_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_get_dev, + RTE_TRACE_POINT_ARGS(uint8_t dev_id), + rte_trace_point_emit_u8(dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_get_named_dev, + RTE_TRACE_POINT_ARGS(const char *name), + rte_trace_point_emit_string(name); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_parse_input_args, + RTE_TRACE_POINT_ARGS(char *name, int socket_id, + uint32_t max_nb_queue_pairs), + rte_trace_point_emit_string(name); + rte_trace_point_emit_int(socket_id); + rte_trace_point_emit_u32(max_nb_queue_pairs); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_probing_finish, + RTE_TRACE_POINT_ARGS(const struct rte_cryptodev *cryptodev), + rte_trace_point_emit_ptr(cryptodev); + rte_trace_point_emit_string(cryptodev->data->name); + rte_trace_point_emit_u8(cryptodev->data->socket_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_pmd_release_device, + RTE_TRACE_POINT_ARGS(const struct rte_cryptodev *cryptodev), + rte_trace_point_emit_ptr(cryptodev); + rte_trace_point_emit_string(cryptodev->data->name); + rte_trace_point_emit_u8(cryptodev->data->socket_id); + rte_trace_point_emit_u8(cryptodev->data->dev_id); +) + +RTE_TRACE_POINT( + rte_cryptodev_trace_op_pool_create, + RTE_TRACE_POINT_ARGS(const char *name, int socket_id, int type, + uint32_t nb_elts, const void *mp), + rte_trace_point_emit_string(name); + rte_trace_point_emit_int(socket_id); + rte_trace_point_emit_int(type); + rte_trace_point_emit_u32(nb_elts); + rte_trace_point_emit_ptr(mp); +) + #ifdef __cplusplus } #endif diff --git a/lib/cryptodev/rte_cryptodev_trace_fp.h b/lib/cryptodev/rte_cryptodev_trace_fp.h index 9218997c14..03f4503d34 100644 --- a/lib/cryptodev/rte_cryptodev_trace_fp.h +++ b/lib/cryptodev/rte_cryptodev_trace_fp.h @@ -31,6 +31,12 @@ RTE_TRACE_POINT_FP( rte_trace_point_emit_u16(nb_ops); ) +RTE_TRACE_POINT_FP( + rte_cryptodev_trace_session_event_mdata_get, + RTE_TRACE_POINT_ARGS(uint8_t type), + rte_trace_point_emit_u8(type); +) + #ifdef __cplusplus } #endif diff --git a/lib/cryptodev/version.map b/lib/cryptodev/version.map index 5aee87c6f7..a788185229 100644 --- a/lib/cryptodev/version.map +++ b/lib/cryptodev/version.map @@ -109,6 +109,63 @@ EXPERIMENTAL { #added in 22.07 rte_cryptodev_session_event_mdata_set; rte_crypto_asym_ke_strings; + + #added in 22.11 + __rte_cryptodev_trace_add_deq_callback; + __rte_cryptodev_trace_add_enq_callback; + __rte_cryptodev_trace_allocate_driver; + __rte_cryptodev_trace_asym_capability_get; + __rte_cryptodev_trace_asym_get_private_session_size; + __rte_cryptodev_trace_asym_get_xform_enum; + __rte_cryptodev_trace_asym_session_get_user_data; + __rte_cryptodev_trace_asym_session_set_user_data; + __rte_cryptodev_trace_asym_xform_capability_check_modlen; + __rte_cryptodev_trace_callback_register; + __rte_cryptodev_trace_callback_unregister; + __rte_cryptodev_trace_configure_raw_dp_ctx; + __rte_cryptodev_trace_device_count_by_driver; + __rte_cryptodev_trace_devices_get; + __rte_cryptodev_trace_driver_id_get; + __rte_cryptodev_trace_driver_name_get; + __rte_cryptodev_trace_get_aead_algo_enum; + __rte_cryptodev_trace_get_auth_algo_enum; + __rte_cryptodev_trace_get_cipher_algo_enum; + __rte_cryptodev_trace_get_dev_id; + __rte_cryptodev_trace_get_feature_name; + __rte_cryptodev_trace_get_qp_status; + __rte_cryptodev_trace_get_raw_dp_ctx_size; + __rte_cryptodev_trace_get_sec_ctx; + __rte_cryptodev_trace_info_get; + __rte_cryptodev_trace_is_valid_dev; + __rte_cryptodev_trace_name_get; + __rte_cryptodev_trace_op_pool_create; + __rte_cryptodev_trace_pmd_allocate; + __rte_cryptodev_trace_pmd_callback_process; + __rte_cryptodev_trace_pmd_create; + __rte_cryptodev_trace_pmd_create_dev_name; + __rte_cryptodev_trace_pmd_destroy; + __rte_cryptodev_trace_pmd_get_dev; + __rte_cryptodev_trace_pmd_get_named_dev; + __rte_cryptodev_trace_pmd_parse_input_args; + __rte_cryptodev_trace_pmd_probing_finish; + __rte_cryptodev_trace_pmd_release_device; + __rte_cryptodev_trace_queue_pair_count; + __rte_cryptodev_trace_remove_deq_callback; + __rte_cryptodev_trace_remove_enq_callback; + __rte_cryptodev_trace_session_event_mdata_get; + __rte_cryptodev_trace_session_event_mdata_set; + __rte_cryptodev_trace_socket_id; + __rte_cryptodev_trace_stats_get; + __rte_cryptodev_trace_stats_reset; + __rte_cryptodev_trace_sym_capability_check_aead; + __rte_cryptodev_trace_sym_capability_check_auth; + __rte_cryptodev_trace_sym_capability_check_cipher; + __rte_cryptodev_trace_sym_capability_get; + __rte_cryptodev_trace_sym_cpu_crypto_process; + __rte_cryptodev_trace_sym_get_existing_header_session_size; + __rte_cryptodev_trace_sym_get_private_session_size; + __rte_cryptodev_trace_sym_session_get_user_data; + __rte_cryptodev_trace_sym_session_set_user_data; }; INTERNAL {