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 0000000000000000000000000000000000000000..28066b8c038b0cab3745ba874299bd1ca8264c57 --- /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 beeb35eb0a58699e12546cecd7c776128139aa8a..d206c407e5ec693d50da884fe9fdf80e85d4b7ea 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