Commit 917d1e79 authored by Hamdan Igbaria's avatar Hamdan Igbaria Committed by Saeed Mahameed
Browse files

net/mlx5: DR, Change SWS usage to debug fs seq_file interface 



In current SWS debug dump mechanism we implement the seq_file interface,
but we only implement the 'show' callback to dump the whole steering DB
with a single call to this callback.

However, for large data size the seq_printf function will fail to
allocate a buffer with the adequate capacity to hold such data.

This patch solves this problem by utilizing the seq_file interface
mechanism in the following way:
 - when the user triggers a dump procedure, we will allocate a list of
   buffers that hold the whole data dump (in the start callback)
 - using the start, next, show and stop callbacks of the seq_file
   API we iterate through the list and dump the whole data

Signed-off-by: default avatarHamdan Igbaria <hamdani@nvidia.com>
Reviewed-by: default avatarYevgeny Kliteynik <kliteyn@nvidia.com>
Signed-off-by: default avatarSaeed Mahameed <saeedm@nvidia.com>
parent 507472ed

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_dbg.c

+600 −134
Original line number Diff line number Diff line
@@ -54,6 +54,107 @@ enum dr_dump_rec_type { 
	DR_DUMP_REC_TYPE_ACTION_MATCH_RANGE = 3425,

};



static struct mlx5dr_dbg_dump_buff *

mlx5dr_dbg_dump_data_init_new_buff(struct mlx5dr_dbg_dump_data *dump_data)

{

	struct mlx5dr_dbg_dump_buff *new_buff;



	new_buff = kzalloc(sizeof(*new_buff), GFP_KERNEL);

	if (!new_buff)

		return NULL;



	new_buff->buff = kvzalloc(MLX5DR_DEBUG_DUMP_BUFF_SIZE, GFP_KERNEL);

	if (!new_buff->buff) {

		kfree(new_buff);

		return NULL;

	}



	INIT_LIST_HEAD(&new_buff->node);

	list_add_tail(&new_buff->node, &dump_data->buff_list);



	return new_buff;

}



static struct mlx5dr_dbg_dump_data *

mlx5dr_dbg_create_dump_data(void)

{

	struct mlx5dr_dbg_dump_data *dump_data;



	dump_data = kzalloc(sizeof(*dump_data), GFP_KERNEL);

	if (!dump_data)

		return NULL;



	INIT_LIST_HEAD(&dump_data->buff_list);



	if (!mlx5dr_dbg_dump_data_init_new_buff(dump_data)) {

		kfree(dump_data);

		return NULL;

	}



	return dump_data;

}



static void

mlx5dr_dbg_destroy_dump_data(struct mlx5dr_dbg_dump_data *dump_data)

{

	struct mlx5dr_dbg_dump_buff *dump_buff, *tmp_buff;



	if (!dump_data)

		return;



	list_for_each_entry_safe(dump_buff, tmp_buff, &dump_data->buff_list, node) {

		kvfree(dump_buff->buff);

		list_del(&dump_buff->node);

		kfree(dump_buff);

	}



	kfree(dump_data);

}



static int

mlx5dr_dbg_dump_data_print(struct seq_file *file, char *str, u32 size)

{

	struct mlx5dr_domain *dmn = file->private;

	struct mlx5dr_dbg_dump_data *dump_data;

	struct mlx5dr_dbg_dump_buff *buff;

	u32 buff_capacity, write_size;

	int remain_size, ret;



	if (size >= MLX5DR_DEBUG_DUMP_BUFF_SIZE)

		return -EINVAL;



	dump_data = dmn->dump_info.dump_data;

	buff = list_last_entry(&dump_data->buff_list,

			       struct mlx5dr_dbg_dump_buff, node);



	buff_capacity = (MLX5DR_DEBUG_DUMP_BUFF_SIZE - 1) - buff->index;

	remain_size = buff_capacity - size;

	write_size = (remain_size > 0) ? size : buff_capacity;



	if (likely(write_size)) {

		ret = snprintf(buff->buff + buff->index, write_size + 1, "%s", str);

		if (ret < 0)

			return ret;



		buff->index += write_size;

	}



	if (remain_size < 0) {

		remain_size *= -1;

		buff = mlx5dr_dbg_dump_data_init_new_buff(dump_data);

		if (!buff)

			return -ENOMEM;



		ret = snprintf(buff->buff, remain_size + 1, "%s", str + write_size);

		if (ret < 0)

			return ret;



		buff->index += remain_size;

	}



	return 0;

}



void mlx5dr_dbg_tbl_add(struct mlx5dr_table *tbl)

{

	mutex_lock(&tbl->dmn->dump_info.dbg_mutex);
@@ -109,36 +210,68 @@ dr_dump_rule_action_mem(struct seq_file *file, const u64 rule_id, 
{

	struct mlx5dr_action *action = action_mem->action;

	const u64 action_id = DR_DBG_PTR_TO_ID(action);

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	u64 hit_tbl_ptr, miss_tbl_ptr;

	u32 hit_tbl_id, miss_tbl_id;

	int ret;



	switch (action->action_type) {

	case DR_ACTION_TYP_DROP:

		seq_printf(file, "%d,0x%llx,0x%llx\n",

			   DR_DUMP_REC_TYPE_ACTION_DROP, action_id, rule_id);

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx\n",

			       DR_DUMP_REC_TYPE_ACTION_DROP, action_id,

			       rule_id);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_FT:

		if (action->dest_tbl->is_fw_tbl)

			seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x\n",

			ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

				       "%d,0x%llx,0x%llx,0x%x,0x%x\n",

				       DR_DUMP_REC_TYPE_ACTION_FT, action_id,

				       rule_id, action->dest_tbl->fw_tbl.id,

				       -1);

		else

			seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%llx\n",

			ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

				       "%d,0x%llx,0x%llx,0x%x,0x%llx\n",

				       DR_DUMP_REC_TYPE_ACTION_FT, action_id,

				       rule_id, action->dest_tbl->tbl->table_id,

				       DR_DBG_PTR_TO_ID(action->dest_tbl->tbl));



		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_CTR:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_CTR, action_id, rule_id,

			       action->ctr->ctr_id + action->ctr->offset);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_TAG:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_TAG, action_id, rule_id,

			       action->flow_tag->flow_tag);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_MODIFY_HDR:

	{
@@ -150,83 +283,171 @@ dr_dump_rule_action_mem(struct seq_file *file, const u64 rule_id, 


		ptrn_arg = !action->rewrite->single_action_opt && ptrn && arg;



		seq_printf(file, "%d,0x%llx,0x%llx,0x%x,%d,0x%x,0x%x,0x%x",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x,%d,0x%x,0x%x,0x%x",

			       DR_DUMP_REC_TYPE_ACTION_MODIFY_HDR, action_id,

			       rule_id, action->rewrite->index,

			       action->rewrite->single_action_opt,

			       ptrn_arg ? action->rewrite->num_of_actions : 0,

			       ptrn_arg ? ptrn->index : 0,

			       ptrn_arg ? mlx5dr_arg_get_obj_id(arg) : 0);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;



		if (ptrn_arg) {

			for (i = 0; i < action->rewrite->num_of_actions; i++) {

				seq_printf(file, ",0x%016llx",

				ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

					       ",0x%016llx",

					       be64_to_cpu(((__be64 *)rewrite_data)[i]));

				if (ret < 0)

					return ret;



				ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

				if (ret)

					return ret;

			}

		}



		seq_puts(file, "\n");

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH, "\n");

		if (ret < 0)

			return ret;

		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	}

	case DR_ACTION_TYP_VPORT:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_VPORT, action_id, rule_id,

			       action->vport->caps->num);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_TNL_L2_TO_L2:

		seq_printf(file, "%d,0x%llx,0x%llx\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx\n",

			       DR_DUMP_REC_TYPE_ACTION_DECAP_L2, action_id,

			       rule_id);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_TNL_L3_TO_L2:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_DECAP_L3, action_id,

			       rule_id,

			       (action->rewrite->ptrn && action->rewrite->arg) ?

			       mlx5dr_arg_get_obj_id(action->rewrite->arg) :

			       action->rewrite->index);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_L2_TO_TNL_L2:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_ENCAP_L2, action_id,

			       rule_id, action->reformat->id);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_L2_TO_TNL_L3:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_ENCAP_L3, action_id,

			       rule_id, action->reformat->id);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_POP_VLAN:

		seq_printf(file, "%d,0x%llx,0x%llx\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx\n",

			       DR_DUMP_REC_TYPE_ACTION_POP_VLAN, action_id,

			       rule_id);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_PUSH_VLAN:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_PUSH_VLAN, action_id,

			       rule_id, action->push_vlan->vlan_hdr);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_INSERT_HDR:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_INSERT_HDR, action_id,

			       rule_id, action->reformat->id,

			       action->reformat->param_0,

			       action->reformat->param_1);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_REMOVE_HDR:

		seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x\n",

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_REMOVE_HDR, action_id,

			       rule_id, action->reformat->id,

			       action->reformat->param_0,

			       action->reformat->param_1);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_SAMPLER:

		seq_printf(file,

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x,0x%llx,0x%llx\n",

			   DR_DUMP_REC_TYPE_ACTION_SAMPLER, action_id, rule_id,

			   0, 0, action->sampler->sampler_id,

			       DR_DUMP_REC_TYPE_ACTION_SAMPLER, action_id,

			       rule_id, 0, 0, action->sampler->sampler_id,

			       action->sampler->rx_icm_addr,

			       action->sampler->tx_icm_addr);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	case DR_ACTION_TYP_RANGE:

		if (action->range->hit_tbl_action->dest_tbl->is_fw_tbl) {
@@ -247,10 +468,17 @@ dr_dump_rule_action_mem(struct seq_file *file, const u64 rule_id, 
				DR_DBG_PTR_TO_ID(action->range->miss_tbl_action->dest_tbl->tbl);

		}



		seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%llx,0x%x,0x%llx,0x%x\n",

			   DR_DUMP_REC_TYPE_ACTION_MATCH_RANGE, action_id, rule_id,

			   hit_tbl_id, hit_tbl_ptr, miss_tbl_id, miss_tbl_ptr,

			   action->range->definer_id);

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,0x%llx,0x%x,0x%llx,0x%x,0x%llx,0x%x\n",

			       DR_DUMP_REC_TYPE_ACTION_MATCH_RANGE, action_id,

			       rule_id, hit_tbl_id, hit_tbl_ptr, miss_tbl_id,

			       miss_tbl_ptr, action->range->definer_id);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

		break;

	default:

		return 0;
@@ -263,8 +491,10 @@ static int 
dr_dump_rule_mem(struct seq_file *file, struct mlx5dr_ste *ste,

		 bool is_rx, const u64 rule_id, u8 format_ver)

{

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	char hw_ste_dump[DR_HEX_SIZE];

	u32 mem_rec_type;

	int ret;



	if (format_ver == MLX5_STEERING_FORMAT_CONNECTX_5) {

		mem_rec_type = is_rx ? DR_DUMP_REC_TYPE_RULE_RX_ENTRY_V0 :
@@ -277,9 +507,16 @@ dr_dump_rule_mem(struct seq_file *file, struct mlx5dr_ste *ste, 
	dr_dump_hex_print(hw_ste_dump, (char *)mlx5dr_ste_get_hw_ste(ste),

			  DR_STE_SIZE_REDUCED);



	seq_printf(file, "%d,0x%llx,0x%llx,%s\n", mem_rec_type,

		   dr_dump_icm_to_idx(mlx5dr_ste_get_icm_addr(ste)), rule_id,

		   hw_ste_dump);

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%llx,%s\n", mem_rec_type,

		       dr_dump_icm_to_idx(mlx5dr_ste_get_icm_addr(ste)),

		       rule_id, hw_ste_dump);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	return 0;

}
@@ -309,6 +546,7 @@ static int dr_dump_rule(struct seq_file *file, struct mlx5dr_rule *rule) 
{

	struct mlx5dr_rule_action_member *action_mem;

	const u64 rule_id = DR_DBG_PTR_TO_ID(rule);

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	struct mlx5dr_rule_rx_tx *rx = &rule->rx;

	struct mlx5dr_rule_rx_tx *tx = &rule->tx;

	u8 format_ver;
@@ -316,8 +554,15 @@ static int dr_dump_rule(struct seq_file *file, struct mlx5dr_rule *rule) 


	format_ver = rule->matcher->tbl->dmn->info.caps.sw_format_ver;



	seq_printf(file, "%d,0x%llx,0x%llx\n", DR_DUMP_REC_TYPE_RULE, rule_id,

		   DR_DBG_PTR_TO_ID(rule->matcher));

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%llx\n", DR_DUMP_REC_TYPE_RULE,

		       rule_id, DR_DBG_PTR_TO_ID(rule->matcher));

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	if (rx->nic_matcher) {

		ret = dr_dump_rule_rx_tx(file, rx, true, rule_id, format_ver);
@@ -344,46 +589,94 @@ static int 
dr_dump_matcher_mask(struct seq_file *file, struct mlx5dr_match_param *mask,

		     u8 criteria, const u64 matcher_id)

{

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	char dump[DR_HEX_SIZE];

	int ret;



	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH, "%d,0x%llx,",

		       DR_DUMP_REC_TYPE_MATCHER_MASK, matcher_id);

	if (ret < 0)

		return ret;



	seq_printf(file, "%d,0x%llx,", DR_DUMP_REC_TYPE_MATCHER_MASK,

		   matcher_id);

	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	if (criteria & DR_MATCHER_CRITERIA_OUTER) {

		dr_dump_hex_print(dump, (char *)&mask->outer, sizeof(mask->outer));

		seq_printf(file, "%s,", dump);

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%s,", dump);

	} else {

		seq_puts(file, ",");

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH, ",");

	}



	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	if (criteria & DR_MATCHER_CRITERIA_INNER) {

		dr_dump_hex_print(dump, (char *)&mask->inner, sizeof(mask->inner));

		seq_printf(file, "%s,", dump);

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%s,", dump);

	} else {

		seq_puts(file, ",");

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH, ",");

	}



	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	if (criteria & DR_MATCHER_CRITERIA_MISC) {

		dr_dump_hex_print(dump, (char *)&mask->misc, sizeof(mask->misc));

		seq_printf(file, "%s,", dump);

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%s,", dump);

	} else {

		seq_puts(file, ",");

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH, ",");

	}



	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	if (criteria & DR_MATCHER_CRITERIA_MISC2) {

		dr_dump_hex_print(dump, (char *)&mask->misc2, sizeof(mask->misc2));

		seq_printf(file, "%s,", dump);

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%s,", dump);

	} else {

		seq_puts(file, ",");

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH, ",");

	}



	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	if (criteria & DR_MATCHER_CRITERIA_MISC3) {

		dr_dump_hex_print(dump, (char *)&mask->misc3, sizeof(mask->misc3));

		seq_printf(file, "%s\n", dump);

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%s\n", dump);

	} else {

		seq_puts(file, ",\n");

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH, ",\n");

	}



	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	return 0;

}
@@ -391,9 +684,19 @@ static int 
dr_dump_matcher_builder(struct seq_file *file, struct mlx5dr_ste_build *builder,

			u32 index, bool is_rx, const u64 matcher_id)

{

	seq_printf(file, "%d,0x%llx,%d,%d,0x%x\n",

		   DR_DUMP_REC_TYPE_MATCHER_BUILDER, matcher_id, index, is_rx,

		   builder->lu_type);

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	int ret;



	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,%d,%d,0x%x\n",

		       DR_DUMP_REC_TYPE_MATCHER_BUILDER, matcher_id, index,

		       is_rx, builder->lu_type);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	return 0;

}
@@ -403,6 +706,7 @@ dr_dump_matcher_rx_tx(struct seq_file *file, bool is_rx, 
		      struct mlx5dr_matcher_rx_tx *matcher_rx_tx,

		      const u64 matcher_id)

{

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	enum dr_dump_rec_type rec_type;

	u64 s_icm_addr, e_icm_addr;

	int i, ret;
@@ -412,12 +716,20 @@ dr_dump_matcher_rx_tx(struct seq_file *file, bool is_rx, 


	s_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(matcher_rx_tx->s_htbl->chunk);

	e_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(matcher_rx_tx->e_anchor->chunk);

	seq_printf(file, "%d,0x%llx,0x%llx,%d,0x%llx,0x%llx\n",

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%llx,%d,0x%llx,0x%llx\n",

		       rec_type, DR_DBG_PTR_TO_ID(matcher_rx_tx),

		       matcher_id, matcher_rx_tx->num_of_builders,

		       dr_dump_icm_to_idx(s_icm_addr),

		       dr_dump_icm_to_idx(e_icm_addr));



	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	for (i = 0; i < matcher_rx_tx->num_of_builders; i++) {

		ret = dr_dump_matcher_builder(file,

					      &matcher_rx_tx->ste_builder[i],
@@ -434,13 +746,22 @@ dr_dump_matcher(struct seq_file *file, struct mlx5dr_matcher *matcher) 
{

	struct mlx5dr_matcher_rx_tx *rx = &matcher->rx;

	struct mlx5dr_matcher_rx_tx *tx = &matcher->tx;

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	u64 matcher_id;

	int ret;



	matcher_id = DR_DBG_PTR_TO_ID(matcher);



	seq_printf(file, "%d,0x%llx,0x%llx,%d\n", DR_DUMP_REC_TYPE_MATCHER,

		   matcher_id, DR_DBG_PTR_TO_ID(matcher->tbl), matcher->prio);

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%llx,%d\n", DR_DUMP_REC_TYPE_MATCHER,

		       matcher_id, DR_DBG_PTR_TO_ID(matcher->tbl),

		       matcher->prio);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	ret = dr_dump_matcher_mask(file, &matcher->mask,

				   matcher->match_criteria, matcher_id);
@@ -486,15 +807,24 @@ dr_dump_table_rx_tx(struct seq_file *file, bool is_rx, 
		    struct mlx5dr_table_rx_tx *table_rx_tx,

		    const u64 table_id)

{

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	enum dr_dump_rec_type rec_type;

	u64 s_icm_addr;

	int ret;



	rec_type = is_rx ? DR_DUMP_REC_TYPE_TABLE_RX :

			   DR_DUMP_REC_TYPE_TABLE_TX;



	s_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(table_rx_tx->s_anchor->chunk);

	seq_printf(file, "%d,0x%llx,0x%llx\n", rec_type, table_id,

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%llx\n", rec_type, table_id,

		       dr_dump_icm_to_idx(s_icm_addr));

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	return 0;

}
@@ -503,11 +833,19 @@ static int dr_dump_table(struct seq_file *file, struct mlx5dr_table *table) 
{

	struct mlx5dr_table_rx_tx *rx = &table->rx;

	struct mlx5dr_table_rx_tx *tx = &table->tx;

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	int ret;



	seq_printf(file, "%d,0x%llx,0x%llx,%d,%d\n", DR_DUMP_REC_TYPE_TABLE,

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%llx,%d,%d\n", DR_DUMP_REC_TYPE_TABLE,

		       DR_DBG_PTR_TO_ID(table), DR_DBG_PTR_TO_ID(table->dmn),

		       table->table_type, table->level);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	if (rx->nic_dmn) {

		ret = dr_dump_table_rx_tx(file, true, rx,
@@ -546,46 +884,86 @@ static int 
dr_dump_send_ring(struct seq_file *file, struct mlx5dr_send_ring *ring,

		  const u64 domain_id)

{

	seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x\n",

		   DR_DUMP_REC_TYPE_DOMAIN_SEND_RING, DR_DBG_PTR_TO_ID(ring),

		   domain_id, ring->cq->mcq.cqn, ring->qp->qpn);

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	int ret;



	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%llx,0x%x,0x%x\n",

		       DR_DUMP_REC_TYPE_DOMAIN_SEND_RING,

		       DR_DBG_PTR_TO_ID(ring), domain_id,

		       ring->cq->mcq.cqn, ring->qp->qpn);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	return 0;

}



static int

static noinline_for_stack int

dr_dump_domain_info_flex_parser(struct seq_file *file,

				const char *flex_parser_name,

				const u8 flex_parser_value,

				const u64 domain_id)

{

	seq_printf(file, "%d,0x%llx,%s,0x%x\n",

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	int ret;



	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,%s,0x%x\n",

		       DR_DUMP_REC_TYPE_DOMAIN_INFO_FLEX_PARSER, domain_id,

		       flex_parser_name, flex_parser_value);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	return 0;

}



static int

static noinline_for_stack int

dr_dump_domain_info_caps(struct seq_file *file, struct mlx5dr_cmd_caps *caps,

			 const u64 domain_id)

{

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	struct mlx5dr_cmd_vport_cap *vport_caps;

	unsigned long i, vports_num;

	int ret;



	xa_for_each(&caps->vports.vports_caps_xa, vports_num, vport_caps)

		; /* count the number of vports in xarray */



	seq_printf(file, "%d,0x%llx,0x%x,0x%llx,0x%llx,0x%x,%lu,%d\n",

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,0x%x,0x%llx,0x%llx,0x%x,%lu,%d\n",

		       DR_DUMP_REC_TYPE_DOMAIN_INFO_CAPS, domain_id, caps->gvmi,

		       caps->nic_rx_drop_address, caps->nic_tx_drop_address,

		       caps->flex_protocols, vports_num, caps->eswitch_manager);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	xa_for_each(&caps->vports.vports_caps_xa, i, vport_caps) {

		vport_caps = xa_load(&caps->vports.vports_caps_xa, i);



		seq_printf(file, "%d,0x%llx,%lu,0x%x,0x%llx,0x%llx\n",

			   DR_DUMP_REC_TYPE_DOMAIN_INFO_VPORT, domain_id, i,

			   vport_caps->vport_gvmi, vport_caps->icm_address_rx,

		ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

			       "%d,0x%llx,%lu,0x%x,0x%llx,0x%llx\n",

			       DR_DUMP_REC_TYPE_DOMAIN_INFO_VPORT,

			       domain_id, i, vport_caps->vport_gvmi,

			       vport_caps->icm_address_rx,

			       vport_caps->icm_address_tx);

		if (ret < 0)

			return ret;



		ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

		if (ret)

			return ret;

	}

	return 0;

}
@@ -627,13 +1005,15 @@ dr_dump_domain_info(struct seq_file *file, struct mlx5dr_domain_info *info, 
	return 0;

}



static int

static noinline_for_stack int

dr_dump_domain(struct seq_file *file, struct mlx5dr_domain *dmn)

{

	char buff[MLX5DR_DEBUG_DUMP_BUFF_LENGTH];

	u64 domain_id = DR_DBG_PTR_TO_ID(dmn);

	int ret;



	seq_printf(file, "%d,0x%llx,%d,0%x,%d,%u.%u.%u,%s,%d,%u,%u,%u\n",

	ret = snprintf(buff, MLX5DR_DEBUG_DUMP_BUFF_LENGTH,

		       "%d,0x%llx,%d,0%x,%d,%u.%u.%u,%s,%d,%u,%u,%u\n",

		       DR_DUMP_REC_TYPE_DOMAIN,

		       domain_id, dmn->type, dmn->info.caps.gvmi,

		       dmn->info.supp_sw_steering,
@@ -645,6 +1025,12 @@ dr_dump_domain(struct seq_file *file, struct mlx5dr_domain *dmn) 
		       dmn->num_buddies[DR_ICM_TYPE_STE],

		       dmn->num_buddies[DR_ICM_TYPE_MODIFY_ACTION],

		       dmn->num_buddies[DR_ICM_TYPE_MODIFY_HDR_PTRN]);

	if (ret < 0)

		return ret;



	ret = mlx5dr_dbg_dump_data_print(file, buff, ret);

	if (ret)

		return ret;



	ret = dr_dump_domain_info(file, &dmn->info, domain_id);

	if (ret < 0)
@@ -683,11 +1069,91 @@ static int dr_dump_domain_all(struct seq_file *file, struct mlx5dr_domain *dmn) 
	return ret;

}



static int dr_dump_show(struct seq_file *file, void *priv)

static void *

dr_dump_start(struct seq_file *file, loff_t *pos)

{

	struct mlx5dr_domain *dmn = file->private;

	struct mlx5dr_dbg_dump_data *dump_data;



	if (atomic_read(&dmn->dump_info.state) != MLX5DR_DEBUG_DUMP_STATE_FREE) {

		mlx5_core_warn(dmn->mdev, "Dump already in progress\n");

		return ERR_PTR(-EBUSY);

	}



	atomic_set(&dmn->dump_info.state, MLX5DR_DEBUG_DUMP_STATE_IN_PROGRESS);

	dump_data = dmn->dump_info.dump_data;



	if (dump_data) {

		return seq_list_start(&dump_data->buff_list, *pos);

	} else if (*pos == 0) {

		dump_data = mlx5dr_dbg_create_dump_data();

		if (!dump_data)

			goto exit;



		dmn->dump_info.dump_data = dump_data;

		if (dr_dump_domain_all(file, dmn)) {

			mlx5dr_dbg_destroy_dump_data(dump_data);

			dmn->dump_info.dump_data = NULL;

			goto exit;

		}



		return seq_list_start(&dump_data->buff_list, *pos);

	}



exit:

	atomic_set(&dmn->dump_info.state, MLX5DR_DEBUG_DUMP_STATE_FREE);

	return NULL;

}



static void *

dr_dump_next(struct seq_file *file, void *v, loff_t *pos)

{

	struct mlx5dr_domain *dmn = file->private;

	struct mlx5dr_dbg_dump_data *dump_data;



	dump_data = dmn->dump_info.dump_data;



	return seq_list_next(v, &dump_data->buff_list, pos);

}



static void

dr_dump_stop(struct seq_file *file, void *v)

{

	struct mlx5dr_domain *dmn = file->private;

	struct mlx5dr_dbg_dump_data *dump_data;



	if (v && IS_ERR(v))

		return;



	if (!v) {

		dump_data = dmn->dump_info.dump_data;

		if (dump_data) {

			mlx5dr_dbg_destroy_dump_data(dump_data);

			dmn->dump_info.dump_data = NULL;

		}

	}



	atomic_set(&dmn->dump_info.state, MLX5DR_DEBUG_DUMP_STATE_FREE);

}



static int

dr_dump_show(struct seq_file *file, void *v)

{

	return dr_dump_domain_all(file, file->private);

	struct mlx5dr_dbg_dump_buff *entry;



	entry = list_entry(v, struct mlx5dr_dbg_dump_buff, node);

	seq_printf(file, "%s", entry->buff);



	return 0;

}

DEFINE_SHOW_ATTRIBUTE(dr_dump);



static const struct seq_operations dr_dump_sops = {

	.start	= dr_dump_start,

	.next	= dr_dump_next,

	.stop	= dr_dump_stop,

	.show	= dr_dump_show,

};

DEFINE_SEQ_ATTRIBUTE(dr_dump);



void mlx5dr_dbg_init_dump(struct mlx5dr_domain *dmn)

{

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_dbg.h

+20 −0

File changed.

Preview size limit exceeded, changes collapsed.