From 881b2e05f8f7c79e07b905648896ce4c469c66b4 Mon Sep 17 00:00:00 2001 From: Junhao He Date: Tue, 16 Sep 2025 19:47:25 +0800 Subject: [PATCH] hikptool: ras: do some cleanup and refactoring of rasdfx dump cleanup: 1) Add a macro to simplify obtaining the packet size 2) Remove redundant checks for cmd and size, as they are always true 3) Use memcpy instead of for loop statements 4) Remove the redundant initialization of ras_rsp_data to 0 5) Other minor cleanup refactor: During the dump file process, do not repeatedly open and close the file No need to subtract the packet header length, then simplify the code for obtaining the file buffer size. Add helper of ras_get_rasdfx_header Add a check to verify if cmd_ret->rsp_data_num is 0 Add a check to verify whether f_header.pkt_num exceeds the maximum value The header.pkt_length indicates the size in bytes, which needs to be converted to DWORD size, and then compared with DFX_REG_PACKET_HEAD_LEN to address potential division by zero issues. Refactoring of parseing payload. Signed-off-by: Junhao He (cherry picked from commit 0cca8cf7a75c017459a164e30f6ab32688628443) --- ...some-cleanup-and-refactoring-of-rasd.patch | 875 ++++++++++++++++++ hikptool.spec | 6 +- 2 files changed, 880 insertions(+), 1 deletion(-) create mode 100644 0110-hikptool-ras-do-some-cleanup-and-refactoring-of-rasd.patch diff --git a/0110-hikptool-ras-do-some-cleanup-and-refactoring-of-rasd.patch b/0110-hikptool-ras-do-some-cleanup-and-refactoring-of-rasd.patch new file mode 100644 index 0000000..28066b8 --- /dev/null +++ b/0110-hikptool-ras-do-some-cleanup-and-refactoring-of-rasd.patch @@ -0,0 +1,875 @@ +From bfd5326b0abb9d6f54333f8f9090fd8cabc17061 Mon Sep 17 00:00:00 2001 +From: Junhao He +Date: Tue, 16 Sep 2025 16:59:56 +0800 +Subject: [PATCH] hikptool: ras: do some cleanup and refactoring of rasdfx dump + +cleanup: +1) Add a macro to simplify obtaining the packet size +2) Remove redundant checks for cmd and size, as they are always true +3) Use memcpy instead of for loop statements +4) Remove the redundant initialization of ras_rsp_data to 0 +5) Other minor cleanup + +refactor: +During the dump file process, do not repeatedly open and close the file +No need to subtract the packet header length, then simplify the code for +obtaining the file buffer size. + +Add helper of ras_get_rasdfx_header +Add a check to verify if cmd_ret->rsp_data_num is 0 +Add a check to verify whether f_header.pkt_num exceeds the maximum value + +The header.pkt_length indicates the size in bytes, which needs to be +converted to DWORD size, and then compared with DFX_REG_PACKET_HEAD_LEN +to address potential division by zero issues. + +Refactoring of parseing payload. + +Signed-off-by: Junhao He +--- + ras/ras_func/ras_common.h | 26 -- + ras/ras_func/ras_dump_data.c | 468 +++++++++++++------------------ + ras/ras_func/ras_dump_data.h | 90 +++--- + ras/user_cmd/ras_cmd_dump.c | 35 +-- + ras/user_cmd/ras_tools_include.h | 25 -- + 5 files changed, 243 insertions(+), 401 deletions(-) + delete mode 100644 ras/ras_func/ras_common.h + delete mode 100644 ras/user_cmd/ras_tools_include.h + +diff --git a/ras/ras_func/ras_common.h b/ras/ras_func/ras_common.h +deleted file mode 100644 +index 0931ed9..0000000 +--- a/ras/ras_func/ras_common.h ++++ /dev/null +@@ -1,26 +0,0 @@ +-/* +- * 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 +index 7ab7d6b..2d0f274 100644 +--- a/ras/ras_func/ras_dump_data.c ++++ b/ras/ras_func/ras_dump_data.c +@@ -13,377 +13,299 @@ + #include + #include + #include ++#include + #include + #include + #include + #include + #include "hikptdev_plug.h" + #include "op_logs.h" +-#include "ras_common.h" ++#include "hikpt_rciep.h" ++#include "tool_lib.h" + #include "ras_dump_data.h" + +-static struct dfx_reg_dump_header header; ++static void __attribute__((format(printf, 2, 3))) __THROWNL ++rasdfx_wr2buf(struct file_seq *s, const char *fmt, ...); + +-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; ++#define RAS_DUMP 0 + +- 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; +- } ++#define RASDFX_FILE_HEADER_LEN 6 ++#define MAX_DFX_PACKET_LEN 256 ++#define DFX_REG_PACKET_HEAD_LEN 3U + +- 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]; +- } ++#define DFX_DATA_CLEARED_MAGIC 0 ++#define DFX_DATA_DUMPED_MAGIC 0x5aa5a55a + +- hikp_cmd_free(&cmd_ret); +- return 0; +-} ++#define RASDFX_PACKET_HEAD_SIZE 256 ++#define RASDFX_PACKET_SIZE(reg_num) (RASDFX_PACKET_HEAD_SIZE + (reg_num) * 10) ++#define RASDFX_PACKET_NUM_MAX 1000000 + +-static void ras_print_time(struct file_seq *s) ++static void __THROWNL rasdfx_wr2buf(struct file_seq *s, const char *fmt, ...) + { +- 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); ++ size_t size = s->buf_size - s->buf_offs; ++ va_list argp; ++ int len; ++ ++ va_start(argp, fmt); ++ len = vsnprintf(s->buf + s->buf_offs, size, fmt, argp); ++ va_end(argp); ++ ++ if (len < 0 || (size_t)len >= size) ++ HIKP_WARN_PRINT("rasdfx_wr2buf failed, the dfx data is incomplete\n"); ++ else ++ s->buf_offs += (size_t)len; + } + +-static int ras_parse_data(uint32_t *reg_save, uint32_t reg_num, uint32_t reg_off, struct file_seq *s) ++static struct hikp_cmd_ret *ras_get_rsp_data(struct ras_dump_cmd *cmd) + { +- 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; +- } ++ struct hikp_cmd_header req_header; ++ struct hikp_cmd_ret *cmd_ret; + +- 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]); ++ hikp_cmd_init(&req_header, RAS_MOD, RAS_DUMP, cmd->cmd_type); ++ cmd_ret = hikp_cmd_alloc(&req_header, &cmd->cmd_id, sizeof(cmd->cmd_id)); ++ if (!cmd_ret) { ++ HIKP_ERROR_PRINT("alloc cmd failed, cmd: %u\n", cmd->cmd_id); ++ return NULL; ++ } + +- s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "\n"); +- off += pkt_reg_num; ++ if (cmd_ret->status) { ++ HIKP_ERROR_PRINT("hikp_data_proc err, status: %u\n", cmd_ret->status); ++ hikp_cmd_free(&cmd_ret); ++ return NULL; + } + +- return 0; ++ return cmd_ret; + } + +-static int ras_generate_file_name(struct file_seq *s) ++static int ras_get_rasdfx_header(struct ras_dump_cmd *cmd, struct rasdfx_file_header *f_header) + { +- time_t time_seconds = time(0); +- struct tm timeinfo; +- int ret; ++ struct hikp_cmd_ret *cmd_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; ++ cmd->cmd_id = 0; ++ cmd_ret = ras_get_rsp_data(cmd); ++ if (!cmd_ret) ++ return -ENOMEM; ++ ++ if (cmd_ret->rsp_data_num != RASDFX_FILE_HEADER_LEN) { ++ HIKP_ERROR_PRINT("invalid number of response data: %u\n", cmd_ret->rsp_data_num); ++ hikp_cmd_free(&cmd_ret); ++ return -1; + } + ++ memcpy(f_header, cmd_ret->rsp_data, sizeof(struct rasdfx_file_header)); ++ hikp_cmd_free(&cmd_ret); ++ + return 0; + } + +-static int ras_store_data(struct file_seq *s) ++static bool ras_check_header(struct rasdfx_file_header *f_header) + { +- 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; ++ if (f_header->pkt_size_dwords % REP_DATA_BLK_SIZE) { ++ HIKP_ERROR_PRINT("packet size is not aligned: %u\n", f_header->pkt_size_dwords); ++ return false; + } + +- fp = fopen(file_path, "a"); +- if (fp == NULL) { +- HIKP_ERROR_PRINT("open %s failed, errno is %d\n", file_path, errno); +- return -errno; ++ /* Converted to DWORD units to simplify subsequent calculations */ ++ f_header->pkt_size_dwords = f_header->pkt_size_dwords / REP_DATA_BLK_SIZE; ++ if (f_header->pkt_size_dwords < DFX_REG_PACKET_HEAD_LEN || ++ f_header->pkt_size_dwords > MAX_DFX_PACKET_LEN) { ++ HIKP_ERROR_PRINT("packet size is out of bounds: %u\n", f_header->pkt_size_dwords); ++ return false; + } + +- 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; ++ if (f_header->pkt_num == 0 || f_header->pkt_num > RASDFX_PACKET_NUM_MAX) { ++ HIKP_ERROR_PRINT("packet number is out of bounds: %u\n", f_header->pkt_num); ++ return false; + } + +- s->len = 0; +- +- return 0; ++ return true; + } + +-static int file_seq_init(struct file_seq *s, uint32_t size) ++static int ras_open_rasdfx_file_seq(struct file_seq *s, struct rasdfx_file_header *f_header) + { +- if (!size) +- return -1; ++ char file_path[OP_LOG_FILE_PATH_MAXLEN]; ++ time_t time_seconds = time(0); ++ struct tm timeinfo; + +- s->buffer_size = size; +- s->len = 0; +- s->buffer = (char*)malloc(s->buffer_size); +- if (!s->buffer) +- return -1; ++ s->buf_offs = 0; ++ s->buf_size = RASDFX_PACKET_SIZE(f_header->pkt_size_dwords); ++ s->buf = (char *)malloc(s->buf_size); ++ if (!s->buf) { ++ HIKP_ERROR_PRINT("malloc file_seq buffer is failed\n"); ++ return -ENOMEM; ++ } ++ ++ (void)localtime_r(&time_seconds, &timeinfo); ++ snprintf(file_path, sizeof(file_path), "%srasdfx_%04d_%02d_%02d_%02d_%02d_%02d.log", ++ HIKP_LOG_DIR_PATH, timeinfo.tm_year + START_YEAR, timeinfo.tm_mon + 1, ++ timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec); ++ ++ // creat and open file, set file permissiion 0440 ++ s->fd = open(file_path, O_WRONLY | O_CREAT, S_IRUSR | S_IRGRP); ++ if (s->fd < 0) { ++ HIKP_ERROR_PRINT("open %s failed: %s\n", file_path, strerror(errno)); ++ free(s->buf); ++ return -errno; ++ } + ++ printf("dump dfx log start, log file: %s\n", file_path); + return 0; + } + +-static void file_seq_destroy(struct file_seq *s) ++static void ras_close_rasdfx_file_seq(struct file_seq *s) + { +- free(s->buffer); +- s->buffer = NULL; ++ (void)close(s->fd); ++ free(s->buf); + } + +-static void ras_rsp_init(struct ras_rsp *ras_rsp_data) ++static void ras_parse_rasdfx_pkt_header(struct file_seq *s, struct rasdfx_pkt *pkt) + { +- 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; ++ time_t time_seconds = time(0); ++ struct tm timeinfo; + +- 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)); ++ (void)localtime_r(&time_seconds, &timeinfo); ++ rasdfx_wr2buf(s, "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); ++ rasdfx_wr2buf(s, "Socket: 0X%hhX ", pkt->dw0.skt_id); ++ rasdfx_wr2buf(s, "DIE: 0X%hhX ", pkt->dw0.die_id); ++ rasdfx_wr2buf(s, "Module: 0X%hhX ", pkt->dw1.module_id); ++ rasdfx_wr2buf(s, "Sub Module: 0X%hhX ", pkt->dw1.submodule_id); ++ rasdfx_wr2buf(s, "SequenceNum: 0X%hhX ", pkt->dw1.sequence_num); ++ rasdfx_wr2buf(s, "Version: 0X%hhX\n", pkt->dw0.version); ++ rasdfx_wr2buf(s, "----------------------- DFX REGISTER DUMP -----------------------\n"); + } + +-static int parse_packet_buffer_data(struct ras_rsp *ras_rsp_data, +- uint32_t pkt_reg_num, struct file_seq *s) ++static int ras_parse_rasdfx_payload(struct file_seq *s, uint32_t *buf, ++ struct rasdfx_file_header *f_header) + { +- 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; +- } ++ struct rasdfx_pkt *pkt = (struct rasdfx_pkt *)buf; ++ uint32_t reg_offs, i; ++ ssize_t write_cnt; + +- if (ras_rsp_data->packet_buffer_len) { +- uint32_t rest_pkt_length; ++ rasdfx_wr2buf(s, "SocID: %u\n\n", pkt->dw0.soc_id); + +- 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; ++ for (i = 0; i < f_header->pkt_num; i++) { ++ ras_parse_rasdfx_pkt_header(s, pkt); ++ if (pkt->dw1.reg_count > f_header->pkt_size_dwords - DFX_REG_PACKET_HEAD_LEN) { ++ HIKP_ERROR_PRINT("ras dfx register number is incorrect\n"); ++ return -1; + } +- } else { +- ras_rsp_data->first_pkt_begin = 0; +- } + +- if (ras_rsp_data->first_pkt_begin == ras_rsp_data->rsp_data_num) +- return 0; ++ for (reg_offs = 0; reg_offs < pkt->dw1.reg_count; reg_offs++) ++ rasdfx_wr2buf(s, "0X%08X\n", pkt->reg_base[reg_offs]); ++ rasdfx_wr2buf(s, "\n"); + +- 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; ++ write_cnt = write(s->fd, s->buf, s->buf_offs); ++ if (write_cnt != (ssize_t)s->buf_offs) { ++ HIKP_ERROR_PRINT("write rasdfx file failed: %s\n", strerror(errno)); ++ return -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); ++ s->buf_offs = 0; ++ pkt = (struct rasdfx_pkt *)((uint32_t *)pkt + f_header->pkt_size_dwords); ++ } + + return 0; + } + +-static int ras_dump_pkt_pre(struct ras_rsp *ras_rsp_data, struct file_seq *s) ++static int ras_dump_data_into_buf(struct ras_dump_cmd *cmd, uint32_t *buf, uint32_t buf_max) + { +- 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; ++ struct hikp_cmd_ret *cmd_ret; ++ uint32_t copy_len = 0; ++ uint32_t data_num; ++ ++ while (copy_len < buf_max) { ++ cmd->cmd_id++; ++ cmd_ret = ras_get_rsp_data(cmd); ++ if (!cmd_ret) ++ return -ENOMEM; ++ ++ data_num = cmd_ret->rsp_data_num; ++ if (data_num == 0 || data_num > HIKP_RSP_ALL_DATA_MAX) { ++ HIKP_ERROR_PRINT("invalid response data number: %u\n", data_num); ++ hikp_cmd_free(&cmd_ret); ++ return -1; ++ } + +- ret = file_seq_init(s, s_buffer_size); +- if (ret) { +- HIKP_ERROR_PRINT("malloc file_seq buffer is failed\n"); +- return ret; +- } ++ if (copy_len + data_num > buf_max) { ++ HIKP_ERROR_PRINT("response data is more than expected\n"); ++ hikp_cmd_free(&cmd_ret); ++ return -1; ++ } + +- ret = ras_generate_file_name(s); +- if (ret) { +- HIKP_ERROR_PRINT("ras generate file name is failed\n"); +- file_seq_destroy(s); +- return ret; ++ memcpy(buf + copy_len, cmd_ret->rsp_data, data_num * REP_DATA_BLK_SIZE); ++ copy_len += data_num; ++ hikp_cmd_free(&cmd_ret); + } + +- return ret; ++ return 0; + } + +-static int ras_dump_packet(struct tool_ras_cmd *cmd, struct ras_rsp *ras_rsp_data, +- struct ras_dump_req_para *req_data) ++static int ras_get_rasdfx_payload(struct ras_dump_cmd *cmd, struct rasdfx_file_header *f_header) + { +- int ret; +- uint32_t i, cmd_num; +- bool has_printed_socid = false; ++ uint32_t buf_max = f_header->pkt_size_dwords * f_header->pkt_num; ++ uint32_t *total_buf; + struct file_seq s; ++ int ret; + +- 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"); ++ total_buf = (uint32_t *)malloc(buf_max * REP_DATA_BLK_SIZE); ++ if (!total_buf) { ++ HIKP_ERROR_PRINT("malloc total_buf failed\n"); ++ return -ENOMEM; ++ } + +- has_printed_socid = true; +- } ++ ret = ras_dump_data_into_buf(cmd, total_buf, buf_max); ++ if (ret) ++ goto release_total_buf; + +- 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; +- } ++ ret = ras_open_rasdfx_file_seq(&s, f_header); ++ if (ret) ++ goto release_total_buf; + +- 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_parse_rasdfx_payload(&s, total_buf, f_header); + +- 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); ++ ras_close_rasdfx_file_seq(&s); ++release_total_buf: ++ free(total_buf); + return ret; + } + +-int ras_data_dump(struct tool_ras_cmd *cmd) ++int ras_data_dump(void) + { ++ struct ras_dump_cmd cmd = { .cmd_type = DUMP_DFX }; ++ struct rasdfx_file_header f_header; + 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; +- } ++ ret = ras_get_rasdfx_header(&cmd, &f_header); ++ if (ret) ++ return ret; + +- 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"); ++ if (f_header.head_magic != DFX_DATA_DUMPED_MAGIC) { ++ HIKP_ERROR_PRINT("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); ++ if (!ras_check_header(&f_header)) + 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; ++ return ras_get_rasdfx_payload(&cmd, &f_header); + } + +-int ras_data_clear(struct tool_ras_cmd *cmd) ++int ras_data_clear(void) + { ++ struct ras_dump_cmd cmd = { .cmd_type = DUMP_CLEAR }; ++ struct rasdfx_file_header f_header; + int ret; +- struct ras_rsp ras_rsp_data; +- struct ras_dump_req_para req_data = { 0 }; + +- if (cmd == NULL) +- return -ENOSPC; ++ ret = ras_get_rasdfx_header(&cmd, &f_header); ++ if (ret) ++ return ret; + +- 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) { ++ if (f_header.head_magic != DFX_DATA_CLEARED_MAGIC) { + 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 +index 4c54ffe..ef4a00f 100644 +--- a/ras/ras_func/ras_dump_data.h ++++ b/ras/ras_func/ras_dump_data.h +@@ -11,78 +11,60 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef RAS_DUMP_REG_H +-#define RAS_DUMP_REG_H ++#ifndef RAS_DUMP_DATA_H ++#define RAS_DUMP_DATA_H + +-#include "ras_tools_include.h" +-#include "hikpt_rciep.h" +-#include "tool_lib.h" ++#include + +-#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 { ++struct rasdfx_file_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 pkt_size_dwords; // 单个packet内DWord个数，单位4bytes + 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 rasdfx_pkt_header_dw0 { ++ uint32_t version : 8; ++ uint32_t soc_id : 8; ++ uint32_t skt_id : 8; ++ uint32_t die_id : 8; + }; + +-struct ras_dump_req_para { +- uint32_t cmd_id; ++struct rasdfx_pkt_header_dw1 { ++ uint32_t module_id : 8; ++ uint32_t submodule_id : 8; ++ uint32_t sequence_num : 8; ++ uint32_t reg_count : 8; + }; + +-enum reg_dump_header_index { +- HEAD_MAGIC, +- VERSION, +- CAP_BITS, +- PKT_NUM, +- PKT_LENGTH ++struct rasdfx_pkt { ++ struct rasdfx_pkt_header_dw0 dw0; ++ struct rasdfx_pkt_header_dw1 dw1; ++ uint32_t reserved; ++ uint32_t reg_base[0]; + }; + +-enum dfx_packet_index { +- DFX_HEAD_INFO_DW0, +- DFX_HEAD_INFO_DW1, +- DFX_COMMON_MAIN_TEXT_BEGIN = 3 ++struct file_seq { ++ int fd; ++ char *buf; ++ size_t buf_size; ++ size_t buf_offs; + }; + +-#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 ++enum ras_dump_cmd_type { ++ DUMP_DFX, ++ DUMP_CLEAR ++ }; + +-#define DFX_DATA_IS_CLEARED 0 +- +-#define DFX_FILE_SINGLE_PACKET_HEAD_SIZE 256 +-#define DFX_FILE_SINGLE_REG_SIZE 10 ++struct ras_dump_cmd { ++ enum ras_dump_cmd_type cmd_type; ++ uint32_t cmd_id; /* 0: get header info, 1-n: get packet data */ ++}; + ++int ras_data_dump(void); ++int ras_data_clear(void); + +-int ras_data_dump(struct tool_ras_cmd *cmd); +-int ras_data_clear(struct tool_ras_cmd *cmd); ++#endif /* RAS_DUMP_DATA_H */ + +-#endif /* RAS_DUMP_REG_H */ +diff --git a/ras/user_cmd/ras_cmd_dump.c b/ras/user_cmd/ras_cmd_dump.c +index 14fa0cf..a9f1d85 100644 +--- a/ras/user_cmd/ras_cmd_dump.c ++++ b/ras/user_cmd/ras_cmd_dump.c +@@ -13,11 +13,12 @@ + + #include + #include "tool_cmd.h" +-#include "ras_tools_include.h" ++#include "hikptdev_plug.h" ++#include "tool_lib.h" + #include "ras_dump_data.h" + +-struct tool_ras_cmd g_ras_dump_cmd = { +- .ras_cmd_type = DUMP_DFX, ++struct ras_dump_cmd g_cmd = { ++ .cmd_type = DUMP_DFX + }; + + static int ras_dump_help(struct major_cmd_ctrl *self, const char *argv) +@@ -34,33 +35,21 @@ static int ras_dump_help(struct major_cmd_ctrl *self, const char *argv) + 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); ++ g_cmd.cmd_type = DUMP_CLEAR; + return 0; + } + +-static int ras_dump_execute_process(void) ++static int ras_dump_execute_process(enum ras_dump_cmd_type cmd_type) + { +- 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); ++ if (cmd_type == DUMP_CLEAR) ++ return ras_data_clear(); + else +- return -EINVAL; ++ return ras_data_dump(); + } + + static void ras_dump_execute(struct major_cmd_ctrl *self) +@@ -75,12 +64,12 @@ static void ras_dump_execute(struct major_cmd_ctrl *self) + "ras dfx data clear error." + }; + +- ret = ras_dump_execute_process(); ++ ret = ras_dump_execute_process(g_cmd.cmd_type); + if (ret == 0) { +- printf("%s\n", suc_msg[ras_get_cmd_type()]); ++ printf("%s\n", suc_msg[g_cmd.cmd_type]); + } else { + snprintf(self->err_str, sizeof(self->err_str), "%s\n", +- err_msg[ras_get_cmd_type()]); ++ err_msg[g_cmd.cmd_type]); + self->err_no = ret; + } + } +diff --git a/ras/user_cmd/ras_tools_include.h b/ras/user_cmd/ras_tools_include.h +deleted file mode 100644 +index 19d9db2..0000000 +--- a/ras/user_cmd/ras_tools_include.h ++++ /dev/null +@@ -1,25 +0,0 @@ +-/* +- * 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.25.1 + diff --git a/hikptool.spec b/hikptool.spec index beeb35e..d206c40 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: 23 +Release: 24 License: MulanPSL2 Source: %{name}-%{version}.tar.gz ExclusiveOS: linux @@ -125,6 +125,7 @@ Patch0106: 0106-hikptool-Add-serdes-module-submodule-dump-types.patch Patch0107: 0107-hikptool-Optimize-the-ROCE-SCC-module-register-dump-.patch Patch0108: 0108-hikptool-solve-some-code-review-comments.patch Patch0109: 0109-hikptool-optimization-tool-help-information.patch +Patch0110: 0110-hikptool-ras-do-some-cleanup-and-refactoring-of-rasd.patch %description This package contains the hikptool @@ -177,6 +178,9 @@ fi /sbin/ldconfig %changelog +* Tue Sep 16 2025 Junhao He 1.0.0-24 +- ras: do some cleanup and refactoring of rasdfx dump + * Thu Aug 28 2025 veega2022 1.0.0-23 - Optimize help information and modify code review comments -- Gitee