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 <hejunhao3@h-partners.com> --- ras/ras_func/ras_common.h | 26 -- ras/ras_func/ras_dump_data.c | 541 +++++++++++++------------------ ras/ras_func/ras_dump_data.h | 101 +++--- ras/user_cmd/ras_cmd_dump.c | 37 +-- ras/user_cmd/ras_tools_include.h | 25 -- 5 files changed, 282 insertions(+), 448 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 9b9a486..0000000 --- a/ras/ras_func/ras_common.h +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c) 2022 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 f4238e3..5d0ec8e 100644 --- a/ras/ras_func/ras_dump_data.c +++ b/ras/ras_func/ras_dump_data.c @@ -13,384 +13,299 @@ #include <unistd.h> #include <stdint.h> #include <stdlib.h> +#include <stdarg.h> #include <string.h> #include <stdio.h> #include <errno.h> #include <time.h> #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) +#define RAS_DUMP 0 + +#define RASDFX_FILE_HEADER_LEN 6 +#define MAX_DFX_PACKET_LEN 256 +#define DFX_REG_PACKET_HEAD_LEN 3U + +#define DFX_DATA_CLEARED_MAGIC 0 +#define DFX_DATA_DUMPED_MAGIC 0x5aa5a55a + +#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 __THROWNL rasdfx_wr2buf(struct file_seq *s, const char *fmt, ...) +{ + 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 struct hikp_cmd_ret *ras_get_rsp_data(struct ras_dump_cmd *cmd) { - uint32_t i; - struct hikp_cmd_ret *cmd_ret; struct hikp_cmd_header req_header; + struct hikp_cmd_ret *cmd_ret; + + 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; + } - 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"); + if (cmd_ret->status) { + HIKP_ERROR_PRINT("hikp_data_proc err, status: %u\n", cmd_ret->status); hikp_cmd_free(&cmd_ret); - return -1; + return NULL; } - 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]; - } + return cmd_ret; +} + +static int ras_get_rasdfx_header(struct ras_dump_cmd *cmd, struct rasdfx_file_header *f_header) +{ + struct hikp_cmd_ret *cmd_ret; + + 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 void ras_print_time(struct file_seq *s) +static bool ras_check_header(struct rasdfx_file_header *f_header) { + 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; + } + + /* 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; + } + + 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; + } + + return true; +} + +static int ras_open_rasdfx_file_seq(struct file_seq *s, struct rasdfx_file_header *f_header) +{ + char file_path[OP_LOG_FILE_PATH_MAXLEN]; time_t time_seconds = time(0); struct tm timeinfo; + 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); - 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); + 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 int ras_parse_data(uint32_t *reg_save, uint32_t reg_num, uint32_t reg_off, struct file_seq *s) +static void ras_close_rasdfx_file_seq(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", - (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, "%4s", ""); - s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "DIE: 0X%hhX", - (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, "%4s", ""); - s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "Module: 0X%hhX", - (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, "%4s", ""); - s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "Sub Module: 0X%hhX", - (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, "%4s", ""); - s->len += snprintf(s->buffer + s->len, s->buffer_size - s->len, "SequenceNum: 0X%hhX", - (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, "%4s", ""); - 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%08X\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; + (void)close(s->fd); + free(s->buf); } -static int ras_generate_file_name(struct file_seq *s) +static void ras_parse_rasdfx_pkt_header(struct file_seq *s, struct rasdfx_pkt *pkt) { 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; + 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 ras_store_data(struct file_seq *s) +static int ras_parse_rasdfx_payload(struct file_seq *s, uint32_t *buf, + 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; - } + struct rasdfx_pkt *pkt = (struct rasdfx_pkt *)buf; + uint32_t reg_offs, i; + ssize_t write_cnt; - fp = fopen(file_path, "a"); - if (fp == NULL) { - HIKP_ERROR_PRINT("open %s failed, errno is %d\n", file_path, errno); - return -errno; - } + rasdfx_wr2buf(s, "SocID: %u\n\n", pkt->dw0.soc_id); - 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; - } + 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; + } - printf("dump dfx 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); + 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"); - if (fclose(fp)) { - HIKP_ERROR_PRINT("close %s failed, errno is %d\n", file_path, errno); - return -errno; - } + 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; + } - s->len = 0; + s->buf_offs = 0; + pkt = (struct rasdfx_pkt *)((uint32_t *)pkt + f_header->pkt_size_dwords); + } return 0; } -static int file_seq_init(struct file_seq *s, uint32_t size) +static int ras_dump_data_into_buf(struct ras_dump_cmd *cmd, uint32_t *buf, uint32_t buf_max) { - if (!size) - return -1; + 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; + } - s->buffer_size = size; - s->len = 0; - s->buffer = (char*)malloc(s->buffer_size); - if (!s->buffer) - return -1; + if (copy_len + data_num > buf_max) { + HIKP_ERROR_PRINT("response data is more than expected\n"); + hikp_cmd_free(&cmd_ret); + return -1; + } - return 0; -} + memcpy(buf + copy_len, cmd_ret->rsp_data, data_num * REP_DATA_BLK_SIZE); + copy_len += data_num; + hikp_cmd_free(&cmd_ret); + } -static void file_seq_destroy(struct file_seq *s) -{ - free(s->buffer); - s->buffer = NULL; + return 0; } -static void ras_rsp_init(struct ras_rsp *ras_rsp_data) +static int ras_get_rasdfx_payload(struct ras_dump_cmd *cmd, struct rasdfx_file_header *f_header) { - 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; + uint32_t buf_max = f_header->pkt_size_dwords * f_header->pkt_num; + uint32_t *total_buf; + struct file_seq s; + int ret; - 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)); -} + total_buf = (uint32_t *)malloc(buf_max * REP_DATA_BLK_SIZE); + if (!total_buf) { + HIKP_ERROR_PRINT("malloc total_buf failed\n"); + return -ENOMEM; + } -static int parse_packet_buffer_data(struct ras_rsp *ras_rsp_data, - uint32_t pkt_reg_num, struct file_seq *s) -{ - int ret; + ret = ras_dump_data_into_buf(cmd, total_buf, buf_max); + if (ret) + goto release_total_buf; - if (ras_rsp_data->packet_buffer_len) { - uint32_t rest_pkt_length; + ret = ras_open_rasdfx_file_seq(&s, f_header); + if (ret) + goto release_total_buf; - rest_pkt_length = pkt_reg_num - ras_rsp_data->packet_buffer_len; - if (rest_pkt_length > ras_rsp_data->rsp_data_num) { - HIKP_ERROR_PRINT("The rest of packet_buffer is %u and rsp_data_num is %u, \ - memcpy will out of bounds\n", - rest_pkt_length, ras_rsp_data->rsp_data_num); - return -1; - } - 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; -} + ret = ras_parse_rasdfx_payload(&s, total_buf, f_header); -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; + ras_close_rasdfx_file_seq(&s); +release_total_buf: + free(total_buf); + 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 ras_data_dump(void) { - 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: %u\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; + struct ras_dump_cmd cmd = { .cmd_type = DUMP_DFX }; + struct rasdfx_file_header f_header; + int ret; + + ret = ras_get_rasdfx_header(&cmd, &f_header); + if (ret) + return ret; + + if (f_header.head_magic != DFX_DATA_DUMPED_MAGIC) { + HIKP_ERROR_PRINT("data does not exist or has been cleared.\n"); + return -1; + } + + if (!ras_check_header(&f_header)) + return -1; + + return ras_get_rasdfx_payload(&cmd, &f_header); } -int ras_data_dump(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; - - 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 || - header.pkt_length > MAX_DFX_PACKET_LEN * sizeof(uint32_t)) { - 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; -} + ret = ras_get_rasdfx_header(&cmd, &f_header); + if (ret) + return ret; + 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 b54efce..a5e8749 100644 --- a/ras/ras_func/ras_dump_data.h +++ b/ras/ras_func/ras_dump_data.h @@ -11,78 +11,59 @@ * 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 <stdint.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 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_size_dwords; // 单个packet内DWord个数，单位4bytes + uint32_t reserved; }; -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 - -#define DFX_DATA_IS_CLEARED 0 - -#define DFX_FILE_SINGLE_PACKET_HEAD_SIZE 256 -#define DFX_FILE_SINGLE_REG_SIZE 10 +enum ras_dump_cmd_type { + DUMP_DFX, + DUMP_CLEAR + }; +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(struct tool_ras_cmd *cmd); -int ras_data_clear(struct tool_ras_cmd *cmd); +int ras_data_dump(void); +int ras_data_clear(void); -#endif /* RAS_DUMP_REG_H */ +#endif /* RAS_DUMP_DATA_H */ diff --git a/ras/user_cmd/ras_cmd_dump.c b/ras/user_cmd/ras_cmd_dump.c index f8ae828..e0df98f 100644 --- a/ras/user_cmd/ras_cmd_dump.c +++ b/ras/user_cmd/ras_cmd_dump.c @@ -13,11 +13,12 @@ #include <stdint.h> #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); - else - return -EINVAL; + if (cmd_type == DUMP_CLEAR) + return ras_data_clear(); + else + 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 a999b8a..0000000 --- a/ras/user_cmd/ras_tools_include.h +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (c) 2022 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.33.0