From: Amit Prakash Shukla <amitprakashs@marvell.com>
To: Jerin Jacob <jerinjacobk@gmail.com>
Cc: Akhil Goyal <gakhil@marvell.com>,
Fan Zhang <roy.fan.zhang@intel.com>, Ray Kinsella <mdr@ashroe.eu>,
"dev@dpdk.org" <dev@dpdk.org>,
Jerin Jacob Kollanukkaran <jerinj@marvell.com>
Subject: RE: [EXT] Re: [PATCH] cryptodev: add trace points
Date: Wed, 28 Sep 2022 17:30:44 +0000 [thread overview]
Message-ID: <PH0PR18MB516711193C9C06A47B5D5E29C8549@PH0PR18MB5167.namprd18.prod.outlook.com> (raw)
In-Reply-To: <CALBAE1P+Ekj2Qi9MEDEbKjMRTDBw7EM=gbhVxP9=YZwzRUv5KA@mail.gmail.com>
Hi Jerin,
Thanks for the feedback. I will do the suggested changes in next version of the patch.
> -----Original Message-----
> From: Jerin Jacob <jerinjacobk@gmail.com>
> Sent: Wednesday, September 28, 2022 9:38 AM
> To: Amit Prakash Shukla <amitprakashs@marvell.com>
> Cc: Akhil Goyal <gakhil@marvell.com>; Fan Zhang
> <roy.fan.zhang@intel.com>; Ray Kinsella <mdr@ashroe.eu>; dev@dpdk.org;
> Jerin Jacob Kollanukkaran <jerinj@marvell.com>
> Subject: [EXT] Re: [PATCH] cryptodev: add trace points
>
> External Email
>
> ----------------------------------------------------------------------
> On Fri, Sep 16, 2022 at 11:05 PM Amit Prakash Shukla
> <amitprakashs@marvell.com> wrote:
> >
> > Add trace points for cryptodev functions.
> >
> > Signed-off-by: Amit Prakash Shukla <amitprakashs@marvell.com>
> > ---
>
> 1) Please include the result of API operation in trace so that once can know
> the API status
> 2) restrict trace additions to public API. i.e I think, no need to add trace for
> PMD hooks
> 3) Please test with
> https://urldefense.proofpoint.com/v2/url?u=https-
> 3A__patches.dpdk.org_project_dpdk_patch_20220804134430.6192-2D7-
> 2Dadwivedi-
> 40marvell.com_&d=DwIBaQ&c=nKjWec2b6R0mOyPaz7xtfQ&r=ALGdXl3fZgF
> GR69VnJLdSnADun7zLaXG1p5Rs7pXihE&m=La6KTYnho7a2OyakYv8EYufGmc9
> 4buR5F88gTXM3TE1wkbcHadzRTCGSpG6WnUoU&s=UwXGLOV1QKlABQz31v
> BV7KC6lRzayDRh1lftzCCG2jc&e=
> patch by adding cryptodev symbols
> to make sure not to missed any public cryptodev API.
>
>
> > @@ -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_driv
> er,
> > + 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_enu
> m,
> > + 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_sess
> ion_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_ses
> sion_size,
> > + lib.cryptodev.asym.get.private.session.size)
> > +
> >
> +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_get_xform_enu
> m,
> > + lib.cryptodev.asym.get.xform.enum)
> > +
> >
> +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_xform_capabilit
> y_check_modlen,
> > + lib.cryptodev.asym.xform.capability.check.modlen)
> > +
> >
> +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_cpu_crypto_proc
> ess,
> > + lib.cryptodev.sym.cpu.crypto.process)
> > +
> >
> +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_get_existing_hea
> der_session_size,
> > + lib.cryptodev.sym.get.existing.header.session.size)
> > +
> >
> +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_sym_session_get_use
> r_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_us
> er_data,
> > + lib.cryptodev.asym.session.get.user.data)
> > +
> >
> +RTE_TRACE_POINT_REGISTER(rte_cryptodev_trace_asym_session_set_us
> er_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_na
> me,
> > + 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_arg
> s,
> > + 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 <rte_trace_point.h>
> >
> > #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 {
> > --
> > 2.25.1
> >
next prev parent reply other threads:[~2022-09-28 17:33 UTC|newest]
Thread overview: 8+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-09-16 17:32 Amit Prakash Shukla
2022-09-27 8:06 ` Akhil Goyal
2022-09-27 13:48 ` Amit Prakash Shukla
2022-09-28 4:08 ` Jerin Jacob
2022-09-28 17:30 ` Amit Prakash Shukla [this message]
2022-09-29 12:35 ` [PATCH v2] " Amit Prakash Shukla
2022-09-30 7:34 ` Jerin Jacob
2022-09-30 18:22 ` [EXT] " Akhil Goyal
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=PH0PR18MB516711193C9C06A47B5D5E29C8549@PH0PR18MB5167.namprd18.prod.outlook.com \
--to=amitprakashs@marvell.com \
--cc=dev@dpdk.org \
--cc=gakhil@marvell.com \
--cc=jerinj@marvell.com \
--cc=jerinjacobk@gmail.com \
--cc=mdr@ashroe.eu \
--cc=roy.fan.zhang@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).