From ea186b01e4b2922effa05c2c3d8feeb413e63bd5 Mon Sep 17 00:00:00 2001 From: Junxian Huang Date: Sat, 26 Jul 2025 10:54:52 +0800 Subject: [PATCH] hikptool: Sync codes from master branch Sync codes from master branch, including ras support, coding bugfixes and some roce debug enhancement. Signed-off-by: Junxian Huang --- ...-support-for-exporting-black-box-dat.patch | 713 ++++++++++++++++++ ...-hikptool-Code-quality-reinforcement.patch | 465 ++++++++++++ ...dd-more-RoCE-registers-for-diagnosis.patch | 78 ++ ...l-roce-Support-to-print-u64-reg_data.patch | 198 +++++ ...d-roce_dfx_sta-cmd-for-RoCE-DFX-stat.patch | 248 ++++++ hikptool.spec | 16 +- 6 files changed, 1717 insertions(+), 1 deletion(-) create mode 100644 0100-hikptool-ras-Add-support-for-exporting-black-box-dat.patch create mode 100644 0101-hikptool-Code-quality-reinforcement.patch create mode 100644 0102-hikptool-Add-more-RoCE-registers-for-diagnosis.patch create mode 100644 0103-hikptool-roce-Support-to-print-u64-reg_data.patch create mode 100644 0104-hikptool-roce-Add-roce_dfx_sta-cmd-for-RoCE-DFX-stat.patch diff --git a/0100-hikptool-ras-Add-support-for-exporting-black-box-dat.patch b/0100-hikptool-ras-Add-support-for-exporting-black-box-dat.patch new file mode 100644 index 0000000..844c40b --- /dev/null +++ b/0100-hikptool-ras-Add-support-for-exporting-black-box-dat.patch @@ -0,0 +1,713 @@ +From 94d07c64e3cfda4ed0a41b8e27446973082c3379 Mon Sep 17 00:00:00 2001 +From: Bing Xia +Date: Wed, 12 Mar 2025 10:24:21 +0800 +Subject: [PATCH 100/104] hikptool: ras: Add support for exporting black box + data to file. + +1. support export black box data + e.g. hikptool bbox_export +2. support clear black box data + e.g. hikptool bbox_export -c + +Signed-off-by: Bing Xia xiabing14@h-partners.com +--- + CMakeLists.txt | 1 + + libhikptdev/include/hikptdev_plug.h | 3 +- + ras/ras_func/ras_common.h | 26 ++ + ras/ras_func/ras_dump_data.c | 389 ++++++++++++++++++++++++++++ + ras/ras_func/ras_dump_data.h | 88 +++++++ + ras/user_cmd/ras_cmd_dump.c | 99 +++++++ + ras/user_cmd/ras_tools_include.h | 25 ++ + 7 files changed, 630 insertions(+), 1 deletion(-) + create mode 100644 ras/ras_func/ras_common.h + create mode 100644 ras/ras_func/ras_dump_data.c + create mode 100644 ras/ras_func/ras_dump_data.h + create mode 100644 ras/user_cmd/ras_cmd_dump.c + create mode 100644 ras/user_cmd/ras_tools_include.h + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 07481e8..386cc28 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -48,6 +48,7 @@ file(GLOB_RECURSE HIKPTOOL_SRC + ${CMAKE_CURRENT_SOURCE_DIR}/socip/*.c + ${CMAKE_CURRENT_SOURCE_DIR}/hccs/*.c + ${CMAKE_CURRENT_SOURCE_DIR}/sdma/*.c ++ ${CMAKE_CURRENT_SOURCE_DIR}/ras/*.c + ${CMAKE_CURRENT_SOURCE_DIR}/tool_lib/*.c + ${CMAKE_CURRENT_SOURCE_DIR}/info_collect/*.c + ${CMAKE_CURRENT_SOURCE_DIR}/hikp_init_main.c +diff --git a/libhikptdev/include/hikptdev_plug.h b/libhikptdev/include/hikptdev_plug.h +index a24326a..ba9931f 100644 +--- a/libhikptdev/include/hikptdev_plug.h ++++ b/libhikptdev/include/hikptdev_plug.h +@@ -46,7 +46,8 @@ enum cmd_module_type { + UB_MOD = 11, + HCCS_MOD = 16, + SDMA_MOD = 17, +- CORE_RING_MOD = 18 ++ CORE_RING_MOD = 18, ++ RAS_MOD = 19 + }; + + void hikp_unlock(void); +diff --git a/ras/ras_func/ras_common.h b/ras/ras_func/ras_common.h +new file mode 100644 +index 0000000..0931ed9 +--- /dev/null ++++ b/ras/ras_func/ras_common.h +@@ -0,0 +1,26 @@ ++/* ++ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd. ++ * Hikptool is licensed under Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, ++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, ++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. ++ * ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#ifndef RAS_COMMON_H ++#define RAS_COMMON_H ++ ++enum { ++ RAS_DUMP, ++}; ++ ++enum ras_dump_cmd_type { ++ DUMP_DFX = 0, ++ DUMP_CLEAR, ++}; ++ ++#endif /* RAS_COMMON_H */ +diff --git a/ras/ras_func/ras_dump_data.c b/ras/ras_func/ras_dump_data.c +new file mode 100644 +index 0000000..7ab7d6b +--- /dev/null ++++ b/ras/ras_func/ras_dump_data.c +@@ -0,0 +1,389 @@ ++/* ++ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd. ++ * Hikptool is licensed under Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, ++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, ++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. ++ * ++ * See the Mulan PSL v2 for more details. ++ */ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "hikptdev_plug.h" ++#include "op_logs.h" ++#include "ras_common.h" ++#include "ras_dump_data.h" ++ ++static struct dfx_reg_dump_header header; ++ ++static int ras_get_data(uint32_t ras_cmd_type, struct ras_dump_req_para *req_data, ++ struct ras_rsp *ras_rsp_data) ++{ ++ uint32_t i; ++ struct hikp_cmd_ret *cmd_ret; ++ struct hikp_cmd_header req_header; ++ ++ hikp_cmd_init(&req_header, RAS_MOD, RAS_DUMP, ras_cmd_type); ++ cmd_ret = hikp_cmd_alloc(&req_header, req_data, RAS_REQ_DATA_LEN); ++ if (cmd_ret == NULL || cmd_ret->status != 0 || ++ cmd_ret->rsp_data_num > HIKP_RSP_ALL_DATA_MAX) { ++ printf("hikp_data_proc err\n"); ++ hikp_cmd_free(&cmd_ret); ++ return -1; ++ } ++ ++ ras_rsp_data->rsp_data_num = cmd_ret->rsp_data_num; ++ for (i = 0; i < ras_rsp_data->rsp_data_num; i++) { ++ ras_rsp_data->rsp_data[i] = cmd_ret->rsp_data[i]; ++ } ++ ++ hikp_cmd_free(&cmd_ret); ++ return 0; ++} ++ ++static void ras_print_time(struct file_seq *s) ++{ ++ time_t time_seconds = time(0); ++ struct tm timeinfo; ++ ++ (void)localtime_r(&time_seconds, &timeinfo); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "Time: %d-%d-%d %d:%d:%d\n", ++ timeinfo.tm_year + START_YEAR, timeinfo.tm_mon + 1, timeinfo.tm_mday, ++ timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec); ++} ++ ++static int ras_parse_data(uint32_t *reg_save, uint32_t reg_num, uint32_t reg_off, struct file_seq *s) ++{ ++ uint32_t i, j; ++ uint32_t cycle; ++ uint32_t reg_count, pkt_reg_num; ++ uint32_t off = reg_off; ++ ++ pkt_reg_num = header.pkt_length / sizeof(uint32_t); ++ cycle = reg_num / pkt_reg_num; ++ if (!cycle) ++ return -1; ++ ++ for (i = 0; i < cycle; i++) { ++ if ((off + pkt_reg_num) > HIKP_RSP_ALL_DATA_MAX) { ++ HIKP_ERROR_PRINT("off is %u, pkt_reg_num is %u,\ ++ reg_save index will exceed max reg_save length\n", ++ off, pkt_reg_num); ++ return -1; ++ } ++ ++ ras_print_time(s); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "Socket: 0X%hhX\t", ++ (reg_save[off + DFX_HEAD_INFO_DW0] >> DFX_HEAD_SKT_ID_OFF) & 0xff); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "DIE: 0X%hhX\t", ++ (reg_save[off + DFX_HEAD_INFO_DW0] >> DFX_HEAD_DIE_ID_OFF) & 0xff); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "Module: 0X%hhX\t", ++ (reg_save[off + DFX_HEAD_INFO_DW1] >> DFX_HEAD_MODULE_ID_OFF) & 0xff); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "Sub Module: 0X%hhX\t", ++ (reg_save[off + DFX_HEAD_INFO_DW1] >> DFX_HEAD_SUBMODULE_ID_OFF) & 0xff); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "SequenceNum: 0X%hhX\t", ++ (reg_save[off + DFX_HEAD_INFO_DW1] >> DFX_HEAD_SEQUENCE_NUM_OFF) & 0xff); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "Version: 0X%hhX\n", ++ (reg_save[off + DFX_HEAD_INFO_DW0] >> DFX_HEAD_VERSION_OFF) & 0xff); ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, ++ "----------------------- DFX REGISTER DUMP -----------------------\n"); ++ ++ reg_count = (reg_save[off + DFX_HEAD_INFO_DW1] >> DFX_HEAD_REG_COUNT_OFF) & 0xff; ++ if (!reg_count || reg_count > pkt_reg_num - DFX_REG_PACKET_HEAD_LEN) { ++ HIKP_ERROR_PRINT("reg_count is %u, value is not within the reasonable range(1-%u).\n", ++ reg_count, pkt_reg_num - DFX_REG_PACKET_HEAD_LEN); ++ return -1; ++ } ++ ++ for (j = 0; j < reg_count; j++) ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "0X%X\n", ++ reg_save[off + DFX_COMMON_MAIN_TEXT_BEGIN + j]); ++ ++ s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "\n"); ++ off += pkt_reg_num; ++ } ++ ++ return 0; ++} ++ ++static int ras_generate_file_name(struct file_seq *s) ++{ ++ time_t time_seconds = time(0); ++ struct tm timeinfo; ++ int ret; ++ ++ (void)localtime_r(&time_seconds, &timeinfo); ++ ret = snprintf(s->file_name, MAX_LOG_NAME_LEN, "rasdfx_%d_%d_%d_%d_%d_%d.log", ++ timeinfo.tm_year + START_YEAR, timeinfo.tm_mon + 1, timeinfo.tm_mday, ++ timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec); ++ if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) { ++ HIKP_ERROR_PRINT("generate file name failed, errno is %d\n", errno); ++ return -errno; ++ } ++ ++ return 0; ++} ++ ++static int ras_store_data(struct file_seq *s) ++{ ++ char file_path[OP_LOG_FILE_PATH_MAXLEN]; ++ size_t write_cnt; ++ FILE *fp; ++ int rc; ++ ++ rc = snprintf(file_path, sizeof(file_path), HIKP_LOG_DIR_PATH"%s", s->file_name); ++ if (rc < 0) { ++ HIKP_ERROR_PRINT("creat log file path fail.\n"); ++ return -EIO; ++ } ++ ++ fp = fopen(file_path, "a"); ++ if (fp == NULL) { ++ HIKP_ERROR_PRINT("open %s failed, errno is %d\n", file_path, errno); ++ return -errno; ++ } ++ ++ write_cnt = fwrite(s->buffer, 1, s->len, fp); ++ if (write_cnt != (uint32_t)s->len) { ++ fclose(fp); ++ HIKP_ERROR_PRINT("write %s failed, write cnt %zu.\n", file_path, write_cnt); ++ return -EAGAIN; ++ } ++ ++ printf("dump imp log completed, log file: %s.\n", file_path); ++ /* Set the file permission to 0440 */ ++ if (chmod(file_path, 0440)) ++ HIKP_ERROR_PRINT("chmod %s failed, errno is %d\n", file_path, errno); ++ ++ if (fclose(fp)) { ++ HIKP_ERROR_PRINT("close %s failed, errno is %d\n", file_path, errno); ++ return -errno; ++ } ++ ++ s->len = 0; ++ ++ return 0; ++} ++ ++static int file_seq_init(struct file_seq *s, uint32_t size) ++{ ++ if (!size) ++ return -1; ++ ++ s->buffer_size = size; ++ s->len = 0; ++ s->buffer = (char*)malloc(s->buffer_size); ++ if (!s->buffer) ++ return -1; ++ ++ return 0; ++} ++ ++static void file_seq_destroy(struct file_seq *s) ++{ ++ free(s->buffer); ++ s->buffer = NULL; ++} ++ ++static void ras_rsp_init(struct ras_rsp *ras_rsp_data) ++{ ++ ras_rsp_data->first_pkt_begin = 0; ++ ras_rsp_data->last_pkt_end = 0; ++ ras_rsp_data->rsp_data_num = 0; ++ ras_rsp_data->packet_buffer_len = 0; ++ ++ memset(ras_rsp_data->rsp_data, 0, sizeof(ras_rsp_data->rsp_data)); ++ memset(ras_rsp_data->packet_buffer, 0, sizeof(ras_rsp_data->packet_buffer)); ++} ++ ++static int parse_packet_buffer_data(struct ras_rsp *ras_rsp_data, ++ uint32_t pkt_reg_num, struct file_seq *s) ++{ ++ int ret; ++ ++ if (pkt_reg_num > MAX_DFX_PACKET_LEN) { ++ HIKP_ERROR_PRINT("pkt_reg_num is %u, has exceeded max packet length\n", pkt_reg_num); ++ return -1; ++ } ++ ++ if (ras_rsp_data->packet_buffer_len) { ++ uint32_t rest_pkt_length; ++ ++ rest_pkt_length = pkt_reg_num - ras_rsp_data->packet_buffer_len; ++ memcpy(ras_rsp_data->packet_buffer + ras_rsp_data->packet_buffer_len, ++ ras_rsp_data->rsp_data, rest_pkt_length); ++ ++ ras_rsp_data->first_pkt_begin = rest_pkt_length; ++ ret = ras_parse_data(ras_rsp_data->packet_buffer, pkt_reg_num, 0, s); ++ if (ret) { ++ HIKP_ERROR_PRINT("ras parse packet_buffer_data is failed\n"); ++ return ret; ++ } ++ } else { ++ ras_rsp_data->first_pkt_begin = 0; ++ } ++ ++ if (ras_rsp_data->first_pkt_begin == ras_rsp_data->rsp_data_num) ++ return 0; ++ ++ ras_rsp_data->packet_buffer_len = ++ (ras_rsp_data->rsp_data_num - ras_rsp_data->first_pkt_begin) % pkt_reg_num; ++ ras_rsp_data->last_pkt_end = ras_rsp_data->rsp_data_num - ras_rsp_data->packet_buffer_len - 1; ++ ras_rsp_data->rsp_data_num = ras_rsp_data->last_pkt_end - ras_rsp_data->first_pkt_begin + 1; ++ ++ memcpy(ras_rsp_data->packet_buffer, ras_rsp_data->rsp_data + ras_rsp_data->last_pkt_end + 1, ++ ras_rsp_data->packet_buffer_len); ++ ++ return 0; ++} ++ ++static int ras_dump_pkt_pre(struct ras_rsp *ras_rsp_data, struct file_seq *s) ++{ ++ int ret; ++ uint32_t reg_num, max_pkt_num, s_buffer_size; ++ ++ max_pkt_num = (HIKP_RSP_DATA_SIZE_MAX / header.pkt_length) + 1; ++ reg_num = header.pkt_length / sizeof(uint32_t) - DFX_REG_PACKET_HEAD_LEN; ++ s_buffer_size = max_pkt_num * ++ (reg_num * DFX_FILE_SINGLE_REG_SIZE + DFX_FILE_SINGLE_PACKET_HEAD_SIZE); ++ ras_rsp_data->rsp_data_num = 0; ++ ++ ret = file_seq_init(s, s_buffer_size); ++ if (ret) { ++ HIKP_ERROR_PRINT("malloc file_seq buffer is failed\n"); ++ return ret; ++ } ++ ++ ret = ras_generate_file_name(s); ++ if (ret) { ++ HIKP_ERROR_PRINT("ras generate file name is failed\n"); ++ file_seq_destroy(s); ++ return ret; ++ } ++ ++ return ret; ++} ++ ++static int ras_dump_packet(struct tool_ras_cmd *cmd, struct ras_rsp *ras_rsp_data, ++ struct ras_dump_req_para *req_data) ++{ ++ int ret; ++ uint32_t i, cmd_num; ++ bool has_printed_socid = false; ++ struct file_seq s; ++ ++ ret = ras_dump_pkt_pre(ras_rsp_data, &s); ++ if (ret) ++ return ret; ++ ++ cmd_num = (header.pkt_num * header.pkt_length + ++ HIKP_RSP_DATA_SIZE_MAX - 1) / HIKP_RSP_DATA_SIZE_MAX; ++ /* 0: get header info; 1-n: get packet data */ ++ for (i = 0; i < cmd_num; i++) { ++ req_data->cmd_id = i + 1; ++ ret = ras_get_data(cmd->ras_cmd_type, req_data, ras_rsp_data); ++ if (ret) { ++ HIKP_ERROR_PRINT("ras dump cmd %u is failed\n", req_data->cmd_id); ++ goto err_out_free; ++ } ++ ++ if (!has_printed_socid) { ++ s.len += snprintf(s.buffer + s.len, s.buffer_size - s.len, "SocID: %hhX\n", ++ (ras_rsp_data->rsp_data[DFX_HEAD_INFO_DW0] >> DFX_HEAD_SOC_ID_OFF) & 0xff); ++ s.len += snprintf(s.buffer + s.len, s.buffer_size - s.len, "\n"); ++ ++ has_printed_socid = true; ++ } ++ ++ ret = parse_packet_buffer_data(ras_rsp_data, header.pkt_length / sizeof(uint32_t), &s); ++ if (ret) { ++ HIKP_ERROR_PRINT("ras parse packet buffer data is failed\n"); ++ goto err_out_free; ++ } ++ ++ if (ras_rsp_data->first_pkt_begin != ras_rsp_data->rsp_data_num) { ++ ret = ras_parse_data(ras_rsp_data->rsp_data, ras_rsp_data->rsp_data_num, ++ ras_rsp_data->first_pkt_begin, &s); ++ if (ret) { ++ HIKP_ERROR_PRINT("ras parse rsp_data is failed\n"); ++ goto err_out_free; ++ } ++ } ++ ++ ret = ras_store_data(&s); ++ if (ret) { ++ HIKP_ERROR_PRINT("ras store rsp_data is failed\n"); ++ goto err_out_free; ++ } ++ } ++ ++err_out_free: ++ file_seq_destroy(&s); ++ return ret; ++} ++ ++int ras_data_dump(struct tool_ras_cmd *cmd) ++{ ++ int ret; ++ struct ras_rsp ras_rsp_data; ++ struct ras_dump_req_para req_data = {0}; ++ ++ if (cmd == NULL) ++ return -ENOSPC; ++ ++ ras_rsp_init(&ras_rsp_data); ++ ret = ras_get_data(cmd->ras_cmd_type, &req_data, &ras_rsp_data); ++ if (ret || (ras_rsp_data.rsp_data_num != DFX_REG_DUMP_HEADER_LEN)) { ++ HIKP_ERROR_PRINT("ras dump header is failed, rsp_data_num is %u\n", ++ ras_rsp_data.rsp_data_num); ++ return -1; ++ } ++ ++ if (!ras_rsp_data.rsp_data[HEAD_MAGIC]) { ++ HIKP_ERROR_PRINT("ras dfx dump is failed, data does not exist or has been cleared.\n"); ++ return -1; ++ } ++ ++ header.pkt_num = ras_rsp_data.rsp_data[PKT_NUM]; ++ header.pkt_length = ras_rsp_data.rsp_data[PKT_LENGTH]; ++ if (header.pkt_num == 0 || header.pkt_length < DFX_REG_PACKET_HEAD_LEN) { ++ HIKP_ERROR_PRINT("ras dfx dump is failed, pkt_num is %u, pkt_length is %u\n", ++ header.pkt_num, header.pkt_length); ++ return -1; ++ } ++ ++ ret = ras_dump_packet(cmd, &ras_rsp_data, &req_data); ++ if (ret) ++ HIKP_ERROR_PRINT("ras dump packet is failed\n"); ++ ++ return ret; ++} ++ ++int ras_data_clear(struct tool_ras_cmd *cmd) ++{ ++ int ret; ++ struct ras_rsp ras_rsp_data; ++ struct ras_dump_req_para req_data = { 0 }; ++ ++ if (cmd == NULL) ++ return -ENOSPC; ++ ++ ras_rsp_init(&ras_rsp_data); ++ ret = ras_get_data(cmd->ras_cmd_type, &req_data, &ras_rsp_data); ++ if (ret || ras_rsp_data.rsp_data_num != DFX_REG_DUMP_HEADER_LEN || ++ ras_rsp_data.rsp_data[HEAD_MAGIC] != DFX_DATA_IS_CLEARED) { ++ HIKP_ERROR_PRINT("ras dfx data clear is failed\n"); ++ return -1; ++ } ++ ++ return 0; ++} ++ +diff --git a/ras/ras_func/ras_dump_data.h b/ras/ras_func/ras_dump_data.h +new file mode 100644 +index 0000000..4c54ffe +--- /dev/null ++++ b/ras/ras_func/ras_dump_data.h +@@ -0,0 +1,88 @@ ++/* ++ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd. ++ * Hikptool is licensed under Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, ++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, ++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. ++ * ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#ifndef RAS_DUMP_REG_H ++#define RAS_DUMP_REG_H ++ ++#include "ras_tools_include.h" ++#include "hikpt_rciep.h" ++#include "tool_lib.h" ++ ++#define RAS_FILE_HEAD_BUF_LEN 256 ++#define MAX_DFX_PACKET_LEN 256 ++#define RAS_REQ_DATA_LEN 4 ++#define DFX_REG_DUMP_HEADER_LEN 6 ++#define DFX_REG_PACKET_HEAD_LEN 3 ++ ++struct dfx_reg_dump_header { ++ uint32_t head_magic; // 文件头的magic数字，特定值表示有效记录。 ++ uint32_t version; // 存储格式版本 ++ uint32_t cap_bits; // bit0表示是否开启crc，其余bit保留。 ++ uint32_t pkt_num; // packet数量 ++ uint32_t pkt_length; // 单个packet占用内存空间，单位bytes ++ uint32_t reserved; ++}; ++ ++struct file_seq { ++ char *buffer; ++ uint32_t buffer_size; ++ int len; ++ char file_name[MAX_LOG_NAME_LEN]; ++}; ++ ++struct ras_rsp { ++ uint32_t rsp_data[HIKP_RSP_ALL_DATA_MAX]; ++ uint32_t first_pkt_begin; ++ uint32_t last_pkt_end; ++ uint32_t rsp_data_num; ++ uint32_t packet_buffer[MAX_DFX_PACKET_LEN]; ++ uint32_t packet_buffer_len; ++}; ++ ++struct ras_dump_req_para { ++ uint32_t cmd_id; ++}; ++ ++enum reg_dump_header_index { ++ HEAD_MAGIC, ++ VERSION, ++ CAP_BITS, ++ PKT_NUM, ++ PKT_LENGTH ++}; ++ ++enum dfx_packet_index { ++ DFX_HEAD_INFO_DW0, ++ DFX_HEAD_INFO_DW1, ++ DFX_COMMON_MAIN_TEXT_BEGIN = 3 ++}; ++ ++#define DFX_HEAD_VERSION_OFF 0 ++#define DFX_HEAD_SOC_ID_OFF 8 ++#define DFX_HEAD_SKT_ID_OFF 16 ++#define DFX_HEAD_DIE_ID_OFF 24 ++#define DFX_HEAD_MODULE_ID_OFF 0 ++#define DFX_HEAD_SUBMODULE_ID_OFF 8 ++#define DFX_HEAD_SEQUENCE_NUM_OFF 16 ++#define DFX_HEAD_REG_COUNT_OFF 24 ++ ++#define DFX_DATA_IS_CLEARED 0 ++ ++#define DFX_FILE_SINGLE_PACKET_HEAD_SIZE 256 ++#define DFX_FILE_SINGLE_REG_SIZE 10 ++ ++ ++int ras_data_dump(struct tool_ras_cmd *cmd); ++int ras_data_clear(struct tool_ras_cmd *cmd); ++ ++#endif /* RAS_DUMP_REG_H */ +diff --git a/ras/user_cmd/ras_cmd_dump.c b/ras/user_cmd/ras_cmd_dump.c +new file mode 100644 +index 0000000..14fa0cf +--- /dev/null ++++ b/ras/user_cmd/ras_cmd_dump.c +@@ -0,0 +1,99 @@ ++/* ++ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd. ++ * Hikptool is licensed under Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, ++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, ++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. ++ * ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include ++#include "tool_cmd.h" ++#include "ras_tools_include.h" ++#include "ras_dump_data.h" ++ ++struct tool_ras_cmd g_ras_dump_cmd = { ++ .ras_cmd_type = DUMP_DFX, ++}; ++ ++static int ras_dump_help(struct major_cmd_ctrl *self, const char *argv) ++{ ++ HIKP_SET_USED(argv); ++ ++ printf("\n Usage: %s\n", self->cmd_ptr->name); ++ printf("\n %s\n", self->cmd_ptr->help_info); ++ printf("\n Options:\n\n"); ++ printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit\n"); ++ printf(" %s, %-25s %s\n", "-c", "--clear", "clearing memory dfx data\n"); ++ printf("\n"); ++ ++ return 0; ++} ++ ++static enum ras_dump_cmd_type ras_get_cmd_type(void) ++{ ++ return g_ras_dump_cmd.ras_cmd_type; ++} ++ ++static void ras_set_cmd_type(enum ras_dump_cmd_type type) ++{ ++ g_ras_dump_cmd.ras_cmd_type = type; ++} ++ ++static int ras_set_clear(struct major_cmd_ctrl *self, const char *argv) ++{ ++ HIKP_SET_USED(self); ++ HIKP_SET_USED(argv); ++ ++ ras_set_cmd_type(DUMP_CLEAR); ++ return 0; ++} ++ ++static int ras_dump_execute_process(void) ++{ ++ if (ras_get_cmd_type() == DUMP_DFX) ++ return ras_data_dump(&g_ras_dump_cmd); ++ else if (ras_get_cmd_type() == DUMP_CLEAR) ++ return ras_data_clear(&g_ras_dump_cmd); ++ else ++ return -EINVAL; ++} ++ ++static void ras_dump_execute(struct major_cmd_ctrl *self) ++{ ++ int ret; ++ const char *suc_msg[] = { ++ "ras dfx data dump success.", ++ "ras dfx data clear success." ++ }; ++ const char *err_msg[] = { ++ "ras dfx data dump error.", ++ "ras dfx data clear error." ++ }; ++ ++ ret = ras_dump_execute_process(); ++ if (ret == 0) { ++ printf("%s\n", suc_msg[ras_get_cmd_type()]); ++ } else { ++ snprintf(self->err_str, sizeof(self->err_str), "%s\n", ++ err_msg[ras_get_cmd_type()]); ++ self->err_no = ret; ++ } ++} ++ ++static void cmd_ras_dump_init(void) ++{ ++ struct major_cmd_ctrl *major_cmd = get_major_cmd(); ++ ++ major_cmd->option_count = 0; ++ major_cmd->execute = ras_dump_execute; ++ ++ cmd_option_register("-c", "--clear", false, ras_set_clear); ++ cmd_option_register("-h", "--help", false, ras_dump_help); ++} ++ ++HIKP_CMD_DECLARE("bbox_export", "export black box data to file", cmd_ras_dump_init); +diff --git a/ras/user_cmd/ras_tools_include.h b/ras/user_cmd/ras_tools_include.h +new file mode 100644 +index 0000000..19d9db2 +--- /dev/null ++++ b/ras/user_cmd/ras_tools_include.h +@@ -0,0 +1,25 @@ ++/* ++ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd. ++ * Hikptool is licensed under Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, ++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, ++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. ++ * ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#ifndef RAS_TOOLS_INCLUDE_H ++#define RAS_TOOLS_INCLUDE_H ++ ++#include "hikptdev_plug.h" ++#include "tool_lib.h" ++#include "ras_common.h" ++ ++struct tool_ras_cmd { ++ enum ras_dump_cmd_type ras_cmd_type; ++}; ++ ++#endif /* RAS_TOOLS_INCLUDE_H */ +-- +2.34.1.windows.1 + diff --git a/0101-hikptool-Code-quality-reinforcement.patch b/0101-hikptool-Code-quality-reinforcement.patch new file mode 100644 index 0000000..735269a --- /dev/null +++ b/0101-hikptool-Code-quality-reinforcement.patch @@ -0,0 +1,465 @@ +From c12043b0552a73a8b621c3a6265c4339fdd820f7 Mon Sep 17 00:00:00 2001 +From: veega2022 +Date: Tue, 10 Jun 2025 22:14:32 +0800 +Subject: [PATCH 101/104] hikptool: Code quality reinforcement + +Fixed some Code Security Review Comments +Including: Out-of-bounds access risk, +null pointer check + +Signed-off-by: veega2022 +--- + hccs/hikp_hccs.c | 2 +- + info_collect/hikp_collect_lib.c | 23 +++++++++++--- + net/nic/nic_dfx/hikp_nic_dfx.c | 16 ++++++---- + net/nic/nic_fd/hikp_nic_fd.c | 9 ++++++ + net/nic/nic_fd/hikp_nic_fd.h | 1 + + net/nic/nic_log/hikp_nic_log.c | 31 ++++++++++++++----- + .../roce_ext_common/hikp_roce_ext_common.c | 10 ++++++ + net/roce/roce_scc/hikp_roce_scc.c | 12 ++++--- + net/roce/roce_trp/hikp_roce_trp.c | 12 ++++--- + net/ub/ub_dfx/hikp_ub_dfx.c | 30 +++++++++++------- + net/ub/ub_ppp/hikp_unic_ppp.c | 13 +++++--- + pcie/func_lib/pcie_func/pcie_reg_dump.c | 7 ++++- + tool_lib/tool_cmd.c | 10 +++++- + 13 files changed, 128 insertions(+), 48 deletions(-) + +diff --git a/hccs/hikp_hccs.c b/hccs/hikp_hccs.c +index 5ef4222..d979aad 100644 +--- a/hccs/hikp_hccs.c ++++ b/hccs/hikp_hccs.c +@@ -106,7 +106,7 @@ static int hikp_hccs_cmd_send(struct hikp_cmd_header *req_header, + goto out; + } + if (cur_blk_size > buff_len || +- cur_blk_size > sizeof(struct hikp_hccs_rsp)) { ++ cur_blk_size > sizeof(rsp->rsp_data)) { + HIKP_ERROR_PRINT("The firmware data size (%" PRIu64 ") greater than " + "sw buffer(%zu) or hikp_hccs_rsp size(%zu).\n", + cur_blk_size, buff_len, sizeof(struct hikp_hccs_rsp)); +diff --git a/info_collect/hikp_collect_lib.c b/info_collect/hikp_collect_lib.c +index bada846..c4db315 100644 +--- a/info_collect/hikp_collect_lib.c ++++ b/info_collect/hikp_collect_lib.c +@@ -102,10 +102,15 @@ int hikp_create_save_path(const char *name) + { + char collect_name[MAX_LOG_NAME_LEN] = {0}; + time_t time_seconds = time(0); +- struct tm timeinfo; ++ struct tm timeinfo, *ptm; + int ret; + +- localtime_r(&time_seconds, &timeinfo); ++ ptm = localtime_r(&time_seconds, &timeinfo); ++ if (!ptm) { ++ HIKP_ERROR_PRINT("failed to get time info.\n"); ++ return -EINVAL; ++ } ++ + if (name != NULL) + (void)snprintf((char *)collect_name, MAX_LOG_NAME_LEN, + "collect_%s_%04d%02d%02d%02d%02d%02d", +@@ -201,12 +206,22 @@ static int hikp_collect_cmd_exec(const struct info_collect_cmd *cmd) + * process just like when it succeeds. + * */ + if (execvp(cmd->args[ARGS_IDX0], cmd->args) < 0) { +- HIKP_ERROR_PRINT("execvp failed: %d\n", errno); ++ HIKP_ERROR_PRINT("%s: execvp failed %d\n", cmd->args[ARGS_IDX0], errno); + exit(EXIT_FAILURE); + } + } else if (pid > 0) { + /* Parent process */ +- waitpid(pid, &status, 0); ++ if (waitpid(pid, &status, 0) < 0) { ++ HIKP_ERROR_PRINT("%s: waitpid() failure %d\n", ++ cmd->args[ARGS_IDX0], errno); ++ } else if (WIFEXITED((unsigned int)status) && ++ (WEXITSTATUS((unsigned int)status) != 0)) { ++ HIKP_ERROR_PRINT("%s: child exit %u\n", ++ cmd->args[ARGS_IDX0], ++ WEXITSTATUS((unsigned int)status)); ++ if (strcmp(cmd->args[ARGS_IDX0], "tar") == 0) ++ return -ECHILD; ++ } + } else { + HIKP_ERROR_PRINT("fork failed!\n"); + return -ECHILD; +diff --git a/net/nic/nic_dfx/hikp_nic_dfx.c b/net/nic/nic_dfx/hikp_nic_dfx.c +index d6114de..c7737a8 100644 +--- a/net/nic/nic_dfx/hikp_nic_dfx.c ++++ b/net/nic/nic_dfx/hikp_nic_dfx.c +@@ -406,9 +406,11 @@ static const struct dfx_type_name_parse g_dfx_ssu_name_parse[] = { + + void hikp_nic_dfx_set_cmd_para(int idx) + { +- g_dfx_param.sub_cmd_code = g_dfx_module_parse[idx].sub_cmd_code; +- g_dfx_param.module_idx = idx; +- g_dfx_param.flag |= MODULE_SET_FLAG; ++ if (idx < (int)HIKP_ARRAY_SIZE(g_dfx_module_parse)) { ++ g_dfx_param.sub_cmd_code = g_dfx_module_parse[idx].sub_cmd_code; ++ g_dfx_param.module_idx = idx; ++ g_dfx_param.flag |= MODULE_SET_FLAG; ++ } + } + + static void dfx_help_info(const struct major_cmd_ctrl *self) +@@ -458,6 +460,7 @@ static int hikp_nic_dfx_get_blk(struct hikp_cmd_ret **cmd_ret, + static int hikp_nic_get_first_blk_dfx(struct nic_dfx_rsp_head_t *rsp_head, uint32_t **reg_data, + uint32_t *max_dfx_size, uint32_t *version) + { ++ uint32_t reg_data_size = MAX_DFX_DATA_NUM * sizeof(uint32_t); + struct nic_dfx_rsp_t *dfx_rsp = NULL; + struct hikp_cmd_ret *cmd_ret = NULL; + int ret; +@@ -482,11 +485,12 @@ static int hikp_nic_get_first_blk_dfx(struct nic_dfx_rsp_head_t *rsp_head, uint3 + goto err_out; + } + +- if (rsp_head->cur_blk_size > *max_dfx_size) { ++ if (rsp_head->cur_blk_size > *max_dfx_size || rsp_head->cur_blk_size > reg_data_size) { + free(*reg_data); + *reg_data = NULL; +- HIKP_ERROR_PRINT("blk0 reg_data copy size error, data size: 0x%x, max size: 0x%x\n", +- rsp_head->cur_blk_size, *max_dfx_size); ++ HIKP_ERROR_PRINT("blk0 reg_data copy size error" ++ "data size: 0x%x, max size: 0x%x, reg_data_size: 0x%x\n", ++ rsp_head->cur_blk_size, *max_dfx_size, reg_data_size); + ret = -EINVAL; + goto err_out; + } +diff --git a/net/nic/nic_fd/hikp_nic_fd.c b/net/nic/nic_fd/hikp_nic_fd.c +index fb5f029..f581553 100644 +--- a/net/nic/nic_fd/hikp_nic_fd.c ++++ b/net/nic/nic_fd/hikp_nic_fd.c +@@ -841,6 +841,7 @@ static void hikp_nic_fd_data_free(union nic_fd_feature_info *fd_data) + static int hikp_nic_check_fd_hw_info(const struct nic_fd_hw_info *hw_info, + const struct fd_feature_cmd *fd_cmd) + { ++ uint16_t max_key_bytes, active_key_bits; + uint16_t i; + + if (strcmp(fd_cmd->feature_name, NIC_FD_RULES_NAME) == 0) { +@@ -863,6 +864,14 @@ static int hikp_nic_check_fd_hw_info(const struct nic_fd_hw_info *hw_info, + return -EOPNOTSUPP; + } + } ++ ++ max_key_bytes = hikp_nic_get_tcam_data_size(hw_info->key_max_bit); ++ active_key_bits = hikp_nic_get_max_key_len(hw_info->mode); ++ if (active_key_bits > max_key_bytes * HIKP_BITS_PER_BYTE) { ++ HIKP_ERROR_PRINT("The active tcam bits(%u) is more than the max key bits(%d).\n", ++ active_key_bits, max_key_bytes * HIKP_BITS_PER_BYTE); ++ return -EINVAL; ++ } + } else if (strcmp(fd_cmd->feature_name, NIC_FD_COUNTER_NAME) == 0) { + if (hw_info->alloc.stage_counter_num[NIC_FD_STAGE_1] == 0) { + HIKP_ERROR_PRINT("The stage1's counter number is zero.\n"); +diff --git a/net/nic/nic_fd/hikp_nic_fd.h b/net/nic/nic_fd/hikp_nic_fd.h +index ce363c9..98577ff 100644 +--- a/net/nic/nic_fd/hikp_nic_fd.h ++++ b/net/nic/nic_fd/hikp_nic_fd.h +@@ -113,6 +113,7 @@ struct nic_fd_key_cfg { + struct nic_fd_hw_info { + uint8_t mode; + uint8_t enable; ++ /* Max key bit width hwardware supported and unrelated to mode. */ + uint16_t key_max_bit; + struct nic_fd_alloc alloc; + struct nic_fd_key_cfg key_cfg[NIC_FD_STAGE_NUM]; +diff --git a/net/nic/nic_log/hikp_nic_log.c b/net/nic/nic_log/hikp_nic_log.c +index 0e2d556..4dd2721 100644 +--- a/net/nic/nic_log/hikp_nic_log.c ++++ b/net/nic/nic_log/hikp_nic_log.c +@@ -56,30 +56,45 @@ static int hikp_nic_write_data_to_file(uint8_t *data, uint32_t len) + size_t write_cnt; + FILE *fp = NULL; + int ret; ++ int rc; + + ret = generate_file_name(file_name, MAX_LOG_NAME_LEN, (const unsigned char *)"m7"); + if (ret < 0) + return ret; + +- ret = snprintf(g_log_path, sizeof(g_log_path), HIKP_LOG_DIR_PATH"%s", file_name); +- if (ret < 0) { ++ rc = snprintf(g_log_path, sizeof(g_log_path), HIKP_LOG_DIR_PATH"%s", file_name); ++ if (rc < 0) { + HIKP_ERROR_PRINT("creat log file path fail.\n"); + return -EIO; + } +- (void)remove((const char *)g_log_path); ++ ++ if (access((const char *)g_log_path, F_OK) == 0) { ++ if (remove((const char *)g_log_path)) { ++ HIKP_ERROR_PRINT("remove %s failed, errno is %d\n", g_log_path, errno); ++ return -errno; ++ } ++ } ++ + fp = fopen(g_log_path, "w+"); + if (fp == NULL) { + HIKP_ERROR_PRINT("open %s failed, errno is %d\n", g_log_path, errno); + return -errno; + } + write_cnt = fwrite(data, 1, len, fp); +- if (write_cnt != len) +- HIKP_ERROR_PRINT("write %s failed, write cnt %lu.\n", g_log_path, write_cnt); ++ if (write_cnt != len) { ++ HIKP_ERROR_PRINT("write %s failed, write cnt %zu.\n", g_log_path, write_cnt); ++ ret = -EAGAIN; ++ } + + printf("dump m7 log completed, log file: %s.\n", g_log_path); +- (void)chmod(g_log_path, 0440); +- (void)fclose(fp); +- return 0; ++ /* Set the file permission to 0440 */ ++ if (chmod(g_log_path, 0440)) ++ HIKP_ERROR_PRINT("chmod %s failed, errno is %d\n", g_log_path, errno); ++ ++ if (fclose(fp)) ++ HIKP_ERROR_PRINT("close %s failed, errno is %d\n", g_log_path, errno); ++ ++ return ret; + } + + static int hikp_nic_get_blk_log(struct hikp_cmd_ret **cmd_ret, uint32_t blk_id) +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index 9c844f4..fda2cf8 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -96,6 +96,7 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + struct reg_data *reg = &output->reg; + struct hikp_cmd_ret *cmd_ret; + uint32_t remain_block; ++ size_t reg_data_size; + size_t cur_size; + int ret; + +@@ -144,6 +145,15 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + } + + cur_size = res_head->cur_block_num * sizeof(uint32_t); ++ /*calculates the size of reg_data in the roce_ext_res_param structure.*/ ++ reg_data_size = cmd_ret->rsp_data_num * sizeof(uint32_t) - sizeof(struct roce_ext_head); ++ if (cur_size + reg_array_length * sizeof(uint32_t) > reg_data_size) { ++ printf("hikptool roce_%s cur size error, cur_size: %zu, reg_data_size: %zu.\n", ++ cmd_name, cur_size, reg_data_size); ++ ret = -EINVAL; ++ hikp_roce_ext_reg_data_free(reg); ++ goto get_data_error; ++ } + memcpy(reg->offset + block_id, + (uint32_t *)&roce_ext_res->reg_data, cur_size); + memcpy(reg->data + block_id, +diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c +index 67a2a1e..d7aaaa8 100644 +--- a/net/roce/roce_scc/hikp_roce_scc.c ++++ b/net/roce/roce_scc/hikp_roce_scc.c +@@ -169,9 +169,10 @@ static int hikp_roce_scc_get_total_data_num(struct roce_scc_head *res_head, + } + + cur_size = roce_scc_res->head.cur_block_num * sizeof(uint32_t); +- if (cur_size > max_size) { ++ if (cur_size > max_size || roce_scc_res->head.cur_block_num > ROCE_HIKP_SCC_REG_NUM) { + printf("hikptool roce_scc log data copy size error, " +- "data size: 0x%zx, max size: 0x%zx\n", cur_size, max_size); ++ "data size: 0x%zx, max size: 0x%zx, block_num: 0x%x\n", ++ cur_size, max_size, roce_scc_res->head.cur_block_num); + ret = -EINVAL; + goto get_data_error; + } +@@ -204,10 +205,11 @@ static int hikp_roce_scc_get_next_data(struct roce_scc_head *res_head, + + roce_scc_res = (struct roce_scc_res_param *)cmd_ret->rsp_data; + cur_size = roce_scc_res->head.cur_block_num * sizeof(uint32_t); +- if (cur_size > data_size) { +- hikp_cmd_free(&cmd_ret); ++ if (cur_size > data_size || roce_scc_res->head.cur_block_num > ROCE_HIKP_SCC_REG_NUM) { + printf("hikptool roce_scc next log data copy size error, " +- "data size: 0x%zx, max size: 0x%zx\n", cur_size, data_size); ++ "data size: 0x%zx, max size: 0x%zx, block_num: 0x%x\n", ++ cur_size, data_size, roce_scc_res->head.cur_block_num); ++ hikp_cmd_free(&cmd_ret); + return -EINVAL; + } + memcpy(*offset, roce_scc_res->reg_data.offset, cur_size); +diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c +index 67dfb8e..8b34409 100644 +--- a/net/roce/roce_trp/hikp_roce_trp.c ++++ b/net/roce/roce_trp/hikp_roce_trp.c +@@ -192,9 +192,10 @@ static int hikp_roce_trp_get_total_data_num(struct roce_trp_head *res_head, + } + + cur_size = roce_trp_res->head.cur_block_num * sizeof(uint32_t); +- if (cur_size > max_size) { ++ if (cur_size > max_size || roce_trp_res->head.cur_block_num > ROCE_HIKP_TRP_REG_NUM) { + printf("hikptool roce_trp log data copy size error, " +- "data size: 0x%zx, max size: 0x%zx\n", cur_size, max_size); ++ "data size: 0x%zx, max size: 0x%zx, block_num: 0x%x\n", ++ cur_size, max_size, roce_trp_res->head.cur_block_num); + hikp_roce_trp_reg_data_free(offset, data); + ret = -EINVAL; + goto get_data_error; +@@ -229,10 +230,11 @@ static int hikp_roce_trp_get_next_data(struct roce_trp_head *res_head, + roce_trp_res = (struct roce_trp_res_param *)cmd_ret->rsp_data; + cur_size = roce_trp_res->head.cur_block_num * sizeof(uint32_t); + +- if (cur_size > data_size) { +- hikp_cmd_free(&cmd_ret); ++ if (cur_size > data_size || roce_trp_res->head.cur_block_num > ROCE_HIKP_TRP_REG_NUM) { + printf("hikptool roce_trp next log data copy size error, " +- "data size: 0x%zx, max size: 0x%zx\n", cur_size, data_size); ++ "data size: 0x%zx, max size: 0x%zx, block_num: 0x%x\n", ++ cur_size, data_size, roce_trp_res->head.cur_block_num); ++ hikp_cmd_free(&cmd_ret); + return -EINVAL; + } + memcpy(*offset, roce_trp_res->reg_data.offset, cur_size); +diff --git a/net/ub/ub_dfx/hikp_ub_dfx.c b/net/ub/ub_dfx/hikp_ub_dfx.c +index 8a3e293..4929003 100644 +--- a/net/ub/ub_dfx/hikp_ub_dfx.c ++++ b/net/ub/ub_dfx/hikp_ub_dfx.c +@@ -104,6 +104,7 @@ static int hikp_ub_get_first_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t + struct ub_dfx_rsp *dfx_rsp = NULL; + struct hikp_cmd_ret *cmd_ret; + uint32_t rsp_data_size; ++ uint8_t cur_blk_size; + int ret; + + ret = hikp_ub_dfx_get_blk_data(&cmd_ret, 0, g_ub_dfx_param.sub_cmd_code); +@@ -127,18 +128,20 @@ static int hikp_ub_get_first_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t + } + + rsp_data_size = cmd_ret->rsp_data_num * REP_DATA_BLK_SIZE; +- if (rsp_data_size - sizeof(dfx_rsp->rsp_head) < rsp_head->cur_blk_size || +- *max_dfx_size < rsp_head->cur_blk_size) { +- HIKP_ERROR_PRINT("blk0 reg_data copy size error, rsp data size: %u, data size: %hhu, max size: %u\n", +- rsp_data_size, rsp_head->cur_blk_size, *max_dfx_size); ++ cur_blk_size = rsp_head->cur_blk_size; ++ if (rsp_data_size - sizeof(dfx_rsp->rsp_head) < cur_blk_size || ++ *max_dfx_size < cur_blk_size || cur_blk_size > sizeof(dfx_rsp->reg_data)) { ++ HIKP_ERROR_PRINT("blk0 reg_data copy size error, rsp data size: %u, " ++ "data size: %hhu, max size: %u\n", ++ rsp_data_size, cur_blk_size, *max_dfx_size); + free(*reg_data); + *reg_data = NULL; + ret = -EINVAL; + goto err_out; + } +- memcpy(*reg_data, dfx_rsp->reg_data, rsp_head->cur_blk_size); ++ memcpy(*reg_data, dfx_rsp->reg_data, cur_blk_size); + +- *max_dfx_size -= (uint32_t)rsp_head->cur_blk_size; ++ *max_dfx_size -= (uint32_t)cur_blk_size; + err_out: + hikp_cmd_free(&cmd_ret); + +@@ -151,6 +154,7 @@ static int hikp_ub_get_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t blk_id + struct ub_dfx_rsp *dfx_rsp = NULL; + struct hikp_cmd_ret *cmd_ret; + uint32_t rsp_data_size; ++ uint8_t cur_blk_size; + int ret; + + ret = hikp_ub_dfx_get_blk_data(&cmd_ret, blk_id, g_ub_dfx_param.sub_cmd_code); +@@ -160,15 +164,17 @@ static int hikp_ub_get_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t blk_id + dfx_rsp = (struct ub_dfx_rsp *)(cmd_ret->rsp_data); + *rsp_head = dfx_rsp->rsp_head; + rsp_data_size = cmd_ret->rsp_data_num * REP_DATA_BLK_SIZE; +- if (rsp_data_size - sizeof(dfx_rsp->rsp_head) < rsp_head->cur_blk_size || +- rsp_head->cur_blk_size > *max_dfx_size) { +- HIKP_ERROR_PRINT("blk%u reg_data copy size error, rsp data size: %u, data size: %hhu, max size: %u\n", +- blk_id, rsp_data_size, rsp_head->cur_blk_size, *max_dfx_size); ++ cur_blk_size = rsp_head->cur_blk_size; ++ if (rsp_data_size - sizeof(dfx_rsp->rsp_head) < cur_blk_size || ++ *max_dfx_size < cur_blk_size || cur_blk_size > sizeof(dfx_rsp->reg_data)) { ++ HIKP_ERROR_PRINT("blk%u reg_data copy size error, rsp data size: %u, " ++ "data size: %hhu, max size: %u\n", ++ blk_id, rsp_data_size, cur_blk_size, *max_dfx_size); + ret = -EINVAL; + goto err_out; + } +- memcpy(reg_data, dfx_rsp->reg_data, rsp_head->cur_blk_size); +- *max_dfx_size -= (uint32_t)rsp_head->cur_blk_size; ++ memcpy(reg_data, dfx_rsp->reg_data, cur_blk_size); ++ *max_dfx_size -= (uint32_t)cur_blk_size; + + err_out: + hikp_cmd_free(&cmd_ret); +diff --git a/net/ub/ub_ppp/hikp_unic_ppp.c b/net/ub/ub_ppp/hikp_unic_ppp.c +index 4c48e70..5f48ee6 100644 +--- a/net/ub/ub_ppp/hikp_unic_ppp.c ++++ b/net/ub/ub_ppp/hikp_unic_ppp.c +@@ -90,6 +90,7 @@ static int hikp_unic_ppp_get_blk(struct hikp_cmd_header *req_header, + struct hikp_cmd_ret *cmd_ret; + struct unic_ppp_rsp *rsp; + uint32_t rsp_data_size; ++ uint8_t cur_blk_size; + int ret = 0; + + cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); +@@ -100,14 +101,16 @@ static int hikp_unic_ppp_get_blk(struct hikp_cmd_header *req_header, + + rsp = (struct unic_ppp_rsp *)cmd_ret->rsp_data; + rsp_data_size = cmd_ret->rsp_data_num * REP_DATA_BLK_SIZE; +- if (rsp_data_size - sizeof(rsp->rsp_head) < rsp->rsp_head.cur_blk_size || +- buf_len < rsp->rsp_head.cur_blk_size) { +- HIKP_ERROR_PRINT("block context copy size error, data size: %u, buffer size: %zu, blk size: %hhu.\n", +- rsp_data_size, buf_len, rsp->rsp_head.cur_blk_size); ++ cur_blk_size = rsp->rsp_head.cur_blk_size; ++ if (rsp_data_size - sizeof(rsp->rsp_head) < cur_blk_size || ++ buf_len < cur_blk_size || cur_blk_size > sizeof(rsp->rsp_data)) { ++ HIKP_ERROR_PRINT("block context copy size error, data size: %u, " ++ "buffer size: %zu, blk size: %hhu.\n", ++ rsp_data_size, buf_len, cur_blk_size); + ret = -EINVAL; + goto out; + } +- memcpy(buf, rsp->rsp_data, rsp->rsp_head.cur_blk_size); ++ memcpy(buf, rsp->rsp_data, cur_blk_size); + memcpy(rsp_head, &rsp->rsp_head, sizeof(struct unic_ppp_rsp_head)); + + out: +diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c +index ba6641e..f7ec2b3 100644 +--- a/pcie/func_lib/pcie_func/pcie_reg_dump.c ++++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c +@@ -397,7 +397,12 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) + memset(dumpreg_log_file, 0, sizeof(dumpreg_log_file)); + (void)strncpy((char *)dumpreg_log_file, file_name, MAX_LOG_NAME_LEN + 1); + +- (void)remove((const char *)file_name); ++ if (access((const char *)file_name, F_OK) == 0) { ++ if (remove((const char *)file_name)) { ++ Err("remove %s failed, errno is %d\n", file_name, errno); ++ return -errno; ++ } ++ } + /* Add write permission to the file */ + fd_file = fopen(file_name, "w+"); + if (fd_file == NULL) { +diff --git a/tool_lib/tool_cmd.c b/tool_lib/tool_cmd.c +index db54f0f..409bb5d 100644 +--- a/tool_lib/tool_cmd.c ++++ b/tool_lib/tool_cmd.c +@@ -206,7 +206,15 @@ void command_parse_and_excute(const int argc, const char **argv) + snprintf(major_cmd->err_str, sizeof(major_cmd->err_str), "locking failed."); + goto PARSE_OUT; + } +- major_cmd->execute(major_cmd); ++ ++ if (major_cmd->execute) { ++ major_cmd->execute(major_cmd); ++ } else { ++ major_cmd->err_no = -EPERM; ++ snprintf(major_cmd->err_str, sizeof(major_cmd->err_str), ++ "Command execute is null."); ++ } ++ + tool_unlock(&lock_fd, UDA_FLOCK_BLOCK); + PARSE_OUT: + if (major_cmd->err_no) +-- +2.34.1.windows.1 + diff --git a/0102-hikptool-Add-more-RoCE-registers-for-diagnosis.patch b/0102-hikptool-Add-more-RoCE-registers-for-diagnosis.patch new file mode 100644 index 0000000..a4849b0 --- /dev/null +++ b/0102-hikptool-Add-more-RoCE-registers-for-diagnosis.patch @@ -0,0 +1,78 @@ +From cc04a0a123a43636b49feaf02af04a6f15625130 Mon Sep 17 00:00:00 2001 +From: veega2022 +Date: Thu, 12 Jun 2025 21:37:47 +0800 +Subject: [PATCH 102/104] hikptool: Add more RoCE registers for diagnosis + +Add more RoCE registers for diagnosis. + +Signed-off-by: Junxian Huang +--- + net/roce/roce_pkt/hikp_roce_pkt.c | 3 +++ + net/roce/roce_scc/hikp_roce_scc.c | 1 + + net/roce/roce_timer/hikp_roce_timer.c | 8 ++++++++ + net/roce/roce_tsp/hikp_roce_tsp.c | 4 ++++ + 4 files changed, 16 insertions(+) + +diff --git a/net/roce/roce_pkt/hikp_roce_pkt.c b/net/roce/roce_pkt/hikp_roce_pkt.c +index 1538788..4d1a377 100644 +--- a/net/roce/roce_pkt/hikp_roce_pkt.c ++++ b/net/roce/roce_pkt/hikp_roce_pkt.c +@@ -90,6 +90,9 @@ static const char *g_pkt_reg_name[] = { + "ROCEE_CNP_PKT_TX_CNT", + "TRP_GET_MPT_ERR_PKT_CNT", + "TRP_GET_IRRL_ERR_PKT_CNT", ++ "GEN_AC_CQ_CQE_CNT", ++ "GEN_AC_CQ_POE_CNT", ++ "GEN_AC_CQ_NOTIFY_CNT", + }; + + static void hikp_roce_pkt_print(uint32_t total_block_num, +diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c +index d7aaaa8..428beda 100644 +--- a/net/roce/roce_scc/hikp_roce_scc.c ++++ b/net/roce/roce_scc/hikp_roce_scc.c +@@ -265,6 +265,7 @@ static const char *g_scc_common_reg_name[] = { + "SCC_INPUT_REQ_CNT", + "SCC_OUTPUT_RSP_CNT", + "SCC_INOUT_CNT_CFG", ++ "SCC_CUR_PROCESS_TIME", + }; + + static const char *g_scc_dcqcn_reg_name[] = { +diff --git a/net/roce/roce_timer/hikp_roce_timer.c b/net/roce/roce_timer/hikp_roce_timer.c +index 927d8a6..38b63ac 100644 +--- a/net/roce/roce_timer/hikp_roce_timer.c ++++ b/net/roce/roce_timer/hikp_roce_timer.c +@@ -69,6 +69,14 @@ static const char *g_timer_qpc_reg_name[] = { + "ROCEE_TIMER_QPC_ECC_ERR", + "ROCEE_TIMER_QPC_ECC_ERR_INFO", + "START_TYPE_ERR_CNT", ++ "FIFO_CNT_TH0", ++ "FIFO_CNT_TH1", ++ "FIFO_CNT_TH2", ++ "FIFO_CNT_TH3", ++ "FIFO_CNT_TH4", ++ "FIFO_CNT_TH5", ++ "FIFO_CNT_TH6", ++ "FIFO_CNT_TH7", + }; + + static const char *g_timer_cqc_reg_name[] = { +diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c +index 5fe2104..671288d 100644 +--- a/net/roce/roce_tsp/hikp_roce_tsp.c ++++ b/net/roce/roce_tsp/hikp_roce_tsp.c +@@ -167,6 +167,10 @@ static const char *g_tsp_common_reg_name[] = { + "TSP_INDRECT_RD_CTRL", + "TSP_INDRECT_RD_DATA", + "ROCEE_TSP_OVF", ++ "ROCE_TPP_DATA_FIFO_ST", ++ "ROCE_TPP_DATA_ALM", ++ "ROCE_TPP_DATA_STA0", ++ "ROCE_TPP_DATA_STA1", + }; + + static const char *g_tsp_tdp_reg_name[] = { +-- +2.34.1.windows.1 + diff --git a/0103-hikptool-roce-Support-to-print-u64-reg_data.patch b/0103-hikptool-roce-Support-to-print-u64-reg_data.patch new file mode 100644 index 0000000..3222345 --- /dev/null +++ b/0103-hikptool-roce-Support-to-print-u64-reg_data.patch @@ -0,0 +1,198 @@ +From 1c76f34ff0cb1c0d552cc8bb5aa8ca19d2741692 Mon Sep 17 00:00:00 2001 +From: wenglianfa +Date: Thu, 3 Jul 2025 17:25:08 +0800 +Subject: [PATCH 103/104] hikptool/roce: Support to print u64 reg_data + +Support to print u64 reg_data. + +Signed-off-by: wenglianfa +--- + .../roce_ext_common/hikp_roce_ext_common.c | 61 +++++++++++++------ + .../roce_ext_common/hikp_roce_ext_common.h | 26 +++++++- + 2 files changed, 66 insertions(+), 21 deletions(-) + +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index fda2cf8..c225ec8 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -12,6 +12,7 @@ + */ + + #include "hikp_roce_ext_common.h" ++#include + + static void hikp_roce_ext_reg_data_free(struct reg_data *reg) + { +@@ -95,9 +96,11 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + struct roce_ext_res_param *roce_ext_res; + struct reg_data *reg = &output->reg; + struct hikp_cmd_ret *cmd_ret; ++ size_t reg_data_offset; + uint32_t remain_block; +- size_t reg_data_size; +- size_t cur_size; ++ size_t offset_size; ++ size_t data_size; ++ void *dst_data; + int ret; + + /* reg_array_length greater than or equal to 0 ensures that cmd_name +@@ -117,6 +120,7 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + + if (block_id == 0) { + res_head->total_block_num = roce_ext_res->head.total_block_num; ++ res_head->flags = roce_ext_res->head.flags; + if (!res_head->total_block_num) { + printf("hikptool roce_%s total_block_num error!\n", + cmd_name); +@@ -124,10 +128,12 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + goto get_data_error; + } + reg->offset = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t)); +- reg->data = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t)); ++ output->per_val_size = res_head->flags & ROCE_HIKP_DATA_U64_FLAG ? ++ sizeof(uint64_t) : sizeof(uint32_t); ++ reg->data = calloc(res_head->total_block_num, output->per_val_size); + if ((reg->offset == NULL) || (reg->data == NULL)) { +- printf("hikptool roce_%s alloc log memmory 0x%zx failed!\n", +- cmd_name, res_head->total_block_num * sizeof(uint32_t)); ++ printf("hikptool roce_%s alloc log memmory failed!\n", ++ cmd_name); + ret = -ENOMEM; + hikp_roce_ext_reg_data_free(reg); + goto get_data_error; +@@ -144,20 +150,32 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + goto get_data_error; + } + +- cur_size = res_head->cur_block_num * sizeof(uint32_t); +- /*calculates the size of reg_data in the roce_ext_res_param structure.*/ +- reg_data_size = cmd_ret->rsp_data_num * sizeof(uint32_t) - sizeof(struct roce_ext_head); +- if (cur_size + reg_array_length * sizeof(uint32_t) > reg_data_size) { +- printf("hikptool roce_%s cur size error, cur_size: %zu, reg_data_size: %zu.\n", +- cmd_name, cur_size, reg_data_size); ++ /* ++ * The data structure `roce_ext_res_param_u64` returned by the ++ * firmware is 8-byte aligned, so the offset of the `reg_data` ++ * member needs to be adjusted accordingly. ++ */ ++ if (res_head->flags & ROCE_HIKP_DATA_U64_FLAG) ++ reg_data_offset = offsetof(struct roce_ext_res_param_u64, reg_data); ++ else ++ reg_data_offset = offsetof(struct roce_ext_res_param, reg_data); ++ ++ offset_size = res_head->cur_block_num * sizeof(uint32_t); ++ data_size = res_head->cur_block_num * output->per_val_size; ++ dst_data = reg->data_u32 + block_id * output->per_val_size / sizeof(uint32_t); ++ /* Avoid memcpy out-of-bounds. */ ++ if ((reg_data_offset + data_size) / sizeof(uint32_t) + reg_array_length > cmd_ret->rsp_data_num) { ++ printf("hikptool roce_%s cur size error, data_size: %zu, rsp_data_num: %u.\n", ++ cmd_name, data_size, cmd_ret->rsp_data_num); + ret = -EINVAL; + hikp_roce_ext_reg_data_free(reg); + goto get_data_error; + } + memcpy(reg->offset + block_id, +- (uint32_t *)&roce_ext_res->reg_data, cur_size); +- memcpy(reg->data + block_id, +- (uint32_t *)&roce_ext_res->reg_data + reg_array_length, cur_size); ++ (uint32_t *)&roce_ext_res->head + reg_data_offset / sizeof(uint32_t), ++ offset_size); ++ memcpy(dst_data, (uint32_t *)&roce_ext_res->head + reg_data_offset ++ / sizeof(uint32_t) + reg_array_length, data_size); + + get_data_error: + hikp_cmd_free(&cmd_ret); +@@ -172,15 +190,20 @@ static void hikp_roce_ext_print(enum roce_cmd_type cmd_type, + const char *cmd_name = get_cmd_name(cmd_type); + uint8_t arr_len = output->reg_name.arr_len; + uint32_t *offset = output->reg.offset; +- uint32_t *data = output->reg.data; ++ struct reg_data *reg = &output->reg; ++ const char *name; + uint32_t i; + + printf("**************%s INFO*************\n", cmd_name); + printf("%-40s[addr_offset] : reg_data\n", "reg_name"); +- for (i = 0; i < total_block_num; i++) +- printf("%-40s[0x%08X] : 0x%08X\n", +- i < arr_len ? reg_name[i] : "", +- offset[i], data[i]); ++ for (i = 0; i < total_block_num; i++) { ++ name = i < arr_len ? reg_name[i] : ""; ++ printf("%-40s[0x%08X] : ", name, offset[i]); ++ if (output->res_head.flags & ROCE_HIKP_DATA_U64_FLAG) ++ printf("0x%016lX\n", reg->data_u64[i]); ++ else ++ printf("0x%08X\n", reg->data_u32[i]); ++ } + printf("************************************\n"); + } + +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.h b/net/roce/roce_ext_common/hikp_roce_ext_common.h +index 8568556..6f04024 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.h ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.h +@@ -17,6 +17,7 @@ + #include "hikp_net_lib.h" + + #define ROCE_MAX_REG_NUM (NET_MAX_REQ_DATA_NUM - 1) ++#define ROCE_MAX_U64_REG_NUM 18 + + #define ROCE_HIKP_CAEP_REG_NUM_EXT ROCE_MAX_REG_NUM + #define ROCE_HIKP_GMV_REG_NUM_EXT ROCE_MAX_REG_NUM +@@ -30,11 +31,15 @@ + #define ROCE_HIKP_RST_REG_NUM ROCE_MAX_REG_NUM + #define ROCE_HIKP_GLOBAL_CFG_REG_NUM ROCE_MAX_REG_NUM + #define ROCE_HIKP_BOND_REG_NUM ROCE_MAX_REG_NUM ++#define ROCE_HIKP_DFX_STA_NUM_EXT ROCE_MAX_U64_REG_NUM ++ ++#define ROCE_HIKP_DATA_U64_FLAG 1 << 0 + + struct roce_ext_head { + uint8_t total_block_num; + uint8_t cur_block_num; +- uint16_t reserved; ++ uint8_t flags; ++ uint8_t reserved; + }; + + struct roce_ext_res_param { +@@ -42,9 +47,25 @@ struct roce_ext_res_param { + uint32_t reg_data[0]; + }; + ++struct roce_ext_res_data_u64 { ++ uint32_t offset[ROCE_MAX_U64_REG_NUM]; ++ uint64_t data[ROCE_MAX_U64_REG_NUM]; ++ uint32_t rsv[4]; ++}; ++ ++struct roce_ext_res_param_u64 { ++ struct roce_ext_head head; ++ uint32_t rsv; ++ struct roce_ext_res_data_u64 reg_data; ++}; ++ + struct reg_data { + uint32_t *offset; +- uint32_t *data; ++ union { ++ void *data; ++ uint32_t *data_u32; ++ uint64_t *data_u64; ++ }; + }; + + struct roce_ext_reg_name { +@@ -55,6 +76,7 @@ struct roce_ext_reg_name { + struct roce_ext_res_output { + struct roce_ext_head res_head; + struct reg_data reg; ++ uint32_t per_val_size; + struct roce_ext_reg_name reg_name; + }; + +-- +2.34.1.windows.1 + diff --git a/0104-hikptool-roce-Add-roce_dfx_sta-cmd-for-RoCE-DFX-stat.patch b/0104-hikptool-roce-Add-roce_dfx_sta-cmd-for-RoCE-DFX-stat.patch new file mode 100644 index 0000000..2c6cd55 --- /dev/null +++ b/0104-hikptool-roce-Add-roce_dfx_sta-cmd-for-RoCE-DFX-stat.patch @@ -0,0 +1,248 @@ +From b0cbaaabe1e07da2673bf13b01b2859c47d17224 Mon Sep 17 00:00:00 2001 +From: wenglianfa +Date: Wed, 2 Jul 2025 11:46:15 +0800 +Subject: [PATCH 104/104] hikptool/roce: Add roce_dfx_sta cmd for RoCE DFX + statistics + +Add roce_dfx_sta cmd for RoCE DFX statistics. + +Example: +hikptool roce_dfx_sta -i eth1 + +Signed-off-by: wenglianfa +--- + info_collect/hikp_collect_roce.c | 22 ++++ + net/hikp_net_lib.h | 1 + + net/roce/roce_dfx_sta/hikp_roce_dfx_sta.c | 107 ++++++++++++++++++ + net/roce/roce_dfx_sta/hikp_roce_dfx_sta.h | 33 ++++++ + .../roce_ext_common/hikp_roce_ext_common.c | 1 + + 5 files changed, 164 insertions(+) + create mode 100644 net/roce/roce_dfx_sta/hikp_roce_dfx_sta.c + create mode 100644 net/roce/roce_dfx_sta/hikp_roce_dfx_sta.h + +diff --git a/info_collect/hikp_collect_roce.c b/info_collect/hikp_collect_roce.c +index baf2899..01d773b 100644 +--- a/info_collect/hikp_collect_roce.c ++++ b/info_collect/hikp_collect_roce.c +@@ -26,6 +26,7 @@ + #include "hikp_roce_tsp.h" + #include "hikp_roce_scc.h" + #include "hikp_roce_gmv.h" ++#include "hikp_roce_dfx_sta.h" + + static void collect_roce_devinfo_log(void) + { +@@ -125,6 +126,26 @@ static int collect_hikp_roce_gmv_log(void *nic_name) + return 0; + } + ++static int collect_hikp_roce_dfx_sta_log(void *nic_name) ++{ ++ struct major_cmd_ctrl self = {0}; ++ struct hikp_cmd_type type = {0}; ++ int ret; ++ ++ self.cmd_ptr = &type; ++ ret = hikp_roce_set_dfx_sta_bdf((char *)nic_name); ++ if (ret) { ++ HIKP_ERROR_PRINT("failed to set roce_dfx_sta bdf for %s.\n", ++ (char *)nic_name); ++ return ret; ++ } ++ ++ printf("hikptool roce_dfx_sta -i %s\n", (char *)nic_name); ++ hikp_roce_dfx_sta_execute(&self); ++ ++ return 0; ++} ++ + static int collect_hikp_roce_scc_log(void *nic_name) + { + struct major_cmd_ctrl self = {0}; +@@ -466,6 +487,7 @@ static int collect_one_roce_hikp_log(void *net_name) + { "roce_tsp", collect_hikp_roce_tsp_log }, + { "roce_scc", collect_hikp_roce_scc_log }, + { "roce_gmv", collect_hikp_roce_gmv_log }, ++ { "roce_dfx_sta", collect_hikp_roce_dfx_sta_log }, + }; + size_t i; + +diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h +index 7ebabfa..aa700ab 100644 +--- a/net/hikp_net_lib.h ++++ b/net/hikp_net_lib.h +@@ -103,6 +103,7 @@ enum roce_cmd_type { + GET_ROCEE_RST_CMD, + GET_ROCEE_GLOBAL_CFG_CMD, + GET_ROCEE_BOND_CMD, ++ GET_ROCEE_DFX_STA_CMD, + }; + + enum ub_cmd_type { +diff --git a/net/roce/roce_dfx_sta/hikp_roce_dfx_sta.c b/net/roce/roce_dfx_sta/hikp_roce_dfx_sta.c +new file mode 100644 +index 0000000..b74507c +--- /dev/null ++++ b/net/roce/roce_dfx_sta/hikp_roce_dfx_sta.c +@@ -0,0 +1,107 @@ ++/* ++ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd. ++ * Hikptool is licensed under Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, ++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, ++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. ++ * ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#include "hikp_roce_dfx_sta.h" ++ ++static struct cmd_roce_dfx_sta_param_t g_roce_dfx_sta_param_t = { 0 }; ++ ++int hikp_roce_set_dfx_sta_bdf(char *nic_name) ++{ ++ return tool_check_and_get_valid_bdf_id(nic_name, ++ &g_roce_dfx_sta_param_t.target); ++} ++ ++static int hikp_roce_dfx_sta_help(struct major_cmd_ctrl *self, const char *argv) ++{ ++ HIKP_SET_USED(argv); ++ ++ printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); ++ printf("\n %s\n", self->cmd_ptr->help_info); ++ printf(" Options:\n\n"); ++ printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); ++ printf(" %s, %-25s %s\n", "-i", "--interface=", "device target, e.g. eth0"); ++ printf(" %s, %-25s %s\n", "-c", "--clear=", "clear param count registers"); ++ printf("\n"); ++ ++ return 0; ++} ++ ++static int hikp_roce_dfx_sta_target(struct major_cmd_ctrl *self, const char *argv) ++{ ++ self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_dfx_sta_param_t.target)); ++ if (self->err_no != 0) ++ snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); ++ ++ return self->err_no; ++} ++ ++static int hikp_roce_dfx_sta_clear_set(struct major_cmd_ctrl *self, const char *argv) ++{ ++ HIKP_SET_USED(self); ++ HIKP_SET_USED(argv); ++ ++ g_roce_dfx_sta_param_t.reset_flag = 1; ++ return 0; ++} ++ ++/* DON'T change the order of this array or add entries between! */ ++static const char *g_dfx_sta_reg_name[] = { ++ "PKT_RNR_STA", ++ "PKT_RTY_STA", ++ "MSN_RTY_STA", ++}; ++ ++static int hikp_roce_dfx_sta_get_data(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id, ++ struct roce_ext_reg_name *reg_name) ++{ ++ struct hikp_cmd_header req_header = { 0 }; ++ struct roce_dfx_sta_req_param req_data; ++ uint32_t req_size; ++ int ret; ++ ++ reg_name->reg_name = g_dfx_sta_reg_name; ++ reg_name->arr_len = HIKP_ARRAY_SIZE(g_dfx_sta_reg_name); ++ ++ req_data.reset_flag = g_roce_dfx_sta_param_t.reset_flag; ++ req_data.bdf = g_roce_dfx_sta_param_t.target.bdf; ++ req_data.block_id = block_id; ++ ++ req_size = sizeof(struct roce_dfx_sta_req_param); ++ hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_DFX_STA_CMD, 0); ++ *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, req_size); ++ ret = hikp_rsp_normal_check(*cmd_ret); ++ if (ret) ++ printf("hikptool roce_dfx_sta get cmd data failed, ret: %d\n", ret); ++ ++ return ret; ++} ++ ++void hikp_roce_dfx_sta_execute(struct major_cmd_ctrl *self) ++{ ++ hikp_roce_ext_execute(self, GET_ROCEE_DFX_STA_CMD, hikp_roce_dfx_sta_get_data); ++} ++ ++static void cmd_roce_dfx_sta_init(void) ++{ ++ struct major_cmd_ctrl *major_cmd = get_major_cmd(); ++ ++ major_cmd->option_count = 0; ++ major_cmd->execute = hikp_roce_dfx_sta_execute; ++ ++ cmd_option_register("-h", "--help", false, hikp_roce_dfx_sta_help); ++ cmd_option_register("-i", "--interface", true, hikp_roce_dfx_sta_target); ++ cmd_option_register("-c", "--clear", false, hikp_roce_dfx_sta_clear_set); ++} ++ ++HIKP_CMD_DECLARE("roce_dfx_sta", "get or clear RoCE dfx statistics", cmd_roce_dfx_sta_init); +diff --git a/net/roce/roce_dfx_sta/hikp_roce_dfx_sta.h b/net/roce/roce_dfx_sta/hikp_roce_dfx_sta.h +new file mode 100644 +index 0000000..b515356 +--- /dev/null ++++ b/net/roce/roce_dfx_sta/hikp_roce_dfx_sta.h +@@ -0,0 +1,33 @@ ++/* ++ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd. ++ * Hikptool is licensed under Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, ++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, ++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. ++ * ++ * See the Mulan PSL v2 for more details. ++ */ ++ ++#ifndef HIKP_ROCE_DFX_STA_H ++#define HIKP_ROCE_DFX_STA_H ++ ++#include "hikp_roce_ext_common.h" ++ ++struct cmd_roce_dfx_sta_param_t { ++ uint8_t reset_flag; ++ struct tool_target target; ++}; ++ ++struct roce_dfx_sta_req_param { ++ struct bdf_t bdf; ++ uint32_t block_id; ++ uint8_t reset_flag; ++}; ++ ++int hikp_roce_set_dfx_sta_bdf(char *nic_name); ++void hikp_roce_dfx_sta_execute(struct major_cmd_ctrl *self); ++ ++#endif /* HIKP_ROCE_DFX_STA_H */ +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index c225ec8..ac6c8fb 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -44,6 +44,7 @@ static const struct cmd_type_info { + {GET_ROCEE_RST_CMD, "RST", ROCE_HIKP_RST_REG_NUM}, + {GET_ROCEE_GLOBAL_CFG_CMD, "GLOBAL_CFG", ROCE_HIKP_GLOBAL_CFG_REG_NUM}, + {GET_ROCEE_BOND_CMD, "BOND", ROCE_HIKP_BOND_REG_NUM}, ++ {GET_ROCEE_DFX_STA_CMD, "DFX_STA", ROCE_HIKP_DFX_STA_NUM_EXT}, + }; + + static int get_cmd_info_table_idx(enum roce_cmd_type cmd_type) +-- +2.34.1.windows.1 + diff --git a/hikptool.spec b/hikptool.spec index c19df02..bd573bf 100644 --- a/hikptool.spec +++ b/hikptool.spec @@ -3,7 +3,7 @@ Name: hikptool Summary: A userspace tool for Linux providing problem location on Kunpeng chips Version: 1.0.0 -Release: 18 +Release: 21 License: MulanPSL2 Source: %{name}-%{version}.tar.gz ExclusiveOS: linux @@ -115,6 +115,11 @@ Patch0096: 0096-Hikptool-add-support-dump-SDMA-register-information-.patch Patch0097: 0097-Add-support-collect-sdma-hikptool-dump-reg-info.patch Patch0098: 0098-hikptool-Update-the-tool-version-number-to-1.1.4.patch Patch0099: 0099-hikptool-The-cpu_ring-command-is-added.patch +Patch0100: 0100-hikptool-ras-Add-support-for-exporting-black-box-dat.patch +Patch0101: 0101-hikptool-Code-quality-reinforcement.patch +Patch0102: 0102-hikptool-Add-more-RoCE-registers-for-diagnosis.patch +Patch0103: 0103-hikptool-roce-Support-to-print-u64-reg_data.patch +Patch0104: 0104-hikptool-roce-Add-roce_dfx_sta-cmd-for-RoCE-DFX-stat.patch %description This package contains the hikptool @@ -167,6 +172,15 @@ fi /sbin/ldconfig %changelog +* Sat Jul 26 2025 Junxian Huang 1.0.0-21 +- Add roce debug enhancements + +* Sat Jul 26 2025 Junxian Huang 1.0.0-20 +- Fix coding problems + +* Sat Jul 26 2025 Junxian Huang 1.0.0-19 +- Add ras support + * Fri Jun 6 2025 veega2022 1.0.0-18 - The cpu_ring command is added. -- Gitee