[v9,3/6] ethdev: add trace points for ethdev (part two)

Message ID 20230207063254.401538-4-adwivedi@marvell.com (mailing list archive)
State Superseded, archived
Delegated to: Ferruh Yigit
Headers
Series add trace points in ethdev library |

Checks

Context Check Description
ci/checkpatch success coding style OK

Commit Message

Ankur Dwivedi Feb. 7, 2023, 6:32 a.m. UTC
  Adds trace points for remaining ethdev functions.

Signed-off-by: Ankur Dwivedi <adwivedi@marvell.com>
Acked-by: Sunil Kumar Kori <skori@marvell.com>
---
 lib/ethdev/ethdev_trace.h        | 893 +++++++++++++++++++++++++++++++
 lib/ethdev/ethdev_trace_points.c | 252 +++++++++
 lib/ethdev/rte_ethdev.c          | 486 ++++++++++++++---
 lib/ethdev/rte_ethdev_cman.c     |  29 +-
 4 files changed, 1581 insertions(+), 79 deletions(-)
  

Comments

Ferruh Yigit Feb. 8, 2023, 1:20 a.m. UTC | #1
On 2/7/2023 6:32 AM, Ankur Dwivedi wrote:
> Subject:
> [PATCH v9 3/6] ethdev: add trace points for ethdev (part two)
> From:
> Ankur Dwivedi <adwivedi@marvell.com>
> Date:
> 2/7/2023, 6:32 AM
> 
> To:
> <dev@dpdk.org>
> CC:
> 
> 
> Adds trace points for remaining ethdev functions.
> 
> Signed-off-by: Ankur Dwivedi <adwivedi@marvell.com>
> Acked-by: Sunil Kumar Kori <skori@marvell.com>

<...>

> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_priority_flow_ctrl_queue_configure,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_pfc_queue_conf *pfc_queue_conf, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(pfc_queue_conf);
> +	rte_trace_point_emit_int(pfc_queue_conf->mode);
> +	rte_trace_point_emit_u16(pfc_queue_conf->rx_pause.tx_qid);
> +	rte_trace_point_emit_u16(pfc_queue_conf->tx_pause.rx_qid);
> +	rte_trace_point_emit_int(ret);
> +)
> +

Recording a pointer value of a struct may not be so useful but at least
it helps to identify different instances used by calls, and this is done
by multiple trace, that is OK.

But for this case some values of the struct is already recorded, so is
there a need to record pointer value of struct too?
Like in 'rte_ethdev_trace_rss_hash_update()', 'rss_conf' pointer value
is not recorded but some of its fields are, or
'rte_eth_trace_rx_queue_info_get()', I think this makes sense.


What do you think as general rule, if some fields of struct is recorded,
don't record its pointer value, else at least record structs pointer value?

This applies a few trace points, I have commented some of them but I may
missed some, can you please check all?

<...>

> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_callback_register,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_eth_event_type event,
> +		rte_eth_dev_cb_fn cb_fn, const void *cb_arg, uint16_t next_port,
> +		uint16_t last_port),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_int(event);
> +	rte_trace_point_emit_ptr(cb_fn);
> +	rte_trace_point_emit_ptr(cb_arg);
> +	rte_trace_point_emit_u16(next_port);
> +	rte_trace_point_emit_u16(last_port);
> +)

'next_port' and 'last_port' are internal variables, and 'next_port' is
increased in while loop, so its final value is always "last_port + 1" if
"port_id == RTE_ETH_ALL".
And if "port_id != RTE_ETH_ALL", next_port = last_port = port_id

'next_port' and 'last_port' derived from 'port_id', hence as 'port_id'
is already recorded, I think 'next_port' and 'last_port' can be dropped.

<...>

> +RTE_TRACE_POINT(
> +	rte_eth_trace_get_monitor_addr,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
> +		const struct rte_power_monitor_cond *pmc, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_u16(queue_id);
> +	rte_trace_point_emit_ptr(pmc);
> +	rte_trace_point_emit_ptr(pmc->addr);
> +	rte_trace_point_emit_u8(pmc->size);
> +	rte_trace_point_emit_int(ret);
> +)
> +

Another sample of what mentioned above, if 'pmc' fields are recorded,
can we drop recording 'pmc' pointer value?

> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_set_mc_addr_list,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_ether_addr *mc_addr_set, uint32_t nb_mc_addr,
> +		int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(mc_addr_set);

What about recording this as blob?
But 'mc_addr_set' is array of addresses, so length needs to be
'RTE_ETHER_ADDR_LEN * nb_mc_addr'.

<...>

> +RTE_TRACE_POINT(
> +	rte_eth_trace_timesync_write_time,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *time,
> +		int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(time);
> +	rte_trace_point_emit_size_t(time->tv_sec);
> +	rte_trace_point_emit_long(time->tv_nsec);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'time'

> +RTE_TRACE_POINT(
> +	rte_eth_trace_read_clock,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *clk, int ret),
> +	uint64_t clk_v = *clk;
> +
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(clk);
> +	rte_trace_point_emit_u64(clk_v);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'clk'

> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_get_reg_info,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_dev_reg_info *info, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(info);
> +	rte_trace_point_emit_ptr(info->data);
> +	rte_trace_point_emit_u32(info->offset);
> +	rte_trace_point_emit_u32(info->length);
> +	rte_trace_point_emit_u32(info->width);
> +	rte_trace_point_emit_u32(info->version);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'info'

> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_get_eeprom_length,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_int(ret);
> +)
> +
> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_get_eeprom,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_dev_eeprom_info *info, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(info);
> +	rte_trace_point_emit_ptr(info->data);
> +	rte_trace_point_emit_u32(info->offset);
> +	rte_trace_point_emit_u32(info->length);
> +	rte_trace_point_emit_u32(info->magic);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'info'

> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_set_eeprom,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_dev_eeprom_info *info, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(info->data);
> +	rte_trace_point_emit_u32(info->offset);
> +	rte_trace_point_emit_u32(info->length);
> +	rte_trace_point_emit_u32(info->magic);
> +	rte_trace_point_emit_int(ret);
> +)
> +
> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_get_module_info,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_dev_module_info *modinfo, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(modinfo);
> +	rte_trace_point_emit_u32(modinfo->type);
> +	rte_trace_point_emit_u32(modinfo->eeprom_len);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'modinfo'

> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_get_module_eeprom,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_dev_eeprom_info *info, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(info);
> +	rte_trace_point_emit_int(ret);
> +)
> +
> +RTE_TRACE_POINT(
> +	rte_ethdev_trace_get_dcb_info,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_dcb_info *dcb_info, int ret),
> +	uint8_t num_user_priorities = RTE_ETH_DCB_NUM_USER_PRIORITIES;
> +	uint8_t num_tcs = RTE_ETH_DCB_NUM_TCS;
> +
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(dcb_info);
> +	rte_trace_point_emit_u8(dcb_info->nb_tcs);
> +	rte_trace_point_emit_blob(dcb_info->prio_tc, num_user_priorities);
> +	rte_trace_point_emit_blob(dcb_info->tc_bws, num_tcs);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'dcb_info'

<...>

> +RTE_TRACE_POINT(
> +	rte_eth_trace_rx_metadata_negotiate,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *features,
> +		uint64_t features_val, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(features);
> +	rte_trace_point_emit_u64(features_val);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'features'

<...>

> +RTE_TRACE_POINT(
> +	rte_eth_trace_ip_reassembly_conf_get,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_ip_reassembly_params *conf, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(conf);
> +	rte_trace_point_emit_int(ret);
> +)
> +
> +RTE_TRACE_POINT(
> +	rte_eth_trace_ip_reassembly_conf_set,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_ip_reassembly_params *conf, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(conf);
> +	rte_trace_point_emit_u32(conf->timeout_ms);
> +	rte_trace_point_emit_u16(conf->max_frags);
> +	rte_trace_point_emit_u16(conf->flags);
> +	rte_trace_point_emit_int(ret);
> +)
> +

Can you please align recorded fields for conf_get and conf_set?

<...>

> +RTE_TRACE_POINT(
> +	rte_eth_trace_cman_info_get,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_cman_info *info, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(info);
> +	rte_trace_point_emit_u64(info->modes_supported);
> +	rte_trace_point_emit_u64(info->objs_supported);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'info'

> +RTE_TRACE_POINT(
> +	rte_eth_trace_cman_config_init,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_cman_config *config, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(config);
> +	rte_trace_point_emit_int(config->obj);
> +	rte_trace_point_emit_int(config->mode);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'config'

> +RTE_TRACE_POINT(
> +	rte_eth_trace_cman_config_set,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_cman_config *config, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(config);
> +	rte_trace_point_emit_int(config->obj);
> +	rte_trace_point_emit_int(config->mode);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'config'

> +RTE_TRACE_POINT(
> +	rte_eth_trace_cman_config_get,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
> +		const struct rte_eth_cman_config *config, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(config);
> +	rte_trace_point_emit_int(config->obj);
> +	rte_trace_point_emit_int(config->mode);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'config'

<...>

> +/* Called in loop in examples/ptpclient */
> +RTE_TRACE_POINT_FP(
> +	rte_eth_trace_timesync_read_rx_timestamp,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *timestamp,
> +		uint32_t flags, int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(timestamp);
> +	rte_trace_point_emit_size_t(timestamp->tv_sec);
> +	rte_trace_point_emit_long(timestamp->tv_nsec);
> +	rte_trace_point_emit_u32(flags);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'timestamp'

> +/* Called in loop in examples/ptpclient */
> +RTE_TRACE_POINT_FP(
> +	rte_eth_trace_timesync_read_tx_timestamp,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *timestamp,
> +		int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(timestamp);
> +	rte_trace_point_emit_size_t(timestamp->tv_sec);
> +	rte_trace_point_emit_long(timestamp->tv_nsec);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'timestamp'

> +/* Called in loop in examples/ptpclient */
> +RTE_TRACE_POINT_FP(
> +	rte_eth_trace_timesync_read_time,
> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *time,
> +		int ret),
> +	rte_trace_point_emit_u16(port_id);
> +	rte_trace_point_emit_ptr(time);
> +	rte_trace_point_emit_size_t(time->tv_sec);
> +	rte_trace_point_emit_long(time->tv_nsec);
> +	rte_trace_point_emit_int(ret);
> +)
> +

ditto for 'time'

<...>

> @@ -4141,6 +4196,7 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id,
>  				   struct rte_eth_pfc_conf *pfc_conf)
>  {
>  	struct rte_eth_dev *dev;
> +	int ret;
>  
>  	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
>  	dev = &rte_eth_devices[port_id];
> @@ -4158,9 +4214,15 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id,
>  	}
>  
>  	/* High water, low water validation are device specific */
> -	if  (*dev->dev_ops->priority_flow_ctrl_set)
> -		return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set)
> -					(dev, pfc_conf));
> +	if  (*dev->dev_ops->priority_flow_ctrl_set) {
> +		ret = eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set)
> +				       (dev, pfc_conf));
> +
> +		rte_ethdev_trace_priority_flow_ctrl_set(port_id, pfc_conf, ret);
> +
> +		return ret;
> +	}
> +
>  	return -ENOTSUP;
>  }
>  
> @@ -4219,6 +4281,7 @@ rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id,
>  		struct rte_eth_pfc_queue_info *pfc_queue_info)
>  {
>  	struct rte_eth_dev *dev;
> +	int ret;
>  
>  	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
>  	dev = &rte_eth_devices[port_id];
> @@ -4229,9 +4292,15 @@ rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id,
>  		return -EINVAL;
>  	}
>  
> -	if (*dev->dev_ops->priority_flow_ctrl_queue_info_get)
> -		return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_queue_info_get)
> +	if (*dev->dev_ops->priority_flow_ctrl_queue_info_get) {
> +		ret = eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_queue_info_get)
>  			(dev, pfc_queue_info));
> +
> +		rte_ethdev_trace_priority_flow_ctrl_queue_info_get(port_id,
> +							pfc_queue_info, ret);
> +
> +		return ret;
> +	}
>  	return -ENOTSUP;
>  }
>  
> @@ -4300,10 +4369,17 @@ rte_eth_dev_priority_flow_ctrl_queue_configure(uint16_t port_id,
>  			return ret;
>  	}
>  
> -	if (*dev->dev_ops->priority_flow_ctrl_queue_config)
> -		return eth_err(port_id,
> -			       (*dev->dev_ops->priority_flow_ctrl_queue_config)(
> -				dev, pfc_queue_conf));
> +	if (*dev->dev_ops->priority_flow_ctrl_queue_config) {
> +		ret = eth_err(port_id,
> +			      (*dev->dev_ops->priority_flow_ctrl_queue_config)(
> +			       dev, pfc_queue_conf));
> +
> +		rte_ethdev_trace_priority_flow_ctrl_queue_configure(port_id,
> +							pfc_queue_conf, ret);
> +
> +		return ret;
> +	}
> +


Not really related with this patch, but dev_ops check logic is reverse
(unconventional) in these functions.

Most of the time what we have is:
```
if (*dev->dev_ops->xxx == NULL)
	return -ENOTSUP;

rest_of_the_function;
```

But after change these functions become:
```
if (*dev->dev_ops->xxx) {
	do_whatever_action_needs;
	...

	return ret;
}

return -ENOTSUP;
```


Since it is updating these lines, can you please fix this check too?

This seems valid for:
rte_eth_dev_priority_flow_ctrl_set
rte_eth_dev_priority_flow_ctrl_queue_info_get
rte_eth_dev_priority_flow_ctrl_queue_configure
  
Ankur Dwivedi Feb. 8, 2023, 10:42 a.m. UTC | #2
>Subject: [EXT] Re: [PATCH v9 3/6] ethdev: add trace points for ethdev (part
>two)
>
>External Email
>
>----------------------------------------------------------------------
>On 2/7/2023 6:32 AM, Ankur Dwivedi wrote:
>> Subject:
>> [PATCH v9 3/6] ethdev: add trace points for ethdev (part two)
>> From:
>> Ankur Dwivedi <adwivedi@marvell.com>
>> Date:
>> 2/7/2023, 6:32 AM
>>
>> To:
>> <dev@dpdk.org>
>> CC:
>>
>>
>> Adds trace points for remaining ethdev functions.
>>
>> Signed-off-by: Ankur Dwivedi <adwivedi@marvell.com>
>> Acked-by: Sunil Kumar Kori <skori@marvell.com>
>
><...>
>
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_priority_flow_ctrl_queue_configure,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_pfc_queue_conf *pfc_queue_conf, int
>ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(pfc_queue_conf);
>> +	rte_trace_point_emit_int(pfc_queue_conf->mode);
>> +	rte_trace_point_emit_u16(pfc_queue_conf->rx_pause.tx_qid);
>> +	rte_trace_point_emit_u16(pfc_queue_conf->tx_pause.rx_qid);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>Recording a pointer value of a struct may not be so useful but at least it helps
>to identify different instances used by calls, and this is done by multiple trace,
>that is OK.
>
>But for this case some values of the struct is already recorded, so is there a
>need to record pointer value of struct too?
>Like in 'rte_ethdev_trace_rss_hash_update()', 'rss_conf' pointer value is not
>recorded but some of its fields are, or 'rte_eth_trace_rx_queue_info_get()', I
>think this makes sense.
>
>
>What do you think as general rule, if some fields of struct is recorded, don't
>record its pointer value, else at least record structs pointer value?

Ok.
>
>This applies a few trace points, I have commented some of them but I may
>missed some, can you please check all?
>
><...>
>
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_callback_register,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_eth_event_type
>event,
>> +		rte_eth_dev_cb_fn cb_fn, const void *cb_arg, uint16_t
>next_port,
>> +		uint16_t last_port),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_int(event);
>> +	rte_trace_point_emit_ptr(cb_fn);
>> +	rte_trace_point_emit_ptr(cb_arg);
>> +	rte_trace_point_emit_u16(next_port);
>> +	rte_trace_point_emit_u16(last_port);
>> +)
>
>'next_port' and 'last_port' are internal variables, and 'next_port' is increased
>in while loop, so its final value is always "last_port + 1" if "port_id ==
>RTE_ETH_ALL".
>And if "port_id != RTE_ETH_ALL", next_port = last_port = port_id
>
>'next_port' and 'last_port' derived from 'port_id', hence as 'port_id'
>is already recorded, I think 'next_port' and 'last_port' can be dropped.

Ok.
>
><...>
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_get_monitor_addr,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
>> +		const struct rte_power_monitor_cond *pmc, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_u16(queue_id);
>> +	rte_trace_point_emit_ptr(pmc);
>> +	rte_trace_point_emit_ptr(pmc->addr);
>> +	rte_trace_point_emit_u8(pmc->size);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>Another sample of what mentioned above, if 'pmc' fields are recorded, can
>we drop recording 'pmc' pointer value?

Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_set_mc_addr_list,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_ether_addr *mc_addr_set, uint32_t
>nb_mc_addr,
>> +		int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(mc_addr_set);
>
>What about recording this as blob?
>But 'mc_addr_set' is array of addresses, so length needs to be
>'RTE_ETHER_ADDR_LEN * nb_mc_addr'.

The mc_addr_set pointer can be NULL in rte_eth_dev_set_mc_addr_list. In that case the
blob function will give seg fault. Hence I think blob cannot be used here.
>
><...>
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_timesync_write_time,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec
>*time,
>> +		int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(time);
>> +	rte_trace_point_emit_size_t(time->tv_sec);
>> +	rte_trace_point_emit_long(time->tv_nsec);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'time'
Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_read_clock,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *clk, int
>ret),
>> +	uint64_t clk_v = *clk;
>> +
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(clk);
>> +	rte_trace_point_emit_u64(clk_v);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'clk'
Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_get_reg_info,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_dev_reg_info *info, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(info);
>> +	rte_trace_point_emit_ptr(info->data);
>> +	rte_trace_point_emit_u32(info->offset);
>> +	rte_trace_point_emit_u32(info->length);
>> +	rte_trace_point_emit_u32(info->width);
>> +	rte_trace_point_emit_u32(info->version);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'info'

Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_get_eeprom_length,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_get_eeprom,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_dev_eeprom_info *info, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(info);
>> +	rte_trace_point_emit_ptr(info->data);
>> +	rte_trace_point_emit_u32(info->offset);
>> +	rte_trace_point_emit_u32(info->length);
>> +	rte_trace_point_emit_u32(info->magic);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'info'

Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_set_eeprom,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_dev_eeprom_info *info, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(info->data);
>> +	rte_trace_point_emit_u32(info->offset);
>> +	rte_trace_point_emit_u32(info->length);
>> +	rte_trace_point_emit_u32(info->magic);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_get_module_info,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_dev_module_info *modinfo, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(modinfo);
>> +	rte_trace_point_emit_u32(modinfo->type);
>> +	rte_trace_point_emit_u32(modinfo->eeprom_len);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'modinfo'

Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_get_module_eeprom,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_dev_eeprom_info *info, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(info);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>> +RTE_TRACE_POINT(
>> +	rte_ethdev_trace_get_dcb_info,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_dcb_info *dcb_info, int ret),
>> +	uint8_t num_user_priorities = RTE_ETH_DCB_NUM_USER_PRIORITIES;
>> +	uint8_t num_tcs = RTE_ETH_DCB_NUM_TCS;
>> +
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(dcb_info);
>> +	rte_trace_point_emit_u8(dcb_info->nb_tcs);
>> +	rte_trace_point_emit_blob(dcb_info->prio_tc, num_user_priorities);
>> +	rte_trace_point_emit_blob(dcb_info->tc_bws, num_tcs);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'dcb_info'

Ok.
>
><...>
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_rx_metadata_negotiate,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *features,
>> +		uint64_t features_val, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(features);
>> +	rte_trace_point_emit_u64(features_val);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'features'

Ok.
>
><...>
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_ip_reassembly_conf_get,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_ip_reassembly_params *conf, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(conf);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_ip_reassembly_conf_set,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_ip_reassembly_params *conf, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(conf);
>> +	rte_trace_point_emit_u32(conf->timeout_ms);
>> +	rte_trace_point_emit_u16(conf->max_frags);
>> +	rte_trace_point_emit_u16(conf->flags);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>Can you please align recorded fields for conf_get and conf_set?

Ok.
>
><...>
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_cman_info_get,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_cman_info *info, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(info);
>> +	rte_trace_point_emit_u64(info->modes_supported);
>> +	rte_trace_point_emit_u64(info->objs_supported);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'info'

Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_cman_config_init,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_cman_config *config, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(config);
>> +	rte_trace_point_emit_int(config->obj);
>> +	rte_trace_point_emit_int(config->mode);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'config'

Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_cman_config_set,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_cman_config *config, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(config);
>> +	rte_trace_point_emit_int(config->obj);
>> +	rte_trace_point_emit_int(config->mode);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'config'
Ok.
>
>> +RTE_TRACE_POINT(
>> +	rte_eth_trace_cman_config_get,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>> +		const struct rte_eth_cman_config *config, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(config);
>> +	rte_trace_point_emit_int(config->obj);
>> +	rte_trace_point_emit_int(config->mode);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'config'

Ok.
>
><...>
>
>> +/* Called in loop in examples/ptpclient */ RTE_TRACE_POINT_FP(
>> +	rte_eth_trace_timesync_read_rx_timestamp,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec
>*timestamp,
>> +		uint32_t flags, int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(timestamp);
>> +	rte_trace_point_emit_size_t(timestamp->tv_sec);
>> +	rte_trace_point_emit_long(timestamp->tv_nsec);
>> +	rte_trace_point_emit_u32(flags);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'timestamp'

Ok.
>
>> +/* Called in loop in examples/ptpclient */ RTE_TRACE_POINT_FP(
>> +	rte_eth_trace_timesync_read_tx_timestamp,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec
>*timestamp,
>> +		int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(timestamp);
>> +	rte_trace_point_emit_size_t(timestamp->tv_sec);
>> +	rte_trace_point_emit_long(timestamp->tv_nsec);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'timestamp'

Ok.
>
>> +/* Called in loop in examples/ptpclient */ RTE_TRACE_POINT_FP(
>> +	rte_eth_trace_timesync_read_time,
>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec
>*time,
>> +		int ret),
>> +	rte_trace_point_emit_u16(port_id);
>> +	rte_trace_point_emit_ptr(time);
>> +	rte_trace_point_emit_size_t(time->tv_sec);
>> +	rte_trace_point_emit_long(time->tv_nsec);
>> +	rte_trace_point_emit_int(ret);
>> +)
>> +
>
>ditto for 'time'

Ok.
>
><...>
>
>> @@ -4141,6 +4196,7 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t
>port_id,
>>  				   struct rte_eth_pfc_conf *pfc_conf)  {
>>  	struct rte_eth_dev *dev;
>> +	int ret;
>>
>>  	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
>>  	dev = &rte_eth_devices[port_id];
>> @@ -4158,9 +4214,15 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t
>port_id,
>>  	}
>>
>>  	/* High water, low water validation are device specific */
>> -	if  (*dev->dev_ops->priority_flow_ctrl_set)
>> -		return eth_err(port_id, (*dev->dev_ops-
>>priority_flow_ctrl_set)
>> -					(dev, pfc_conf));
>> +	if  (*dev->dev_ops->priority_flow_ctrl_set) {
>> +		ret = eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set)
>> +				       (dev, pfc_conf));
>> +
>> +		rte_ethdev_trace_priority_flow_ctrl_set(port_id, pfc_conf,
>ret);
>> +
>> +		return ret;
>> +	}
>> +
>>  	return -ENOTSUP;
>>  }
>>
>> @@ -4219,6 +4281,7 @@
>rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id,
>>  		struct rte_eth_pfc_queue_info *pfc_queue_info)  {
>>  	struct rte_eth_dev *dev;
>> +	int ret;
>>
>>  	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
>>  	dev = &rte_eth_devices[port_id];
>> @@ -4229,9 +4292,15 @@
>rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id,
>>  		return -EINVAL;
>>  	}
>>
>> -	if (*dev->dev_ops->priority_flow_ctrl_queue_info_get)
>> -		return eth_err(port_id, (*dev->dev_ops-
>>priority_flow_ctrl_queue_info_get)
>> +	if (*dev->dev_ops->priority_flow_ctrl_queue_info_get) {
>> +		ret = eth_err(port_id,
>> +(*dev->dev_ops->priority_flow_ctrl_queue_info_get)
>>  			(dev, pfc_queue_info));
>> +
>> +		rte_ethdev_trace_priority_flow_ctrl_queue_info_get(port_id,
>> +							pfc_queue_info, ret);
>> +
>> +		return ret;
>> +	}
>>  	return -ENOTSUP;
>>  }
>>
>> @@ -4300,10 +4369,17 @@
>rte_eth_dev_priority_flow_ctrl_queue_configure(uint16_t port_id,
>>  			return ret;
>>  	}
>>
>> -	if (*dev->dev_ops->priority_flow_ctrl_queue_config)
>> -		return eth_err(port_id,
>> -			       (*dev->dev_ops-
>>priority_flow_ctrl_queue_config)(
>> -				dev, pfc_queue_conf));
>> +	if (*dev->dev_ops->priority_flow_ctrl_queue_config) {
>> +		ret = eth_err(port_id,
>> +			      (*dev->dev_ops-
>>priority_flow_ctrl_queue_config)(
>> +			       dev, pfc_queue_conf));
>> +
>> +
>	rte_ethdev_trace_priority_flow_ctrl_queue_configure(port_id,
>> +							pfc_queue_conf, ret);
>> +
>> +		return ret;
>> +	}
>> +
>
>
>Not really related with this patch, but dev_ops check logic is reverse
>(unconventional) in these functions.
>
>Most of the time what we have is:
>```
>if (*dev->dev_ops->xxx == NULL)
>	return -ENOTSUP;
>
>rest_of_the_function;
>```
>
>But after change these functions become:
>```
>if (*dev->dev_ops->xxx) {
>	do_whatever_action_needs;
>	...
>
>	return ret;
>}
>
>return -ENOTSUP;
>```
>
>
>Since it is updating these lines, can you please fix this check too?

Ok.
>
>This seems valid for:
>rte_eth_dev_priority_flow_ctrl_set
>rte_eth_dev_priority_flow_ctrl_queue_info_get
>rte_eth_dev_priority_flow_ctrl_queue_configure
  
Ferruh Yigit Feb. 8, 2023, 11 a.m. UTC | #3
On 2/8/2023 10:42 AM, Ankur Dwivedi wrote:
>>> +RTE_TRACE_POINT(
>>> +	rte_ethdev_trace_set_mc_addr_list,
>>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>>> +		const struct rte_ether_addr *mc_addr_set, uint32_t
>> nb_mc_addr,
>>> +		int ret),
>>> +	rte_trace_point_emit_u16(port_id);
>>> +	rte_trace_point_emit_ptr(mc_addr_set);
>> What about recording this as blob?
>> But 'mc_addr_set' is array of addresses, so length needs to be
>> 'RTE_ETHER_ADDR_LEN * nb_mc_addr'.
> The mc_addr_set pointer can be NULL in rte_eth_dev_set_mc_addr_list. In that case the
> blob function will give seg fault. Hence I think blob cannot be used here.
Does it make sense to make 'rte_trace_point_emit_blob()' accept NULL and
fill all array with 0 in that case to cover this kind of cases?
  
Ferruh Yigit Feb. 8, 2023, 11:04 a.m. UTC | #4
On 2/8/2023 11:00 AM, Ferruh Yigit wrote:
> On 2/8/2023 10:42 AM, Ankur Dwivedi wrote:
>>>> +RTE_TRACE_POINT(
>>>> +	rte_ethdev_trace_set_mc_addr_list,
>>>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>>>> +		const struct rte_ether_addr *mc_addr_set, uint32_t
>>> nb_mc_addr,
>>>> +		int ret),
>>>> +	rte_trace_point_emit_u16(port_id);
>>>> +	rte_trace_point_emit_ptr(mc_addr_set);
>>> What about recording this as blob?
>>> But 'mc_addr_set' is array of addresses, so length needs to be
>>> 'RTE_ETHER_ADDR_LEN * nb_mc_addr'.
>> The mc_addr_set pointer can be NULL in rte_eth_dev_set_mc_addr_list. In that case the
>> blob function will give seg fault. Hence I think blob cannot be used here.
> Does it make sense to make 'rte_trace_point_emit_blob()' accept NULL and
> fill all array with 0 in that case to cover this kind of cases?


btw, 'rte_trace_point_emit_blob()' already checks for NULL, so expect it
won't give segmentation fault, but won't record the value.
Not sure if not recording the value cause problem later when parsing the
trace file.
  
Ankur Dwivedi Feb. 8, 2023, 2:15 p.m. UTC | #5
>Subject: Re: [EXT] Re: [PATCH v9 3/6] ethdev: add trace points for ethdev (part
>two)
>
>On 2/8/2023 11:00 AM, Ferruh Yigit wrote:
>> On 2/8/2023 10:42 AM, Ankur Dwivedi wrote:
>>>>> +RTE_TRACE_POINT(
>>>>> +	rte_ethdev_trace_set_mc_addr_list,
>>>>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>>>>> +		const struct rte_ether_addr *mc_addr_set, uint32_t
>>>> nb_mc_addr,
>>>>> +		int ret),
>>>>> +	rte_trace_point_emit_u16(port_id);
>>>>> +	rte_trace_point_emit_ptr(mc_addr_set);
>>>> What about recording this as blob?
>>>> But 'mc_addr_set' is array of addresses, so length needs to be
>>>> 'RTE_ETHER_ADDR_LEN * nb_mc_addr'.
>>> The mc_addr_set pointer can be NULL in rte_eth_dev_set_mc_addr_list.
>>> In that case the blob function will give seg fault. Hence I think blob cannot
>be used here.
>> Does it make sense to make 'rte_trace_point_emit_blob()' accept NULL
>> and fill all array with 0 in that case to cover this kind of cases?
>
>
>btw, 'rte_trace_point_emit_blob()' already checks for NULL, so expect it won't
>give segmentation fault, but won't record the value.
The blob function will be called as rte_trace_point_emit_blob(mc_addr_set->addr_bytes, len).
If mc_addr_set is NULL then it will result in a segmentation fault. 

>Not sure if not recording the value cause problem later when parsing the trace
>file.
Wont recording the value is not a issue as the value will not be copied in trace memory in rte_trace_point_emit_blob() (lib/eal/include/rte_trace_point.h).
  
Ferruh Yigit Feb. 8, 2023, 3:05 p.m. UTC | #6
On 2/8/2023 2:15 PM, Ankur Dwivedi wrote:
>> Subject: Re: [EXT] Re: [PATCH v9 3/6] ethdev: add trace points for ethdev (part
>> two)
>>
>> On 2/8/2023 11:00 AM, Ferruh Yigit wrote:
>>> On 2/8/2023 10:42 AM, Ankur Dwivedi wrote:
>>>>>> +RTE_TRACE_POINT(
>>>>>> +	rte_ethdev_trace_set_mc_addr_list,
>>>>>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>>>>>> +		const struct rte_ether_addr *mc_addr_set, uint32_t
>>>>> nb_mc_addr,
>>>>>> +		int ret),
>>>>>> +	rte_trace_point_emit_u16(port_id);
>>>>>> +	rte_trace_point_emit_ptr(mc_addr_set);
>>>>> What about recording this as blob?
>>>>> But 'mc_addr_set' is array of addresses, so length needs to be
>>>>> 'RTE_ETHER_ADDR_LEN * nb_mc_addr'.
>>>> The mc_addr_set pointer can be NULL in rte_eth_dev_set_mc_addr_list.
>>>> In that case the blob function will give seg fault. Hence I think blob cannot
>> be used here.
>>> Does it make sense to make 'rte_trace_point_emit_blob()' accept NULL
>>> and fill all array with 0 in that case to cover this kind of cases?
>>
>>
>> btw, 'rte_trace_point_emit_blob()' already checks for NULL, so expect it won't
>> give segmentation fault, but won't record the value.
> The blob function will be called as rte_trace_point_emit_blob(mc_addr_set->addr_bytes, len).
> If mc_addr_set is NULL then it will result in a segmentation fault. 
> 

Of course trying to access the field 'mc_addr_set->addr_bytes' will
cause problem for null pointer, why not:

rte_trace_point_emit_blob(mc_addr_set, len);

>> Not sure if not recording the value cause problem later when parsing the trace
>> file.
> Wont recording the value is not a issue as the value will not be copied in trace memory in rte_trace_point_emit_blob() (lib/eal/include/rte_trace_point.h).
>
  
Ankur Dwivedi Feb. 8, 2023, 3:11 p.m. UTC | #7
>Subject: Re: [EXT] Re: [PATCH v9 3/6] ethdev: add trace points for ethdev (part
>two)
>
>On 2/8/2023 2:15 PM, Ankur Dwivedi wrote:
>>> Subject: Re: [EXT] Re: [PATCH v9 3/6] ethdev: add trace points for
>>> ethdev (part
>>> two)
>>>
>>> On 2/8/2023 11:00 AM, Ferruh Yigit wrote:
>>>> On 2/8/2023 10:42 AM, Ankur Dwivedi wrote:
>>>>>>> +RTE_TRACE_POINT(
>>>>>>> +	rte_ethdev_trace_set_mc_addr_list,
>>>>>>> +	RTE_TRACE_POINT_ARGS(uint16_t port_id,
>>>>>>> +		const struct rte_ether_addr *mc_addr_set, uint32_t
>>>>>> nb_mc_addr,
>>>>>>> +		int ret),
>>>>>>> +	rte_trace_point_emit_u16(port_id);
>>>>>>> +	rte_trace_point_emit_ptr(mc_addr_set);
>>>>>> What about recording this as blob?
>>>>>> But 'mc_addr_set' is array of addresses, so length needs to be
>>>>>> 'RTE_ETHER_ADDR_LEN * nb_mc_addr'.
>>>>> The mc_addr_set pointer can be NULL in rte_eth_dev_set_mc_addr_list.
>>>>> In that case the blob function will give seg fault. Hence I think
>>>>> blob cannot
>>> be used here.
>>>> Does it make sense to make 'rte_trace_point_emit_blob()' accept NULL
>>>> and fill all array with 0 in that case to cover this kind of cases?
>>>
>>>
>>> btw, 'rte_trace_point_emit_blob()' already checks for NULL, so expect
>>> it won't give segmentation fault, but won't record the value.
>> The blob function will be called as rte_trace_point_emit_blob(mc_addr_set-
>>addr_bytes, len).
>> If mc_addr_set is NULL then it will result in a segmentation fault.
>>
>
>Of course trying to access the field 'mc_addr_set->addr_bytes' will cause
>problem for null pointer, why not:
>
>rte_trace_point_emit_blob(mc_addr_set, len);

This should work.
>
>>> Not sure if not recording the value cause problem later when parsing
>>> the trace file.
>> Wont recording the value is not a issue as the value will not be copied in
>trace memory in rte_trace_point_emit_blob()
>(lib/eal/include/rte_trace_point.h).
>>
  

Patch

diff --git a/lib/ethdev/ethdev_trace.h b/lib/ethdev/ethdev_trace.h
index a5058f97ea..9039446b5f 100644
--- a/lib/ethdev/ethdev_trace.h
+++ b/lib/ethdev/ethdev_trace.h
@@ -592,6 +592,815 @@  RTE_TRACE_POINT(
 	rte_trace_point_emit_int(ret);
 )
 
+RTE_TRACE_POINT(
+	rte_ethdev_trace_info_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_dev_info *dev_info),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_string(dev_info->driver_name);
+	rte_trace_point_emit_u16(dev_info->min_mtu);
+	rte_trace_point_emit_u16(dev_info->max_mtu);
+	rte_trace_point_emit_u32(dev_info->min_rx_bufsize);
+	rte_trace_point_emit_u32(dev_info->max_rx_pktlen);
+	rte_trace_point_emit_u16(dev_info->max_rx_queues);
+	rte_trace_point_emit_u16(dev_info->max_tx_queues);
+	rte_trace_point_emit_u32(dev_info->max_mac_addrs);
+	rte_trace_point_emit_u64(dev_info->rx_offload_capa);
+	rte_trace_point_emit_u64(dev_info->tx_offload_capa);
+	rte_trace_point_emit_u64(dev_info->rx_queue_offload_capa);
+	rte_trace_point_emit_u64(dev_info->tx_queue_offload_capa);
+	rte_trace_point_emit_u16(dev_info->reta_size);
+	rte_trace_point_emit_u8(dev_info->hash_key_size);
+	rte_trace_point_emit_u64(dev_info->flow_type_rss_offloads);
+	rte_trace_point_emit_u16(dev_info->rx_desc_lim.nb_max);
+	rte_trace_point_emit_u16(dev_info->rx_desc_lim.nb_min);
+	rte_trace_point_emit_u16(dev_info->rx_desc_lim.nb_align);
+	rte_trace_point_emit_u16(dev_info->tx_desc_lim.nb_max);
+	rte_trace_point_emit_u16(dev_info->tx_desc_lim.nb_min);
+	rte_trace_point_emit_u16(dev_info->tx_desc_lim.nb_align);
+	rte_trace_point_emit_u32(dev_info->speed_capa);
+	rte_trace_point_emit_u16(dev_info->nb_rx_queues);
+	rte_trace_point_emit_u16(dev_info->nb_tx_queues);
+	rte_trace_point_emit_u64(dev_info->dev_capa);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_conf_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_conf *dev_conf),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(dev_conf);
+	rte_trace_point_emit_u32(dev_conf->link_speeds);
+	rte_trace_point_emit_u64(dev_conf->rxmode.offloads);
+	rte_trace_point_emit_u64(dev_conf->txmode.offloads);
+	rte_trace_point_emit_u32(dev_conf->lpbk_mode);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_supported_ptypes,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int supported_num, int num,
+		uint32_t ptypes),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(supported_num);
+	rte_trace_point_emit_int(num);
+	rte_trace_point_emit_u32(ptypes);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_ptypes,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int supported_num,
+		unsigned int num, uint32_t set_ptypes),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(supported_num);
+	rte_trace_point_emit_u32(num);
+	rte_trace_point_emit_u32(set_ptypes);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_macaddrs_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, unsigned int num),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u32(num);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_mtu,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t mtu, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(mtu);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_vlan_filter,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t vlan_id, int on,
+		int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(vlan_id);
+	rte_trace_point_emit_int(on);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_vlan_strip_on_queue,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t rx_queue_id, int on),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(rx_queue_id);
+	rte_trace_point_emit_int(on);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_vlan_ether_type,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_vlan_type vlan_type,
+		uint16_t tag_type, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(vlan_type);
+	rte_trace_point_emit_u16(tag_type);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_vlan_offload,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int offload_mask, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(offload_mask);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_vlan_offload,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_vlan_pvid,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t pvid, int on, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(pvid);
+	rte_trace_point_emit_int(on);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_flow_ctrl_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_fc_conf *fc_conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(fc_conf);
+	rte_trace_point_emit_u32(fc_conf->high_water);
+	rte_trace_point_emit_u32(fc_conf->low_water);
+	rte_trace_point_emit_u16(fc_conf->pause_time);
+	rte_trace_point_emit_u16(fc_conf->send_xon);
+	rte_trace_point_emit_int(fc_conf->mode);
+	rte_trace_point_emit_u8(fc_conf->mac_ctrl_frame_fwd);
+	rte_trace_point_emit_u8(fc_conf->autoneg);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_flow_ctrl_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_fc_conf *fc_conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u32(fc_conf->high_water);
+	rte_trace_point_emit_u32(fc_conf->low_water);
+	rte_trace_point_emit_u16(fc_conf->pause_time);
+	rte_trace_point_emit_u16(fc_conf->send_xon);
+	rte_trace_point_emit_int(fc_conf->mode);
+	rte_trace_point_emit_u8(fc_conf->mac_ctrl_frame_fwd);
+	rte_trace_point_emit_u8(fc_conf->autoneg);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_priority_flow_ctrl_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_pfc_conf *pfc_conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u32(pfc_conf->fc.high_water);
+	rte_trace_point_emit_u32(pfc_conf->fc.low_water);
+	rte_trace_point_emit_u16(pfc_conf->fc.pause_time);
+	rte_trace_point_emit_u16(pfc_conf->fc.send_xon);
+	rte_trace_point_emit_int(pfc_conf->fc.mode);
+	rte_trace_point_emit_u8(pfc_conf->fc.mac_ctrl_frame_fwd);
+	rte_trace_point_emit_u8(pfc_conf->fc.autoneg);
+	rte_trace_point_emit_u8(pfc_conf->priority);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_priority_flow_ctrl_queue_info_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_pfc_queue_info *pfc_queue_info, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(pfc_queue_info);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_priority_flow_ctrl_queue_configure,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_pfc_queue_conf *pfc_queue_conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(pfc_queue_conf);
+	rte_trace_point_emit_int(pfc_queue_conf->mode);
+	rte_trace_point_emit_u16(pfc_queue_conf->rx_pause.tx_qid);
+	rte_trace_point_emit_u16(pfc_queue_conf->tx_pause.rx_qid);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_rss_reta_update,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_rss_reta_entry64 *reta_conf,
+		uint16_t reta_size, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(reta_conf);
+	rte_trace_point_emit_u16(reta_size);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_rss_reta_query,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_rss_reta_entry64 *reta_conf,
+		uint16_t reta_size, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(reta_conf);
+	rte_trace_point_emit_u16(reta_size);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_rss_hash_update,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_rss_conf *rss_conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(rss_conf->rss_key);
+	rte_trace_point_emit_u8(rss_conf->rss_key_len);
+	rte_trace_point_emit_u64(rss_conf->rss_hf);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_rss_hash_conf_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_rss_conf *rss_conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(rss_conf->rss_key);
+	rte_trace_point_emit_u8(rss_conf->rss_key_len);
+	rte_trace_point_emit_u64(rss_conf->rss_hf);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_udp_tunnel_port_add,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_udp_tunnel *tunnel_udp, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(tunnel_udp->udp_port);
+	rte_trace_point_emit_u8(tunnel_udp->prot_type);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_udp_tunnel_port_delete,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_udp_tunnel *tunnel_udp, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(tunnel_udp->udp_port);
+	rte_trace_point_emit_u8(tunnel_udp->prot_type);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_led_on,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_led_off,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_fec_get_capability,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_fec_capa *speed_fec_capa,
+		unsigned int num, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(speed_fec_capa);
+	rte_trace_point_emit_u32(speed_fec_capa->speed);
+	rte_trace_point_emit_u32(speed_fec_capa->capa);
+	rte_trace_point_emit_u32(num);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_fec_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint32_t *fec_capa,
+		int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(fec_capa);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_fec_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint32_t fec_capa, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u32(fec_capa);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_mac_addr_add,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_ether_addr *addr, uint32_t pool, int ret),
+	uint8_t len = RTE_ETHER_ADDR_LEN;
+
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(addr);
+	rte_trace_point_emit_blob(addr->addr_bytes, len);
+	rte_trace_point_emit_u32(pool);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_mac_addr_remove,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_ether_addr *addr),
+	uint8_t len = RTE_ETHER_ADDR_LEN;
+
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(addr);
+	rte_trace_point_emit_blob(addr->addr_bytes, len);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_default_mac_addr_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_ether_addr *addr),
+	uint8_t len = RTE_ETHER_ADDR_LEN;
+
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(addr);
+	rte_trace_point_emit_blob(addr->addr_bytes, len);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_uc_hash_table_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint8_t on, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u8(on);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_uc_all_hash_table_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint8_t on, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u8(on);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_set_queue_rate_limit,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_idx,
+		uint16_t tx_rate, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_idx);
+	rte_trace_point_emit_u16(tx_rate);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_rx_avail_thresh_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		uint8_t avail_thresh, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_u8(avail_thresh);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_rx_avail_thresh_query,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_callback_register,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_eth_event_type event,
+		rte_eth_dev_cb_fn cb_fn, const void *cb_arg, uint16_t next_port,
+		uint16_t last_port),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(event);
+	rte_trace_point_emit_ptr(cb_fn);
+	rte_trace_point_emit_ptr(cb_arg);
+	rte_trace_point_emit_u16(next_port);
+	rte_trace_point_emit_u16(last_port);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_callback_unregister,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, enum rte_eth_event_type event,
+		rte_eth_dev_cb_fn cb_fn, const void *cb_arg, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(event);
+	rte_trace_point_emit_ptr(cb_fn);
+	rte_trace_point_emit_ptr(cb_arg);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_rx_intr_ctl,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t qid, int epfd, int op,
+		const void *data, int rc),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(qid);
+	rte_trace_point_emit_int(epfd);
+	rte_trace_point_emit_int(op);
+	rte_trace_point_emit_ptr(data);
+	rte_trace_point_emit_int(rc);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_rx_intr_ctl_q_get_fd,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int fd),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_int(fd);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_rx_intr_ctl_q,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int epfd,
+		int op, const void *data, int rc),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_int(epfd);
+	rte_trace_point_emit_int(op);
+	rte_trace_point_emit_ptr(data);
+	rte_trace_point_emit_int(rc);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_add_rx_callback,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		rte_rx_callback_fn fn, void *user_param,
+		const struct rte_eth_rxtx_callback *cb),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(fn);
+	rte_trace_point_emit_ptr(user_param);
+	rte_trace_point_emit_ptr(cb);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_add_first_rx_callback,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		rte_rx_callback_fn fn, const void *user_param,
+		const struct rte_eth_rxtx_callback *cb),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(fn);
+	rte_trace_point_emit_ptr(user_param);
+	rte_trace_point_emit_ptr(cb);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_add_tx_callback,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		rte_tx_callback_fn fn, const void *user_param,
+		const struct rte_eth_rxtx_callback *cb),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(fn);
+	rte_trace_point_emit_ptr(user_param);
+	rte_trace_point_emit_ptr(cb);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_remove_rx_callback,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		const struct rte_eth_rxtx_callback *user_cb, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(user_cb);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_remove_tx_callback,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		const struct rte_eth_rxtx_callback *user_cb, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(user_cb);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_rx_queue_info_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		const struct rte_eth_rxq_info *qinfo),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(qinfo->mp);
+	rte_trace_point_emit_u8(qinfo->conf.rx_drop_en);
+	rte_trace_point_emit_u64(qinfo->conf.offloads);
+	rte_trace_point_emit_u8(qinfo->scattered_rx);
+	rte_trace_point_emit_u8(qinfo->queue_state);
+	rte_trace_point_emit_u16(qinfo->nb_desc);
+	rte_trace_point_emit_u16(qinfo->rx_buf_size);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_tx_queue_info_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		const struct rte_eth_txq_info *qinfo),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_u16(qinfo->nb_desc);
+	rte_trace_point_emit_u8(qinfo->queue_state);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_rx_burst_mode_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		const struct rte_eth_burst_mode *mode, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(mode);
+	rte_trace_point_emit_u64(mode->flags);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_tx_burst_mode_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		const struct rte_eth_burst_mode *mode, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(mode);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_get_monitor_addr,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id,
+		const struct rte_power_monitor_cond *pmc, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_ptr(pmc);
+	rte_trace_point_emit_ptr(pmc->addr);
+	rte_trace_point_emit_u8(pmc->size);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_mc_addr_list,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_ether_addr *mc_addr_set, uint32_t nb_mc_addr,
+		int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(mc_addr_set);
+	rte_trace_point_emit_u32(nb_mc_addr);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_timesync_enable,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_timesync_disable,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_timesync_write_time,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *time,
+		int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(time);
+	rte_trace_point_emit_size_t(time->tv_sec);
+	rte_trace_point_emit_long(time->tv_nsec);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_read_clock,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *clk, int ret),
+	uint64_t clk_v = *clk;
+
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(clk);
+	rte_trace_point_emit_u64(clk_v);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_reg_info,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_dev_reg_info *info, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(info);
+	rte_trace_point_emit_ptr(info->data);
+	rte_trace_point_emit_u32(info->offset);
+	rte_trace_point_emit_u32(info->length);
+	rte_trace_point_emit_u32(info->width);
+	rte_trace_point_emit_u32(info->version);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_eeprom_length,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_eeprom,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_dev_eeprom_info *info, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(info);
+	rte_trace_point_emit_ptr(info->data);
+	rte_trace_point_emit_u32(info->offset);
+	rte_trace_point_emit_u32(info->length);
+	rte_trace_point_emit_u32(info->magic);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_set_eeprom,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_dev_eeprom_info *info, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(info->data);
+	rte_trace_point_emit_u32(info->offset);
+	rte_trace_point_emit_u32(info->length);
+	rte_trace_point_emit_u32(info->magic);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_module_info,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_dev_module_info *modinfo, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(modinfo);
+	rte_trace_point_emit_u32(modinfo->type);
+	rte_trace_point_emit_u32(modinfo->eeprom_len);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_module_eeprom,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_dev_eeprom_info *info, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(info);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_get_dcb_info,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_dcb_info *dcb_info, int ret),
+	uint8_t num_user_priorities = RTE_ETH_DCB_NUM_USER_PRIORITIES;
+	uint8_t num_tcs = RTE_ETH_DCB_NUM_TCS;
+
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(dcb_info);
+	rte_trace_point_emit_u8(dcb_info->nb_tcs);
+	rte_trace_point_emit_blob(dcb_info->prio_tc, num_user_priorities);
+	rte_trace_point_emit_blob(dcb_info->tc_bws, num_tcs);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_adjust_nb_rx_tx_desc,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id),
+	rte_trace_point_emit_u16(port_id);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_hairpin_capability_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_hairpin_cap *cap, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(cap);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_ethdev_trace_pool_ops_supported,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const char *pool, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_string(pool);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_representor_info_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_representor_info *info, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(info);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_rx_metadata_negotiate,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const uint64_t *features,
+		uint64_t features_val, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(features);
+	rte_trace_point_emit_u64(features_val);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_ip_reassembly_capability_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_ip_reassembly_params *capa, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(capa);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_ip_reassembly_conf_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_ip_reassembly_params *conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(conf);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_ip_reassembly_conf_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_ip_reassembly_params *conf, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(conf);
+	rte_trace_point_emit_u32(conf->timeout_ms);
+	rte_trace_point_emit_u16(conf->max_frags);
+	rte_trace_point_emit_u16(conf->flags);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_buffer_split_get_supported_hdr_ptypes,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int supported_num,
+		uint32_t ptypes),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_int(supported_num);
+	rte_trace_point_emit_u32(ptypes);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_cman_info_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_cman_info *info, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(info);
+	rte_trace_point_emit_u64(info->modes_supported);
+	rte_trace_point_emit_u64(info->objs_supported);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_cman_config_init,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_cman_config *config, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(config);
+	rte_trace_point_emit_int(config->obj);
+	rte_trace_point_emit_int(config->mode);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_cman_config_set,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_cman_config *config, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(config);
+	rte_trace_point_emit_int(config->obj);
+	rte_trace_point_emit_int(config->mode);
+	rte_trace_point_emit_int(ret);
+)
+
+RTE_TRACE_POINT(
+	rte_eth_trace_cman_config_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_eth_cman_config *config, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(config);
+	rte_trace_point_emit_int(config->obj);
+	rte_trace_point_emit_int(config->mode);
+	rte_trace_point_emit_int(ret);
+)
+
 /* Fast path trace points */
 
 /* Called in loop in examples/qos_sched and examples/distributor */
@@ -635,6 +1444,90 @@  RTE_TRACE_POINT_FP(
 	rte_trace_point_emit_string(ret);
 )
 
+/* Called in loop in examples/bond and examples/ethtool */
+RTE_TRACE_POINT_FP(
+	rte_eth_trace_macaddr_get,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id,
+		const struct rte_ether_addr *mac_addr),
+	uint8_t len = RTE_ETHER_ADDR_LEN;
+
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(mac_addr);
+	rte_trace_point_emit_blob(mac_addr->addr_bytes, len);
+)
+
+/* Called in loop in examples/ip_pipeline */
+RTE_TRACE_POINT_FP(
+	rte_ethdev_trace_get_mtu,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t mtu),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(mtu);
+)
+
+/* Called in loop in examples/l3fwd-power */
+RTE_TRACE_POINT_FP(
+	rte_ethdev_trace_rx_intr_enable,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_int(ret);
+)
+
+/* Called in loop in examples/l3fwd-power */
+RTE_TRACE_POINT_FP(
+	rte_ethdev_trace_rx_intr_disable,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, uint16_t queue_id, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_u16(queue_id);
+	rte_trace_point_emit_int(ret);
+)
+
+/* Called in loop in examples/ptpclient */
+RTE_TRACE_POINT_FP(
+	rte_eth_trace_timesync_read_rx_timestamp,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *timestamp,
+		uint32_t flags, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(timestamp);
+	rte_trace_point_emit_size_t(timestamp->tv_sec);
+	rte_trace_point_emit_long(timestamp->tv_nsec);
+	rte_trace_point_emit_u32(flags);
+	rte_trace_point_emit_int(ret);
+)
+
+/* Called in loop in examples/ptpclient */
+RTE_TRACE_POINT_FP(
+	rte_eth_trace_timesync_read_tx_timestamp,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *timestamp,
+		int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(timestamp);
+	rte_trace_point_emit_size_t(timestamp->tv_sec);
+	rte_trace_point_emit_long(timestamp->tv_nsec);
+	rte_trace_point_emit_int(ret);
+)
+
+/* Called in loop in examples/ptpclient */
+RTE_TRACE_POINT_FP(
+	rte_eth_trace_timesync_read_time,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, const struct timespec *time,
+		int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_ptr(time);
+	rte_trace_point_emit_size_t(time->tv_sec);
+	rte_trace_point_emit_long(time->tv_nsec);
+	rte_trace_point_emit_int(ret);
+)
+
+/* Called in loop in examples/ptpclient */
+RTE_TRACE_POINT_FP(
+	rte_eth_trace_timesync_adjust_time,
+	RTE_TRACE_POINT_ARGS(uint16_t port_id, int64_t delta, int ret),
+	rte_trace_point_emit_u16(port_id);
+	rte_trace_point_emit_i64(delta);
+	rte_trace_point_emit_int(ret);
+)
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/lib/ethdev/ethdev_trace_points.c b/lib/ethdev/ethdev_trace_points.c
index 3e58c679c3..7a08104dc9 100644
--- a/lib/ethdev/ethdev_trace_points.c
+++ b/lib/ethdev/ethdev_trace_points.c
@@ -222,3 +222,255 @@  RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_rx_queue_stats_mapping,
 
 RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_fw_version_get,
 	lib.ethdev.fw_version_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_info_get,
+	lib.ethdev.info_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_conf_get,
+	lib.ethdev.conf_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_supported_ptypes,
+	lib.ethdev.get_supported_ptypes)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_ptypes,
+	lib.ethdev.set_ptypes)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_macaddrs_get,
+	lib.ethdev.macaddrs_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_macaddr_get,
+	lib.ethdev.macaddr_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_mtu,
+	lib.ethdev.get_mtu)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_mtu,
+	lib.ethdev.set_mtu)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_vlan_filter,
+	lib.ethdev.vlan_filter)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_strip_on_queue,
+	lib.ethdev.set_vlan_strip_on_queue)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_ether_type,
+	lib.ethdev.set_vlan_ether_type)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_offload,
+	lib.ethdev.set_vlan_offload)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_vlan_offload,
+	lib.ethdev.get_vlan_offload)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_vlan_pvid,
+	lib.ethdev.set_vlan_pvid)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_flow_ctrl_get,
+	lib.ethdev.flow_ctrl_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_flow_ctrl_set,
+	lib.ethdev.flow_ctrl_set)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_priority_flow_ctrl_set,
+	lib.ethdev.priority_flow_ctrl_set)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_priority_flow_ctrl_queue_info_get,
+	lib.ethdev.priority_flow_ctrl_queue_info_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_priority_flow_ctrl_queue_configure,
+	lib.ethdev.priority_flow_ctrl_queue_configure)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_reta_update,
+	lib.ethdev.rss_reta_update)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_reta_query,
+	lib.ethdev.rss_reta_query)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_hash_update,
+	lib.ethdev.rss_hash_update)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rss_hash_conf_get,
+	lib.ethdev.rss_hash_conf_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_udp_tunnel_port_add,
+	lib.ethdev.udp_tunnel_port_add)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_udp_tunnel_port_delete,
+	lib.ethdev.udp_tunnel_port_delete)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_led_on,
+	lib.ethdev.led_on)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_led_off,
+	lib.ethdev.led_off)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_fec_get_capability,
+	lib.ethdev.fec_get_capability)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_fec_get,
+	lib.ethdev.fec_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_fec_set,
+	lib.ethdev.fec_set)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_mac_addr_add,
+	lib.ethdev.mac_addr_add)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_mac_addr_remove,
+	lib.ethdev.mac_addr_remove)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_default_mac_addr_set,
+	lib.ethdev.default_mac_addr_set)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_uc_hash_table_set,
+	lib.ethdev.uc_hash_table_set)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_uc_all_hash_table_set,
+	lib.ethdev.uc_all_hash_table_set)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_set_queue_rate_limit,
+	lib.ethdev.set_queue_rate_limit)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_set,
+	lib.ethdev.rx_avail_thresh_set)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_avail_thresh_query,
+	lib.ethdev.rx_avail_thresh_query)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_callback_register,
+	lib.ethdev.callback_register)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_callback_unregister,
+	lib.ethdev.callback_unregister)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_ctl,
+	lib.ethdev.rx_intr_ctl)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_ctl_q_get_fd,
+	lib.ethdev.rx_intr_ctl_q_get_fd)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_ctl_q,
+	lib.ethdev.rx_intr_ctl_q)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_enable,
+	lib.ethdev.rx_intr_enable)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_rx_intr_disable,
+	lib.ethdev.rx_intr_disable)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_add_rx_callback,
+	lib.ethdev.add_rx_callback)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_add_first_rx_callback,
+	lib.ethdev.add_first_rx_callback)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_add_tx_callback,
+	lib.ethdev.add_tx_callback)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_remove_rx_callback,
+	lib.ethdev.remove_rx_callback)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_remove_tx_callback,
+	lib.ethdev.remove_tx_callback)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_queue_info_get,
+	lib.ethdev.rx_queue_info_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_queue_info_get,
+	lib.ethdev.tx_queue_info_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_burst_mode_get,
+	lib.ethdev.rx_burst_mode_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_tx_burst_mode_get,
+	lib.ethdev.tx_burst_mode_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_get_monitor_addr,
+	lib.ethdev.get_monitor_addr)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_mc_addr_list,
+	lib.ethdev.set_mc_addr_list)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_enable,
+	lib.ethdev.timesync_enable)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_disable,
+	lib.ethdev.timesync_disable)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_read_rx_timestamp,
+	lib.ethdev.timesync_read_rx_timestamp)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_read_tx_timestamp,
+	lib.ethdev.timesync_read_tx_timestamp)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_adjust_time,
+	lib.ethdev.timesync_adjust_time)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_read_time,
+	lib.ethdev.timesync_read_time)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_timesync_write_time,
+	lib.ethdev.timesync_write_time)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_read_clock,
+	lib.ethdev.read_clock)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_reg_info,
+	lib.ethdev.get_reg_info)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_eeprom_length,
+	lib.ethdev.get_eeprom_length)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_eeprom,
+	lib.ethdev.get_eeprom)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_set_eeprom,
+	lib.ethdev.set_eeprom)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_module_info,
+	lib.ethdev.get_module_info)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_module_eeprom,
+	lib.ethdev.get_module_eeprom)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_get_dcb_info,
+	lib.ethdev.get_dcb_info)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_adjust_nb_rx_tx_desc,
+	lib.ethdev.adjust_nb_rx_tx_desc)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_hairpin_capability_get,
+	lib.ethdev.hairpin_capability_get)
+
+RTE_TRACE_POINT_REGISTER(rte_ethdev_trace_pool_ops_supported,
+	lib.ethdev.pool_ops_supported)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_representor_info_get,
+	lib.ethdev.representor_info_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_rx_metadata_negotiate,
+	lib.ethdev.rx_metadata_negotiate)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_ip_reassembly_capability_get,
+	lib.ethdev.ip_reassembly_capability_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_ip_reassembly_conf_get,
+	lib.ethdev.ip_reassembly_conf_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_ip_reassembly_conf_set,
+	lib.ethdev.ip_reassembly_conf_set)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_buffer_split_get_supported_hdr_ptypes,
+	lib.ethdev.buffer_split_get_supported_hdr_ptypes)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_info_get,
+	lib.ethdev.cman_info_get)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_init,
+	lib.ethdev.cman_config_init)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_set,
+	lib.ethdev.cman_config_set)
+
+RTE_TRACE_POINT_REGISTER(rte_eth_trace_cman_config_get,
+	lib.ethdev.cman_config_get)
diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c
index 731ce7f27e..233de4e7f5 100644
--- a/lib/ethdev/rte_ethdev.c
+++ b/lib/ethdev/rte_ethdev.c
@@ -3626,6 +3626,8 @@  rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info *dev_info)
 
 	dev_info->dev_flags = &dev->data->dev_flags;
 
+	rte_ethdev_trace_info_get(port_id, dev_info);
+
 	return 0;
 }
 
@@ -3646,6 +3648,8 @@  rte_eth_dev_conf_get(uint16_t port_id, struct rte_eth_conf *dev_conf)
 
 	memcpy(dev_conf, &dev->data->dev_conf, sizeof(struct rte_eth_conf));
 
+	rte_ethdev_trace_conf_get(port_id, dev_conf);
+
 	return 0;
 }
 
@@ -3676,8 +3680,12 @@  rte_eth_dev_get_supported_ptypes(uint16_t port_id, uint32_t ptype_mask,
 
 	for (i = 0, j = 0; all_ptypes[i] != RTE_PTYPE_UNKNOWN; ++i)
 		if (all_ptypes[i] & ptype_mask) {
-			if (j < num)
+			if (j < num) {
 				ptypes[j] = all_ptypes[i];
+
+				rte_ethdev_trace_get_supported_ptypes(port_id,
+						j, num, ptypes[j]);
+			}
 			j++;
 		}
 
@@ -3755,6 +3763,10 @@  rte_eth_dev_set_ptypes(uint16_t port_id, uint32_t ptype_mask,
 		if (ptype_mask & all_ptypes[i]) {
 			if (j < num - 1) {
 				set_ptypes[j] = all_ptypes[i];
+
+				rte_ethdev_trace_set_ptypes(port_id, j, num,
+						set_ptypes[j]);
+
 				j++;
 				continue;
 			}
@@ -3796,6 +3808,8 @@  rte_eth_macaddrs_get(uint16_t port_id, struct rte_ether_addr *ma,
 	num = RTE_MIN(dev_info.max_mac_addrs, num);
 	memcpy(ma, dev->data->mac_addrs, num * sizeof(ma[0]));
 
+	rte_eth_trace_macaddrs_get(port_id, num);
+
 	return num;
 }
 
@@ -3816,6 +3830,8 @@  rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr)
 
 	rte_ether_addr_copy(&dev->data->mac_addrs[0], mac_addr);
 
+	rte_eth_trace_macaddr_get(port_id, mac_addr);
+
 	return 0;
 }
 
@@ -3834,6 +3850,9 @@  rte_eth_dev_get_mtu(uint16_t port_id, uint16_t *mtu)
 	}
 
 	*mtu = dev->data->mtu;
+
+	rte_ethdev_trace_get_mtu(port_id, *mtu);
+
 	return 0;
 }
 
@@ -3876,7 +3895,11 @@  rte_eth_dev_set_mtu(uint16_t port_id, uint16_t mtu)
 	if (ret == 0)
 		dev->data->mtu = mtu;
 
-	return eth_err(port_id, ret);
+	ret = eth_err(port_id, ret);
+
+	rte_ethdev_trace_set_mtu(port_id, mtu, ret);
+
+	return ret;
 }
 
 int
@@ -3919,7 +3942,11 @@  rte_eth_dev_vlan_filter(uint16_t port_id, uint16_t vlan_id, int on)
 			vfc->ids[vidx] &= ~RTE_BIT64(vbit);
 	}
 
-	return eth_err(port_id, ret);
+	ret = eth_err(port_id, ret);
+
+	rte_ethdev_trace_vlan_filter(port_id, vlan_id, on, ret);
+
+	return ret;
 }
 
 int
@@ -3940,6 +3967,8 @@  rte_eth_dev_set_vlan_strip_on_queue(uint16_t port_id, uint16_t rx_queue_id,
 		return -ENOTSUP;
 	(*dev->dev_ops->vlan_strip_queue_set)(dev, rx_queue_id, on);
 
+	rte_ethdev_trace_set_vlan_strip_on_queue(port_id, rx_queue_id, on);
+
 	return 0;
 }
 
@@ -3949,14 +3978,19 @@  rte_eth_dev_set_vlan_ether_type(uint16_t port_id,
 				uint16_t tpid)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->vlan_tpid_set == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->vlan_tpid_set)(dev, vlan_type,
-							       tpid));
+	ret = eth_err(port_id, (*dev->dev_ops->vlan_tpid_set)(dev, vlan_type,
+							      tpid));
+
+	rte_ethdev_trace_set_vlan_ether_type(port_id, vlan_type, tpid, ret);
+
+	return ret;
 }
 
 int
@@ -4048,7 +4082,11 @@  rte_eth_dev_set_vlan_offload(uint16_t port_id, int offload_mask)
 		dev->data->dev_conf.rxmode.offloads = orig_offloads;
 	}
 
-	return eth_err(port_id, ret);
+	ret = eth_err(port_id, ret);
+
+	rte_ethdev_trace_set_vlan_offload(port_id, offload_mask, ret);
+
+	return ret;
 }
 
 int
@@ -4074,6 +4112,8 @@  rte_eth_dev_get_vlan_offload(uint16_t port_id)
 	if (*dev_offloads & RTE_ETH_RX_OFFLOAD_QINQ_STRIP)
 		ret |= RTE_ETH_QINQ_STRIP_OFFLOAD;
 
+	rte_ethdev_trace_get_vlan_offload(port_id, ret);
+
 	return ret;
 }
 
@@ -4081,19 +4121,25 @@  int
 rte_eth_dev_set_vlan_pvid(uint16_t port_id, uint16_t pvid, int on)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->vlan_pvid_set == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->vlan_pvid_set)(dev, pvid, on));
+	ret = eth_err(port_id, (*dev->dev_ops->vlan_pvid_set)(dev, pvid, on));
+
+	rte_ethdev_trace_set_vlan_pvid(port_id, pvid, on, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_flow_ctrl_get(uint16_t port_id, struct rte_eth_fc_conf *fc_conf)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4108,13 +4154,18 @@  rte_eth_dev_flow_ctrl_get(uint16_t port_id, struct rte_eth_fc_conf *fc_conf)
 	if (*dev->dev_ops->flow_ctrl_get == NULL)
 		return -ENOTSUP;
 	memset(fc_conf, 0, sizeof(*fc_conf));
-	return eth_err(port_id, (*dev->dev_ops->flow_ctrl_get)(dev, fc_conf));
+	ret = eth_err(port_id, (*dev->dev_ops->flow_ctrl_get)(dev, fc_conf));
+
+	rte_ethdev_trace_flow_ctrl_get(port_id, fc_conf, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_flow_ctrl_set(uint16_t port_id, struct rte_eth_fc_conf *fc_conf)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4133,7 +4184,11 @@  rte_eth_dev_flow_ctrl_set(uint16_t port_id, struct rte_eth_fc_conf *fc_conf)
 
 	if (*dev->dev_ops->flow_ctrl_set == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->flow_ctrl_set)(dev, fc_conf));
+	ret = eth_err(port_id, (*dev->dev_ops->flow_ctrl_set)(dev, fc_conf));
+
+	rte_ethdev_trace_flow_ctrl_set(port_id, fc_conf, ret);
+
+	return ret;
 }
 
 int
@@ -4141,6 +4196,7 @@  rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id,
 				   struct rte_eth_pfc_conf *pfc_conf)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4158,9 +4214,15 @@  rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id,
 	}
 
 	/* High water, low water validation are device specific */
-	if  (*dev->dev_ops->priority_flow_ctrl_set)
-		return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set)
-					(dev, pfc_conf));
+	if  (*dev->dev_ops->priority_flow_ctrl_set) {
+		ret = eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set)
+				       (dev, pfc_conf));
+
+		rte_ethdev_trace_priority_flow_ctrl_set(port_id, pfc_conf, ret);
+
+		return ret;
+	}
+
 	return -ENOTSUP;
 }
 
@@ -4219,6 +4281,7 @@  rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id,
 		struct rte_eth_pfc_queue_info *pfc_queue_info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4229,9 +4292,15 @@  rte_eth_dev_priority_flow_ctrl_queue_info_get(uint16_t port_id,
 		return -EINVAL;
 	}
 
-	if (*dev->dev_ops->priority_flow_ctrl_queue_info_get)
-		return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_queue_info_get)
+	if (*dev->dev_ops->priority_flow_ctrl_queue_info_get) {
+		ret = eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_queue_info_get)
 			(dev, pfc_queue_info));
+
+		rte_ethdev_trace_priority_flow_ctrl_queue_info_get(port_id,
+							pfc_queue_info, ret);
+
+		return ret;
+	}
 	return -ENOTSUP;
 }
 
@@ -4300,10 +4369,17 @@  rte_eth_dev_priority_flow_ctrl_queue_configure(uint16_t port_id,
 			return ret;
 	}
 
-	if (*dev->dev_ops->priority_flow_ctrl_queue_config)
-		return eth_err(port_id,
-			       (*dev->dev_ops->priority_flow_ctrl_queue_config)(
-				dev, pfc_queue_conf));
+	if (*dev->dev_ops->priority_flow_ctrl_queue_config) {
+		ret = eth_err(port_id,
+			      (*dev->dev_ops->priority_flow_ctrl_queue_config)(
+			       dev, pfc_queue_conf));
+
+		rte_ethdev_trace_priority_flow_ctrl_queue_configure(port_id,
+							pfc_queue_conf, ret);
+
+		return ret;
+	}
+
 	return -ENOTSUP;
 }
 
@@ -4395,8 +4471,12 @@  rte_eth_dev_rss_reta_update(uint16_t port_id,
 
 	if (*dev->dev_ops->reta_update == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->reta_update)(dev, reta_conf,
-							     reta_size));
+	ret = eth_err(port_id, (*dev->dev_ops->reta_update)(dev, reta_conf,
+							    reta_size));
+
+	rte_ethdev_trace_rss_reta_update(port_id, reta_conf, reta_size, ret);
+
+	return ret;
 }
 
 int
@@ -4424,8 +4504,12 @@  rte_eth_dev_rss_reta_query(uint16_t port_id,
 
 	if (*dev->dev_ops->reta_query == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->reta_query)(dev, reta_conf,
-							    reta_size));
+	ret = eth_err(port_id, (*dev->dev_ops->reta_query)(dev, reta_conf,
+							   reta_size));
+
+	rte_ethdev_trace_rss_reta_query(port_id, reta_conf, reta_size, ret);
+
+	return ret;
 }
 
 int
@@ -4469,8 +4553,12 @@  rte_eth_dev_rss_hash_update(uint16_t port_id,
 
 	if (*dev->dev_ops->rss_hash_update == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->rss_hash_update)(dev,
-								 rss_conf));
+	ret = eth_err(port_id, (*dev->dev_ops->rss_hash_update)(dev,
+								rss_conf));
+
+	rte_ethdev_trace_rss_hash_update(port_id, rss_conf, ret);
+
+	return ret;
 }
 
 int
@@ -4478,6 +4566,7 @@  rte_eth_dev_rss_hash_conf_get(uint16_t port_id,
 			      struct rte_eth_rss_conf *rss_conf)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4491,8 +4580,12 @@  rte_eth_dev_rss_hash_conf_get(uint16_t port_id,
 
 	if (*dev->dev_ops->rss_hash_conf_get == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->rss_hash_conf_get)(dev,
-								   rss_conf));
+	ret = eth_err(port_id, (*dev->dev_ops->rss_hash_conf_get)(dev,
+								  rss_conf));
+
+	rte_ethdev_trace_rss_hash_conf_get(port_id, rss_conf, ret);
+
+	return ret;
 }
 
 int
@@ -4500,6 +4593,7 @@  rte_eth_dev_udp_tunnel_port_add(uint16_t port_id,
 				struct rte_eth_udp_tunnel *udp_tunnel)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4518,8 +4612,12 @@  rte_eth_dev_udp_tunnel_port_add(uint16_t port_id,
 
 	if (*dev->dev_ops->udp_tunnel_port_add == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_add)(dev,
+	ret = eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_add)(dev,
 								udp_tunnel));
+
+	rte_ethdev_trace_udp_tunnel_port_add(port_id, udp_tunnel, ret);
+
+	return ret;
 }
 
 int
@@ -4527,6 +4625,7 @@  rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id,
 				   struct rte_eth_udp_tunnel *udp_tunnel)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4545,34 +4644,48 @@  rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id,
 
 	if (*dev->dev_ops->udp_tunnel_port_del == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_del)(dev,
+	ret = eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_del)(dev,
 								udp_tunnel));
+
+	rte_ethdev_trace_udp_tunnel_port_delete(port_id, udp_tunnel, ret);
+
+	return ret;
 }
 
 int
 rte_eth_led_on(uint16_t port_id)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->dev_led_on == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->dev_led_on)(dev));
+	ret = eth_err(port_id, (*dev->dev_ops->dev_led_on)(dev));
+
+	rte_eth_trace_led_on(port_id, ret);
+
+	return ret;
 }
 
 int
 rte_eth_led_off(uint16_t port_id)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->dev_led_off == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->dev_led_off)(dev));
+	ret = eth_err(port_id, (*dev->dev_ops->dev_led_off)(dev));
+
+	rte_eth_trace_led_off(port_id, ret);
+
+	return ret;
 }
 
 int
@@ -4597,6 +4710,8 @@  rte_eth_fec_get_capability(uint16_t port_id,
 		return -ENOTSUP;
 	ret = (*dev->dev_ops->fec_get_capability)(dev, speed_fec_capa, num);
 
+	rte_eth_trace_fec_get_capability(port_id, speed_fec_capa, num, ret);
+
 	return ret;
 }
 
@@ -4604,6 +4719,7 @@  int
 rte_eth_fec_get(uint16_t port_id, uint32_t *fec_capa)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4617,20 +4733,29 @@  rte_eth_fec_get(uint16_t port_id, uint32_t *fec_capa)
 
 	if (*dev->dev_ops->fec_get == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->fec_get)(dev, fec_capa));
+	ret = eth_err(port_id, (*dev->dev_ops->fec_get)(dev, fec_capa));
+
+	rte_eth_trace_fec_get(port_id, fec_capa, ret);
+
+	return ret;
 }
 
 int
 rte_eth_fec_set(uint16_t port_id, uint32_t fec_capa)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->fec_set == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->fec_set)(dev, fec_capa));
+	ret = eth_err(port_id, (*dev->dev_ops->fec_set)(dev, fec_capa));
+
+	rte_eth_trace_fec_set(port_id, fec_capa, ret);
+
+	return ret;
 }
 
 /*
@@ -4718,7 +4843,11 @@  rte_eth_dev_mac_addr_add(uint16_t port_id, struct rte_ether_addr *addr,
 		dev->data->mac_pool_sel[index] |= RTE_BIT64(pool);
 	}
 
-	return eth_err(port_id, ret);
+	ret = eth_err(port_id, ret);
+
+	rte_ethdev_trace_mac_addr_add(port_id, addr, pool, ret);
+
+	return ret;
 }
 
 int
@@ -4758,6 +4887,8 @@  rte_eth_dev_mac_addr_remove(uint16_t port_id, struct rte_ether_addr *addr)
 	/* reset pool bitmap */
 	dev->data->mac_pool_sel[index] = 0;
 
+	rte_ethdev_trace_mac_addr_remove(port_id, addr);
+
 	return 0;
 }
 
@@ -4790,6 +4921,8 @@  rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct rte_ether_addr *addr)
 	/* Update default address in NIC data structure */
 	rte_ether_addr_copy(addr, &dev->data->mac_addrs[0]);
 
+	rte_ethdev_trace_default_mac_addr_set(port_id, addr);
+
 	return 0;
 }
 
@@ -4880,21 +5013,29 @@  rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct rte_ether_addr *addr,
 					&dev->data->hash_mac_addrs[index]);
 	}
 
-	return eth_err(port_id, ret);
+	ret = eth_err(port_id, ret);
+
+	rte_ethdev_trace_uc_hash_table_set(port_id, on, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_uc_all_hash_table_set(uint16_t port_id, uint8_t on)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->uc_all_hash_table_set == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->uc_all_hash_table_set)(dev,
-								       on));
+	ret = eth_err(port_id, (*dev->dev_ops->uc_all_hash_table_set)(dev, on));
+
+	rte_ethdev_trace_uc_all_hash_table_set(port_id, on, ret);
+
+	return ret;
 }
 
 int rte_eth_set_queue_rate_limit(uint16_t port_id, uint16_t queue_idx,
@@ -4930,14 +5071,19 @@  int rte_eth_set_queue_rate_limit(uint16_t port_id, uint16_t queue_idx,
 
 	if (*dev->dev_ops->set_queue_rate_limit == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->set_queue_rate_limit)(dev,
+	ret = eth_err(port_id, (*dev->dev_ops->set_queue_rate_limit)(dev,
 							queue_idx, tx_rate));
+
+	rte_eth_trace_set_queue_rate_limit(port_id, queue_idx, tx_rate, ret);
+
+	return ret;
 }
 
 int rte_eth_rx_avail_thresh_set(uint16_t port_id, uint16_t queue_id,
 			       uint8_t avail_thresh)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4957,14 +5103,19 @@  int rte_eth_rx_avail_thresh_set(uint16_t port_id, uint16_t queue_id,
 	}
 	if (*dev->dev_ops->rx_queue_avail_thresh_set == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_set)(dev,
+	ret = eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_set)(dev,
 							     queue_id, avail_thresh));
+
+	rte_eth_trace_rx_avail_thresh_set(port_id, queue_id, avail_thresh, ret);
+
+	return ret;
 }
 
 int rte_eth_rx_avail_thresh_query(uint16_t port_id, uint16_t *queue_id,
 				 uint8_t *avail_thresh)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -4976,8 +5127,12 @@  int rte_eth_rx_avail_thresh_query(uint16_t port_id, uint16_t *queue_id,
 
 	if (*dev->dev_ops->rx_queue_avail_thresh_query == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_query)(dev,
+	ret = eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_query)(dev,
 							     queue_id, avail_thresh));
+
+	rte_eth_trace_rx_avail_thresh_query(port_id, *queue_id, ret);
+
+	return ret;
 }
 
 RTE_INIT(eth_dev_init_fp_ops)
@@ -5059,6 +5214,10 @@  rte_eth_dev_callback_register(uint16_t port_id,
 	} while (++next_port <= last_port);
 
 	rte_spinlock_unlock(&eth_dev_cb_lock);
+
+	rte_ethdev_trace_callback_register(port_id, event, cb_fn, cb_arg,
+					   next_port, last_port);
+
 	return 0;
 }
 
@@ -5120,6 +5279,10 @@  rte_eth_dev_callback_unregister(uint16_t port_id,
 	} while (++next_port <= last_port);
 
 	rte_spinlock_unlock(&eth_dev_cb_lock);
+
+	rte_ethdev_trace_callback_unregister(port_id, event, cb_fn, cb_arg,
+					     ret);
+
 	return ret;
 }
 
@@ -5149,6 +5312,9 @@  rte_eth_dev_rx_intr_ctl(uint16_t port_id, int epfd, int op, void *data)
 	for (qid = 0; qid < dev->data->nb_rx_queues; qid++) {
 		vec = rte_intr_vec_list_index_get(intr_handle, qid);
 		rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data);
+
+		rte_ethdev_trace_rx_intr_ctl(port_id, qid, epfd, op, data, rc);
+
 		if (rc && rc != -EEXIST) {
 			RTE_ETHDEV_LOG(ERR,
 				"p %u q %u Rx ctl error op %d epfd %d vec %u\n",
@@ -5192,6 +5358,8 @@  rte_eth_dev_rx_intr_ctl_q_get_fd(uint16_t port_id, uint16_t queue_id)
 		(vec - RTE_INTR_VEC_RXTX_OFFSET) : vec;
 	fd = rte_intr_efds_index_get(intr_handle, efd_idx);
 
+	rte_ethdev_trace_rx_intr_ctl_q_get_fd(port_id, queue_id, fd);
+
 	return fd;
 }
 
@@ -5225,6 +5393,9 @@  rte_eth_dev_rx_intr_ctl_q(uint16_t port_id, uint16_t queue_id,
 
 	vec = rte_intr_vec_list_index_get(intr_handle, queue_id);
 	rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data);
+
+	rte_ethdev_trace_rx_intr_ctl_q(port_id, queue_id, epfd, op, data, rc);
+
 	if (rc && rc != -EEXIST) {
 		RTE_ETHDEV_LOG(ERR,
 			"p %u q %u Rx ctl error op %d epfd %d vec %u\n",
@@ -5251,7 +5422,11 @@  rte_eth_dev_rx_intr_enable(uint16_t port_id,
 
 	if (*dev->dev_ops->rx_queue_intr_enable == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->rx_queue_intr_enable)(dev, queue_id));
+	ret = eth_err(port_id, (*dev->dev_ops->rx_queue_intr_enable)(dev, queue_id));
+
+	rte_ethdev_trace_rx_intr_enable(port_id, queue_id, ret);
+
+	return ret;
 }
 
 int
@@ -5270,7 +5445,11 @@  rte_eth_dev_rx_intr_disable(uint16_t port_id,
 
 	if (*dev->dev_ops->rx_queue_intr_disable == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->rx_queue_intr_disable)(dev, queue_id));
+	ret = eth_err(port_id, (*dev->dev_ops->rx_queue_intr_disable)(dev, queue_id));
+
+	rte_ethdev_trace_rx_intr_disable(port_id, queue_id, ret);
+
+	return ret;
 }
 
 
@@ -5328,6 +5507,8 @@  rte_eth_add_rx_callback(uint16_t port_id, uint16_t queue_id,
 	}
 	rte_spinlock_unlock(&eth_dev_rx_cb_lock);
 
+	rte_eth_trace_add_rx_callback(port_id, queue_id, fn, user_param, cb);
+
 	return cb;
 }
 
@@ -5367,6 +5548,9 @@  rte_eth_add_first_rx_callback(uint16_t port_id, uint16_t queue_id,
 		cb, __ATOMIC_RELEASE);
 	rte_spinlock_unlock(&eth_dev_rx_cb_lock);
 
+	rte_eth_trace_add_first_rx_callback(port_id, queue_id, fn, user_param,
+					    cb);
+
 	return cb;
 }
 
@@ -5426,6 +5610,8 @@  rte_eth_add_tx_callback(uint16_t port_id, uint16_t queue_id,
 	}
 	rte_spinlock_unlock(&eth_dev_tx_cb_lock);
 
+	rte_eth_trace_add_tx_callback(port_id, queue_id, fn, user_param, cb);
+
 	return cb;
 }
 
@@ -5460,6 +5646,8 @@  rte_eth_remove_rx_callback(uint16_t port_id, uint16_t queue_id,
 	}
 	rte_spinlock_unlock(&eth_dev_rx_cb_lock);
 
+	rte_eth_trace_remove_rx_callback(port_id, queue_id, user_cb, ret);
+
 	return ret;
 }
 
@@ -5494,6 +5682,8 @@  rte_eth_remove_tx_callback(uint16_t port_id, uint16_t queue_id,
 	}
 	rte_spinlock_unlock(&eth_dev_tx_cb_lock);
 
+	rte_eth_trace_remove_tx_callback(port_id, queue_id, user_cb, ret);
+
 	return ret;
 }
 
@@ -5540,6 +5730,8 @@  rte_eth_rx_queue_info_get(uint16_t port_id, uint16_t queue_id,
 	dev->dev_ops->rxq_info_get(dev, queue_id, qinfo);
 	qinfo->queue_state = dev->data->rx_queue_state[queue_id];
 
+	rte_eth_trace_rx_queue_info_get(port_id, queue_id, qinfo);
+
 	return 0;
 }
 
@@ -5586,6 +5778,8 @@  rte_eth_tx_queue_info_get(uint16_t port_id, uint16_t queue_id,
 	dev->dev_ops->txq_info_get(dev, queue_id, qinfo);
 	qinfo->queue_state = dev->data->tx_queue_state[queue_id];
 
+	rte_eth_trace_tx_queue_info_get(port_id, queue_id, qinfo);
+
 	return 0;
 }
 
@@ -5594,6 +5788,7 @@  rte_eth_rx_burst_mode_get(uint16_t port_id, uint16_t queue_id,
 			  struct rte_eth_burst_mode *mode)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5613,8 +5808,12 @@  rte_eth_rx_burst_mode_get(uint16_t port_id, uint16_t queue_id,
 	if (*dev->dev_ops->rx_burst_mode_get == NULL)
 		return -ENOTSUP;
 	memset(mode, 0, sizeof(*mode));
-	return eth_err(port_id,
-		       dev->dev_ops->rx_burst_mode_get(dev, queue_id, mode));
+	ret = eth_err(port_id,
+		      dev->dev_ops->rx_burst_mode_get(dev, queue_id, mode));
+
+	rte_eth_trace_rx_burst_mode_get(port_id, queue_id, mode, ret);
+
+	return ret;
 }
 
 int
@@ -5622,6 +5821,7 @@  rte_eth_tx_burst_mode_get(uint16_t port_id, uint16_t queue_id,
 			  struct rte_eth_burst_mode *mode)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5641,8 +5841,12 @@  rte_eth_tx_burst_mode_get(uint16_t port_id, uint16_t queue_id,
 	if (*dev->dev_ops->tx_burst_mode_get == NULL)
 		return -ENOTSUP;
 	memset(mode, 0, sizeof(*mode));
-	return eth_err(port_id,
-		       dev->dev_ops->tx_burst_mode_get(dev, queue_id, mode));
+	ret = eth_err(port_id,
+		      dev->dev_ops->tx_burst_mode_get(dev, queue_id, mode));
+
+	rte_eth_trace_tx_burst_mode_get(port_id, queue_id, mode, ret);
+
+	return ret;
 }
 
 int
@@ -5650,6 +5854,7 @@  rte_eth_get_monitor_addr(uint16_t port_id, uint16_t queue_id,
 		struct rte_power_monitor_cond *pmc)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5668,8 +5873,12 @@  rte_eth_get_monitor_addr(uint16_t port_id, uint16_t queue_id,
 
 	if (*dev->dev_ops->get_monitor_addr == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id,
+	ret = eth_err(port_id,
 		dev->dev_ops->get_monitor_addr(dev->data->rx_queues[queue_id], pmc));
+
+	rte_eth_trace_get_monitor_addr(port_id, queue_id, pmc, ret);
+
+	return ret;
 }
 
 int
@@ -5678,40 +5887,56 @@  rte_eth_dev_set_mc_addr_list(uint16_t port_id,
 			     uint32_t nb_mc_addr)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->set_mc_addr_list == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, dev->dev_ops->set_mc_addr_list(dev,
+	ret = eth_err(port_id, dev->dev_ops->set_mc_addr_list(dev,
 						mc_addr_set, nb_mc_addr));
+
+	rte_ethdev_trace_set_mc_addr_list(port_id, mc_addr_set, nb_mc_addr,
+					  ret);
+
+	return ret;
 }
 
 int
 rte_eth_timesync_enable(uint16_t port_id)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->timesync_enable == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->timesync_enable)(dev));
+	ret = eth_err(port_id, (*dev->dev_ops->timesync_enable)(dev));
+
+	rte_eth_trace_timesync_enable(port_id, ret);
+
+	return ret;
 }
 
 int
 rte_eth_timesync_disable(uint16_t port_id)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->timesync_disable == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->timesync_disable)(dev));
+	ret = eth_err(port_id, (*dev->dev_ops->timesync_disable)(dev));
+
+	rte_eth_trace_timesync_disable(port_id, ret);
+
+	return ret;
 }
 
 int
@@ -5719,6 +5944,7 @@  rte_eth_timesync_read_rx_timestamp(uint16_t port_id, struct timespec *timestamp,
 				   uint32_t flags)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5732,8 +5958,14 @@  rte_eth_timesync_read_rx_timestamp(uint16_t port_id, struct timespec *timestamp,
 
 	if (*dev->dev_ops->timesync_read_rx_timestamp == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->timesync_read_rx_timestamp)
-				(dev, timestamp, flags));
+
+	ret = eth_err(port_id, (*dev->dev_ops->timesync_read_rx_timestamp)
+			       (dev, timestamp, flags));
+
+	rte_eth_trace_timesync_read_rx_timestamp(port_id, timestamp, flags,
+						 ret);
+
+	return ret;
 }
 
 int
@@ -5741,6 +5973,7 @@  rte_eth_timesync_read_tx_timestamp(uint16_t port_id,
 				   struct timespec *timestamp)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5754,27 +5987,39 @@  rte_eth_timesync_read_tx_timestamp(uint16_t port_id,
 
 	if (*dev->dev_ops->timesync_read_tx_timestamp == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->timesync_read_tx_timestamp)
-				(dev, timestamp));
+
+	ret = eth_err(port_id, (*dev->dev_ops->timesync_read_tx_timestamp)
+			       (dev, timestamp));
+
+	rte_eth_trace_timesync_read_tx_timestamp(port_id, timestamp, ret);
+
+	return ret;
+
 }
 
 int
 rte_eth_timesync_adjust_time(uint16_t port_id, int64_t delta)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->timesync_adjust_time == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->timesync_adjust_time)(dev, delta));
+	ret = eth_err(port_id, (*dev->dev_ops->timesync_adjust_time)(dev, delta));
+
+	rte_eth_trace_timesync_adjust_time(port_id, delta, ret);
+
+	return ret;
 }
 
 int
 rte_eth_timesync_read_time(uint16_t port_id, struct timespec *timestamp)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5788,14 +6033,19 @@  rte_eth_timesync_read_time(uint16_t port_id, struct timespec *timestamp)
 
 	if (*dev->dev_ops->timesync_read_time == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->timesync_read_time)(dev,
+	ret = eth_err(port_id, (*dev->dev_ops->timesync_read_time)(dev,
 								timestamp));
+
+	rte_eth_trace_timesync_read_time(port_id, timestamp, ret);
+
+	return ret;
 }
 
 int
 rte_eth_timesync_write_time(uint16_t port_id, const struct timespec *timestamp)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5809,14 +6059,19 @@  rte_eth_timesync_write_time(uint16_t port_id, const struct timespec *timestamp)
 
 	if (*dev->dev_ops->timesync_write_time == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->timesync_write_time)(dev,
+	ret = eth_err(port_id, (*dev->dev_ops->timesync_write_time)(dev,
 								timestamp));
+
+	rte_eth_trace_timesync_write_time(port_id, timestamp, ret);
+
+	return ret;
 }
 
 int
 rte_eth_read_clock(uint16_t port_id, uint64_t *clock)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5829,13 +6084,18 @@  rte_eth_read_clock(uint16_t port_id, uint64_t *clock)
 
 	if (*dev->dev_ops->read_clock == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->read_clock)(dev, clock));
+	ret = eth_err(port_id, (*dev->dev_ops->read_clock)(dev, clock));
+
+	rte_eth_trace_read_clock(port_id, clock, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_get_reg_info(uint16_t port_id, struct rte_dev_reg_info *info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5849,26 +6109,36 @@  rte_eth_dev_get_reg_info(uint16_t port_id, struct rte_dev_reg_info *info)
 
 	if (*dev->dev_ops->get_reg == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->get_reg)(dev, info));
+	ret = eth_err(port_id, (*dev->dev_ops->get_reg)(dev, info));
+
+	rte_ethdev_trace_get_reg_info(port_id, info, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_get_eeprom_length(uint16_t port_id)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->get_eeprom_length == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->get_eeprom_length)(dev));
+	ret = eth_err(port_id, (*dev->dev_ops->get_eeprom_length)(dev));
+
+	rte_ethdev_trace_get_eeprom_length(port_id, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_get_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5882,13 +6152,18 @@  rte_eth_dev_get_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info)
 
 	if (*dev->dev_ops->get_eeprom == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->get_eeprom)(dev, info));
+	ret = eth_err(port_id, (*dev->dev_ops->get_eeprom)(dev, info));
+
+	rte_ethdev_trace_get_eeprom(port_id, info, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_set_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5902,7 +6177,11 @@  rte_eth_dev_set_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info)
 
 	if (*dev->dev_ops->set_eeprom == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->set_eeprom)(dev, info));
+	ret = eth_err(port_id, (*dev->dev_ops->set_eeprom)(dev, info));
+
+	rte_ethdev_trace_set_eeprom(port_id, info, ret);
+
+	return ret;
 }
 
 int
@@ -5910,6 +6189,7 @@  rte_eth_dev_get_module_info(uint16_t port_id,
 			    struct rte_eth_dev_module_info *modinfo)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5923,7 +6203,11 @@  rte_eth_dev_get_module_info(uint16_t port_id,
 
 	if (*dev->dev_ops->get_module_info == NULL)
 		return -ENOTSUP;
-	return (*dev->dev_ops->get_module_info)(dev, modinfo);
+	ret = (*dev->dev_ops->get_module_info)(dev, modinfo);
+
+	rte_ethdev_trace_get_module_info(port_id, modinfo, ret);
+
+	return ret;
 }
 
 int
@@ -5931,6 +6215,7 @@  rte_eth_dev_get_module_eeprom(uint16_t port_id,
 			      struct rte_dev_eeprom_info *info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5958,7 +6243,11 @@  rte_eth_dev_get_module_eeprom(uint16_t port_id,
 
 	if (*dev->dev_ops->get_module_eeprom == NULL)
 		return -ENOTSUP;
-	return (*dev->dev_ops->get_module_eeprom)(dev, info);
+	ret = (*dev->dev_ops->get_module_eeprom)(dev, info);
+
+	rte_ethdev_trace_get_module_eeprom(port_id, info, ret);
+
+	return ret;
 }
 
 int
@@ -5966,6 +6255,7 @@  rte_eth_dev_get_dcb_info(uint16_t port_id,
 			     struct rte_eth_dcb_info *dcb_info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -5981,7 +6271,11 @@  rte_eth_dev_get_dcb_info(uint16_t port_id,
 
 	if (*dev->dev_ops->get_dcb_info == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->get_dcb_info)(dev, dcb_info));
+	ret = eth_err(port_id, (*dev->dev_ops->get_dcb_info)(dev, dcb_info));
+
+	rte_ethdev_trace_get_dcb_info(port_id, dcb_info, ret);
+
+	return ret;
 }
 
 static void
@@ -6017,6 +6311,8 @@  rte_eth_dev_adjust_nb_rx_tx_desc(uint16_t port_id,
 	if (nb_tx_desc != NULL)
 		eth_dev_adjust_nb_desc(nb_tx_desc, &dev_info.tx_desc_lim);
 
+	rte_ethdev_trace_adjust_nb_rx_tx_desc(port_id);
+
 	return 0;
 }
 
@@ -6025,6 +6321,7 @@  rte_eth_dev_hairpin_capability_get(uint16_t port_id,
 				   struct rte_eth_hairpin_cap *cap)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -6039,13 +6336,18 @@  rte_eth_dev_hairpin_capability_get(uint16_t port_id,
 	if (*dev->dev_ops->hairpin_cap_get == NULL)
 		return -ENOTSUP;
 	memset(cap, 0, sizeof(*cap));
-	return eth_err(port_id, (*dev->dev_ops->hairpin_cap_get)(dev, cap));
+	ret = eth_err(port_id, (*dev->dev_ops->hairpin_cap_get)(dev, cap));
+
+	rte_ethdev_trace_hairpin_capability_get(port_id, cap, ret);
+
+	return ret;
 }
 
 int
 rte_eth_dev_pool_ops_supported(uint16_t port_id, const char *pool)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -6060,7 +6362,11 @@  rte_eth_dev_pool_ops_supported(uint16_t port_id, const char *pool)
 	if (*dev->dev_ops->pool_ops_supported == NULL)
 		return 1; /* all pools are supported */
 
-	return (*dev->dev_ops->pool_ops_supported)(dev, pool);
+	ret = (*dev->dev_ops->pool_ops_supported)(dev, pool);
+
+	rte_ethdev_trace_pool_ops_supported(port_id, pool, ret);
+
+	return ret;
 }
 
 static int
@@ -6350,19 +6656,25 @@  rte_eth_representor_info_get(uint16_t port_id,
 			     struct rte_eth_representor_info *info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
 
 	if (*dev->dev_ops->representor_info_get == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id, (*dev->dev_ops->representor_info_get)(dev, info));
+	ret = eth_err(port_id, (*dev->dev_ops->representor_info_get)(dev, info));
+
+	rte_eth_trace_representor_info_get(port_id, info, ret);
+
+	return ret;
 }
 
 int
 rte_eth_rx_metadata_negotiate(uint16_t port_id, uint64_t *features)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -6381,8 +6693,12 @@  rte_eth_rx_metadata_negotiate(uint16_t port_id, uint64_t *features)
 
 	if (*dev->dev_ops->rx_metadata_negotiate == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id,
-		       (*dev->dev_ops->rx_metadata_negotiate)(dev, features));
+	ret = eth_err(port_id,
+		      (*dev->dev_ops->rx_metadata_negotiate)(dev, features));
+
+	rte_eth_trace_rx_metadata_negotiate(port_id, features, *features, ret);
+
+	return ret;
 }
 
 int
@@ -6390,6 +6706,7 @@  rte_eth_ip_reassembly_capability_get(uint16_t port_id,
 		struct rte_eth_ip_reassembly_params *reassembly_capa)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -6411,8 +6728,13 @@  rte_eth_ip_reassembly_capability_get(uint16_t port_id,
 		return -ENOTSUP;
 	memset(reassembly_capa, 0, sizeof(struct rte_eth_ip_reassembly_params));
 
-	return eth_err(port_id, (*dev->dev_ops->ip_reassembly_capability_get)
+	ret = eth_err(port_id, (*dev->dev_ops->ip_reassembly_capability_get)
 					(dev, reassembly_capa));
+
+	rte_eth_trace_ip_reassembly_capability_get(port_id, reassembly_capa,
+						   ret);
+
+	return ret;
 }
 
 int
@@ -6420,6 +6742,7 @@  rte_eth_ip_reassembly_conf_get(uint16_t port_id,
 		struct rte_eth_ip_reassembly_params *conf)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -6440,8 +6763,12 @@  rte_eth_ip_reassembly_conf_get(uint16_t port_id,
 	if (*dev->dev_ops->ip_reassembly_conf_get == NULL)
 		return -ENOTSUP;
 	memset(conf, 0, sizeof(struct rte_eth_ip_reassembly_params));
-	return eth_err(port_id,
-		       (*dev->dev_ops->ip_reassembly_conf_get)(dev, conf));
+	ret = eth_err(port_id,
+		      (*dev->dev_ops->ip_reassembly_conf_get)(dev, conf));
+
+	rte_eth_trace_ip_reassembly_conf_get(port_id, conf, ret);
+
+	return ret;
 }
 
 int
@@ -6449,6 +6776,7 @@  rte_eth_ip_reassembly_conf_set(uint16_t port_id,
 		const struct rte_eth_ip_reassembly_params *conf)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -6477,8 +6805,12 @@  rte_eth_ip_reassembly_conf_set(uint16_t port_id,
 
 	if (*dev->dev_ops->ip_reassembly_conf_set == NULL)
 		return -ENOTSUP;
-	return eth_err(port_id,
-		       (*dev->dev_ops->ip_reassembly_conf_set)(dev, conf));
+	ret = eth_err(port_id,
+		      (*dev->dev_ops->ip_reassembly_conf_set)(dev, conf));
+
+	rte_eth_trace_ip_reassembly_conf_set(port_id, conf, ret);
+
+	return ret;
 }
 
 int
@@ -6576,8 +6908,12 @@  rte_eth_buffer_split_get_supported_hdr_ptypes(uint16_t port_id, uint32_t *ptypes
 		return 0;
 
 	for (i = 0, j = 0; all_types[i] != RTE_PTYPE_UNKNOWN; ++i) {
-		if (j < num)
+		if (j < num) {
 			ptypes[j] = all_types[i];
+
+			rte_eth_trace_buffer_split_get_supported_hdr_ptypes(
+							port_id, j, ptypes[j]);
+		}
 		j++;
 	}
 
diff --git a/lib/ethdev/rte_ethdev_cman.c b/lib/ethdev/rte_ethdev_cman.c
index 4a1bdd7bd0..a9c4637521 100644
--- a/lib/ethdev/rte_ethdev_cman.c
+++ b/lib/ethdev/rte_ethdev_cman.c
@@ -8,12 +8,14 @@ 
 #include "rte_ethdev.h"
 #include "ethdev_driver.h"
 #include "ethdev_private.h"
+#include "ethdev_trace.h"
 
 /* Get congestion management information for a port */
 int
 rte_eth_cman_info_get(uint16_t port_id, struct rte_eth_cman_info *info)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -29,7 +31,11 @@  rte_eth_cman_info_get(uint16_t port_id, struct rte_eth_cman_info *info)
 	}
 
 	memset(info, 0, sizeof(struct rte_eth_cman_info));
-	return eth_err(port_id, (*dev->dev_ops->cman_info_get)(dev, info));
+	ret = eth_err(port_id, (*dev->dev_ops->cman_info_get)(dev, info));
+
+	rte_eth_trace_cman_info_get(port_id, info, ret);
+
+	return ret;
 }
 
 /* Initialize congestion management structure with default values */
@@ -37,6 +43,7 @@  int
 rte_eth_cman_config_init(uint16_t port_id, struct rte_eth_cman_config *config)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -52,7 +59,11 @@  rte_eth_cman_config_init(uint16_t port_id, struct rte_eth_cman_config *config)
 	}
 
 	memset(config, 0, sizeof(struct rte_eth_cman_config));
-	return eth_err(port_id, (*dev->dev_ops->cman_config_init)(dev, config));
+	ret = eth_err(port_id, (*dev->dev_ops->cman_config_init)(dev, config));
+
+	rte_eth_trace_cman_config_init(port_id, config, ret);
+
+	return ret;
 }
 
 /* Configure congestion management on a port */
@@ -60,6 +71,7 @@  int
 rte_eth_cman_config_set(uint16_t port_id, const struct rte_eth_cman_config *config)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -74,7 +86,11 @@  rte_eth_cman_config_set(uint16_t port_id, const struct rte_eth_cman_config *conf
 		return -ENOTSUP;
 	}
 
-	return eth_err(port_id, (*dev->dev_ops->cman_config_set)(dev, config));
+	ret = eth_err(port_id, (*dev->dev_ops->cman_config_set)(dev, config));
+
+	rte_eth_trace_cman_config_set(port_id, config, ret);
+
+	return ret;
 }
 
 /* Retrieve congestion management configuration of a port */
@@ -82,6 +98,7 @@  int
 rte_eth_cman_config_get(uint16_t port_id, struct rte_eth_cman_config *config)
 {
 	struct rte_eth_dev *dev;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 	dev = &rte_eth_devices[port_id];
@@ -97,5 +114,9 @@  rte_eth_cman_config_get(uint16_t port_id, struct rte_eth_cman_config *config)
 	}
 
 	memset(config, 0, sizeof(struct rte_eth_cman_config));
-	return eth_err(port_id, (*dev->dev_ops->cman_config_get)(dev, config));
+	ret = eth_err(port_id, (*dev->dev_ops->cman_config_get)(dev, config));
+
+	rte_eth_trace_cman_config_get(port_id, config, ret);
+
+	return ret;
 }