From e30165ff0c434378722de631d8be4cd34763817c Mon Sep 17 00:00:00 2001 From: Xingui Yang Date: Tue, 27 Aug 2024 11:02:55 +0800 Subject: [PATCH 1/9] hikptool: Support for info collect Add the option of information collection and used to collect full information from each module, such as imp, serdes, pcie sas, sata, nic, roce, acc, socip, as follow. 1. Help for collect info, e.g. hikptool info_collect -h/--help 2. Collect imp info, e.g. hikptool info_collect -/--imp 3. Collect all info, e.g. hikptool info_collect -/--all Signed-off-by: Xingui Yang --- CMakeLists.txt | 1 + info_collect/hikp_collect.h | 53 ++ info_collect/hikp_collect_acc.c | 237 ++++++++ info_collect/hikp_collect_common.c | 258 +++++++++ info_collect/hikp_collect_imp.c | 133 +++++ info_collect/hikp_collect_lib.c | 508 ++++++++++++++++++ info_collect/hikp_collect_lib.h | 61 +++ info_collect/hikp_collect_main.c | 274 ++++++++++ info_collect/hikp_collect_nic.c | 368 +++++++++++++ info_collect/hikp_collect_pcie.c | 215 ++++++++ info_collect/hikp_collect_roce.c | 488 +++++++++++++++++ info_collect/hikp_collect_sas.c | 453 ++++++++++++++++ info_collect/hikp_collect_serdes.c | 244 +++++++++ info_collect/hikp_collect_socip.c | 272 ++++++++++ info_collect/hikp_collect_socip.h | 238 ++++++++ net/nic/nic_dfx/hikp_nic_dfx.c | 11 +- net/nic/nic_dfx/hikp_nic_dfx.h | 3 + net/nic/nic_fd/hikp_nic_fd.c | 11 +- net/nic/nic_fd/hikp_nic_fd.h | 4 + net/nic/nic_fec/hikp_nic_fec.c | 4 +- net/nic/nic_fec/hikp_nic_fec.h | 2 + net/nic/nic_ft/hikp_nic_port_fault.c | 4 +- net/nic/nic_ft/hikp_nic_port_fault.h | 2 + net/nic/nic_gro/hikp_nic_gro.c | 4 +- net/nic/nic_gro/hikp_nic_gro.h | 2 + net/nic/nic_info/hikp_nic_info.c | 4 +- net/nic/nic_info/hikp_nic_info.h | 2 + net/nic/nic_log/hikp_nic_log.c | 39 +- net/nic/nic_log/hikp_nic_log.h | 7 + net/nic/nic_mac/hikp_nic_mac_dump.c | 28 +- net/nic/nic_mac/hikp_nic_mac_dump.h | 11 + net/nic/nic_mac/hikp_nic_port.c | 18 + net/nic/nic_mac/hikp_nic_port.h | 6 + net/nic/nic_mac/hikp_nic_xsfp.c | 23 + net/nic/nic_mac/hikp_nic_xsfp.h | 6 + net/nic/nic_ncsi/hikp_nic_ncsi.c | 18 + net/nic/nic_ncsi/hikp_nic_ncsi.h | 6 + net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c | 4 +- net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h | 2 + net/nic/nic_ppp/hikp_nic_ppp.c | 11 +- net/nic/nic_ppp/hikp_nic_ppp.h | 3 + net/nic/nic_qos/hikp_nic_qos.c | 22 +- net/nic/nic_qos/hikp_nic_qos.h | 10 +- net/nic/nic_queue/hikp_nic_queue.c | 12 +- net/nic/nic_queue/hikp_nic_queue.h | 4 + net/nic/nic_rss/hikp_nic_rss.c | 9 +- net/nic/nic_rss/hikp_nic_rss.h | 3 + net/nic/nic_torus/hikp_nic_torus.c | 4 +- net/nic/nic_torus/hikp_nic_torus.h | 2 + net/roce/roce_bond/hikp_roce_bond.c | 8 +- net/roce/roce_bond/hikp_roce_bond.h | 3 + net/roce/roce_caep/hikp_roce_caep.c | 13 +- net/roce/roce_caep/hikp_roce_caep.h | 4 + .../roce_global_cfg/hikp_roce_global_cfg.c | 8 +- .../roce_global_cfg/hikp_roce_global_cfg.h | 3 + net/roce/roce_gmv/hikp_roce_gmv.c | 13 +- net/roce/roce_gmv/hikp_roce_gmv.h | 4 + net/roce/roce_mdb/hikp_roce_mdb.c | 13 +- net/roce/roce_mdb/hikp_roce_mdb.h | 5 + net/roce/roce_pkt/hikp_roce_pkt.c | 8 +- net/roce/roce_pkt/hikp_roce_pkt.h | 3 + net/roce/roce_qmm/hikp_roce_qmm.c | 18 +- net/roce/roce_qmm/hikp_roce_qmm.h | 5 + net/roce/roce_rst/hikp_roce_rst.c | 8 +- net/roce/roce_rst/hikp_roce_rst.h | 3 + net/roce/roce_scc/hikp_roce_scc.c | 19 +- net/roce/roce_scc/hikp_roce_scc.h | 6 +- net/roce/roce_timer/hikp_roce_timer.c | 8 +- net/roce/roce_timer/hikp_roce_timer.h | 3 + net/roce/roce_trp/hikp_roce_trp.c | 24 +- net/roce/roce_trp/hikp_roce_trp.h | 7 +- net/roce/roce_tsp/hikp_roce_tsp.c | 28 +- net/roce/roce_tsp/hikp_roce_tsp.h | 7 +- pcie/func_lib/pcie_func/pcie_link_ltssm.c | 2 +- pcie/func_lib/pcie_func/pcie_link_ltssm.h | 1 + pcie/func_lib/pcie_func/pcie_reg_dump.c | 7 +- pcie/func_lib/pcie_func/pcie_reg_dump.h | 4 + pcie/func_lib/pcie_func/pcie_statistics.c | 2 +- pcie/func_lib/pcie_func/pcie_statistics.h | 2 + sas/sas_func/sas_common.h | 2 +- serdes/hikp_serdes.c | 215 ++++---- serdes/hikp_serdes.h | 4 +- socip/hikp_socip.h | 1 + socip/hikp_socip_dumpreg.c | 2 +- tool_lib/tool_lib.c | 40 ++ tool_lib/tool_lib.h | 16 + 86 files changed, 4433 insertions(+), 190 deletions(-) create mode 100644 info_collect/hikp_collect.h create mode 100644 info_collect/hikp_collect_acc.c create mode 100644 info_collect/hikp_collect_common.c create mode 100644 info_collect/hikp_collect_imp.c create mode 100644 info_collect/hikp_collect_lib.c create mode 100644 info_collect/hikp_collect_lib.h create mode 100644 info_collect/hikp_collect_main.c create mode 100644 info_collect/hikp_collect_nic.c create mode 100644 info_collect/hikp_collect_pcie.c create mode 100644 info_collect/hikp_collect_roce.c create mode 100644 info_collect/hikp_collect_sas.c create mode 100644 info_collect/hikp_collect_serdes.c create mode 100644 info_collect/hikp_collect_socip.c create mode 100644 info_collect/hikp_collect_socip.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 4fb82ca..f28a870 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,6 +38,7 @@ file(GLOB_RECURSE HIKPTOOL_SRC ${CMAKE_CURRENT_SOURCE_DIR}/serdes/*.c ${CMAKE_CURRENT_SOURCE_DIR}/socip/*.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/info_collect/hikp_collect.h b/info_collect/hikp_collect.h new file mode 100644 index 0000000..28aa5a4 --- /dev/null +++ b/info_collect/hikp_collect.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2024 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_COLLECT_H +#define HIKP_COLLECT_H + +#define GROUP_SAS "sas" +#define GROUP_SATA "sata" +#define GROUP_ACC "acc" +#define GROUP_SOCIP "socip" +#define GROUP_NIC "nic" +#define GROUP_ROCE "roce" +#define GROUP_PCIE "pcie" +#define GROUP_IMP "imp" +#define GROUP_COMMON "common" +#define GROUP_SERDES "serdes" + +enum info_collect_type { + COLLECT_ACC, + COLLECT_IMP, + COLLECT_NIC, + COLLECT_PCIE, + COLLECT_ROCE, + COLLECT_SAS, + COLLECT_SATA, + COLLECT_SERDES, + COLLECT_SOCIP, + COLLECT_ALL, + COLLECT_UNKNOWN_TYPE, +}; + +void collect_sas_log(void); +void collect_sata_log(void); +void collect_acc_log(void); +void collect_socip_log(void); +void collect_common_log(void); +void collect_nic_log(void); +void collect_roce_log(void); +void collect_pcie_info(void); +void collect_imp_log(void); +void collect_serdes_log(void); + +#endif /* HIKP_COLLECT_H */ diff --git a/info_collect/hikp_collect_acc.c b/info_collect/hikp_collect_acc.c new file mode 100644 index 0000000..e0f3918 --- /dev/null +++ b/info_collect/hikp_collect_acc.c @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2024 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" + +struct info_collect_cmd acc_cmd_arr[] = { + { + .group = GROUP_ACC, + .log_name = "uadk_version", + .args = {"uadk_tool", "dfx", "--version", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "openssl_version", + .args = {"openssl", "version", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "openssl3_version", + .args = {"openssl3", "version", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "qemu_version", + .args = {"qemu-system-aarch64", "-version", NULL}, + }, +}; + +struct info_collect_cmd acc_cmd_copy[] = { + { + .group = GROUP_ACC, + .log_name = "uadk", + .args = {"cp", "-rf", "/var/log/uadk.log", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_sec", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_sec2/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_sec", + .args = {"cp", "-rf", "/sys/module/hisi_sec2/parameters/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_hpre", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_hpre/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_hpre", + .args = {"cp", "-rf", "/sys/module/hisi_hpre/parameters/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_zip", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_zip/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_zip", + .args = {"cp", "-rf", "/sys/module/hisi_zip/parameters/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_trng", + .args = {"cp", "-rf", "/sys/module/hisi_trng_v2/parameters/", NULL}, + }, +}; + +struct info_collect_cmd acc_copy_link[] = { + { + .group = GROUP_ACC, + .log_name = "uacce", + .args = {"cp", "-rf", "/sys/class/uacce", NULL}, + } +}; + +static int acc_cmd_mkdir(char *root_path, char *src_patch) +{ + char dir_path[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + /* mkdir for log sub source */ + ret = snprintf(dir_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", + root_path, src_patch); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create dir path failed: %d\n", ret); + return -EINVAL; + } + + ret = tool_mk_dir((const char *)dir_path); + if (ret) + return ret; + + return 0; +} + +static int acc_collect_file(struct info_collect_cmd *acc_cmd, char *root_path, char *dev_path) +{ + char sub_src_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char save_path[LOG_FILE_PATH_MAX_LEN] = {0}; + struct info_collect_cmd tmp_cmd = {0}; + char *source_path = acc_cmd->args[ARGS_IDX2]; + char *sub_group = acc_cmd->log_name; + int ret; + + ret = snprintf(sub_src_path, LOG_FILE_PATH_MAX_LEN, "%s/%s/", + source_path, dev_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create sub source path failed: %d\n", ret); + return -EINVAL; + } + if (access(sub_src_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access sub source path: %s\n", sub_src_path); + return -ENOENT; + } + + ret = snprintf(save_path, LOG_FILE_PATH_MAX_LEN, "%s/%s/%s/", + root_path, sub_group, dev_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create save path failed: %d\n", ret); + return -EINVAL; + } + + tmp_cmd.group = acc_cmd->group; + tmp_cmd.log_name = acc_cmd->log_name; + tmp_cmd.args[ARGS_IDX0] = acc_cmd->args[ARGS_IDX0]; + tmp_cmd.args[ARGS_IDX1] = acc_cmd->args[ARGS_IDX1]; + tmp_cmd.args[ARGS_IDX2] = sub_src_path; + tmp_cmd.args[ARGS_IDX3] = save_path; + tmp_cmd.args[ARGS_IDX4] = NULL; + + ret = hikp_collect_exec((void *)&tmp_cmd); + if (ret) + return ret; + + return 0; +} + +static int acc_save_link_files(struct info_collect_cmd *link_cmd) +{ + char root_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char *source_path = link_cmd->args[ARGS_IDX2]; + char *sub_group = link_cmd->log_name; + struct dirent *dev_dir; + DIR *link_dir; + int ret; + + if (strcmp(link_cmd->args[ARGS_IDX0], "cp") != 0) { + HIKP_ERROR_PRINT("input cmd failed: %s.\n", link_cmd->args[ARGS_IDX0]); + return -EINVAL; + } + + ret = hikp_get_file_path(root_path, LOG_FILE_PATH_MAX_LEN, link_cmd->group); + if (ret < 0) { + HIKP_ERROR_PRINT("get save path fail: %d\n", ret); + return ret; + } + + if (source_path == NULL || access(source_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access source path: %s\n", source_path); + return -ENOENT; + } + + ret = acc_cmd_mkdir(root_path, sub_group); + if (ret) + return ret; + + link_dir = opendir(source_path); + if (!link_dir) { + HIKP_ERROR_PRINT("input source file dir is error!\n"); + return -ENOENT; + } + + /* 1 is sizeof ".", 2 is sizeof ".." */ + while ((dev_dir = readdir(link_dir)) != NULL) { + if (!strncmp(dev_dir->d_name, ".", 1) || + !strncmp(dev_dir->d_name, "..", sizeof(".."))) + continue; + + ret = acc_collect_file(link_cmd, root_path, dev_dir->d_name); + if (ret) + goto free_dir; + } + + closedir(link_dir); + return 0; + +free_dir: + closedir(link_dir); + return ret; +} + +void collect_acc_log(void) +{ + int i, asize; + int ret; + + asize = (int)HIKP_ARRAY_SIZE(acc_cmd_arr); + for (i = 0; i < asize; i++) { + ret = hikp_collect_log(acc_cmd_arr[i].group, acc_cmd_arr[i].log_name, + hikp_collect_exec, (void *)&acc_cmd_arr[i]); + if (ret) + HIKP_ERROR_PRINT("collect_acc_log arr failed: %d\n", ret); + } + + asize = (int)HIKP_ARRAY_SIZE(acc_copy_link); + for (i = 0; i < asize; i++) { + ret = acc_save_link_files(&acc_copy_link[i]); + if (ret) + HIKP_ERROR_PRINT("collect_acc_log link copy failed: %d\n", ret); + } + + asize = (int)HIKP_ARRAY_SIZE(acc_cmd_copy); + for (i = 0; i < asize; i++) { + ret = hikp_save_files(&acc_cmd_copy[i]); + if (ret) + HIKP_ERROR_PRINT("collect_acc_log copy failed: %d\n", ret); + } +} diff --git a/info_collect/hikp_collect_common.c b/info_collect/hikp_collect_common.c new file mode 100644 index 0000000..413aac1 --- /dev/null +++ b/info_collect/hikp_collect_common.c @@ -0,0 +1,258 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" + +static int software_version_exec(void *data) +{ + const struct info_collect_cmd software_version_cmds[] = { + { + .args = {"uname", "-a", NULL}, + }, + { + .log_name = "os-release", + .args = {"cat", "/etc/*release", NULL}, + }, + { + .log_name = "os-latest", + .args = {"cat", "/etc/*latest", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(software_version_cmds); + for (i = 0; i < size; i++) { + if (!strcmp(software_version_cmds[i].args[ARGS_IDX0], "cat")) + ret = hikp_collect_cat_glob_exec((void *)&software_version_cmds[i]); + else + ret = hikp_collect_exec((void *)&software_version_cmds[i]); + + if (ret) + HIKP_ERROR_PRINT("collect software_version_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static int mem_info_exec(void *data) +{ + const struct info_collect_cmd mem_info_cmds[] = { + { + .args = {"cat", "/proc/meminfo", NULL}, + }, + { + .args = {"free", "-m", NULL}, + }, + { + .args = {"vmstat", NULL}, + }, + { + .args = {"cat", "/proc/iomem", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(mem_info_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&mem_info_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect mem_info_cmds[%zu] log failed: %d\n", i, ret); + } + + return 0; +} + +static int process_info_exec(void *data) +{ + const struct info_collect_cmd process_info_cmds[] = { + { + .args = {"ps", "euf", NULL}, + }, + { + .args = {"ps", "aux", NULL}, + }, + { + .args = {"top", "-bn", "1", NULL}, + }, + { + .args = {"mpstat", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(process_info_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&process_info_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect process_info_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static int config_info_exec(void *data) +{ + struct info_collect_cmd config_info_cmds[] = { + { + .args = {"cat", "/proc/cmdline", NULL}, + }, + { + .args = {"getconf", "PAGE_SIZE", NULL}, + }, + { + .group = GROUP_COMMON, + .log_name = "config", + .args = {"cp", "-f", "/boot/config-*", NULL}, + }, + { + .group = GROUP_COMMON, + .log_name = "smmu", + .args = {"cp", "-rf", "/sys/class/iommu", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(config_info_cmds); + for (i = 0; i < size; i++) { + char *log_name = config_info_cmds[i].log_name; + + if (log_name && !strcmp(log_name, "config")) + ret = hikp_collect_cp_glob_exec((void *)&config_info_cmds[i]); + else if (log_name && !strcmp(log_name, "smmu")) + ret = hikp_save_files(&config_info_cmds[i]); + else + ret = hikp_collect_exec((void *)&config_info_cmds[i]); + + if (ret) + HIKP_ERROR_PRINT("collect process_info_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static int service_info_exec(void *data) +{ + const struct info_collect_cmd service_info_cmds[] = { + { + .args = {"service", "iptables", "status", NULL}, + }, + { + .args = {"service", "irqbalance", "status", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(service_info_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&service_info_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect service_info_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static void collect_software_info(void) +{ + int ret; + + ret = hikp_collect_log(GROUP_COMMON, "software_version", software_version_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("software_version_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "mem_info", mem_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("mem_info_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "process_info", process_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("process_info_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "config_info", config_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("config_info_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "service_info", service_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("service_info_exec failed: %d\n", ret); +} + +static int hardware_info_exec(void *data) +{ + const struct info_collect_cmd hardware_cmds[] = { + { + .args = {"cat", MIDR_EL1_PATH, NULL}, + }, + { + .args = {"cat", "/sys/bus/cpu/devices/cpu0/cpufreq/scaling_governor", NULL}, + }, + { + .args = {"cat", "/sys/devices/system/cpu/online", NULL}, + }, + { + .args = {"numactl", "-H", NULL}, + }, + { + .args = {"numastat", NULL}, + }, + { + .args = {"lscpu", NULL}, + }, + { + .args = {"dmidecode", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(hardware_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&hardware_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect hardware_cmds[%zu] log failed: %d\n", i, ret); + } + + return 0; +} + +static void collect_hardware_info(void) +{ + int ret; + + ret = hikp_collect_log(GROUP_COMMON, "hardware_info", hardware_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("hardware_info_exec failed: %d\n", ret); +} + +void collect_common_log(void) +{ + collect_software_info(); + collect_hardware_info(); +} diff --git a/info_collect/hikp_collect_imp.c b/info_collect/hikp_collect_imp.c new file mode 100644 index 0000000..296cf07 --- /dev/null +++ b/info_collect/hikp_collect_imp.c @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_nic_log.h" +#include "hikp_nic_mac_dump.h" +#include "hikp_nic_port.h" +#include "hikp_nic_xsfp.h" +#include "hikp_nic_ncsi.h" + +static int hikp_collect_nic_log_info(void *dev_name) +{ + struct info_collect_cmd nic_log_cmd = { + .group = GROUP_IMP, + .log_name = NULL, + .args = {"mv", NULL, NULL}, + }; + struct nic_log_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_log", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_log, (void *)¶m); + if (ret) { + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + return ret; + } + + nic_log_cmd.args[ARGS_IDX1] = (char *)hikp_info_collect_get_log_path(); + ret = hikp_move_files(&nic_log_cmd); + if (ret) + HIKP_ERROR_PRINT("collect imp log failed, %d\n", ret); + + return ret; +} + +static int hikp_collect_nic_port_info(void *dev_name) +{ + struct nic_port_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_port", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_port, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +static int hikp_collect_nic_xsfp_info(void *dev_name) +{ + struct nic_xsfp_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_xsfp", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_xsfp, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +static int hikp_collect_nic_mac_info(void *dev_name) +{ + struct nic_mac_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + param.module_name = "ALL"; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_mac", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_mac, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +static int hikp_collect_nic_ncsi_info(void *dev_name) +{ + struct nic_ncsi_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_ncsi", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_ncsi, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +void collect_imp_log(void) +{ + hikp_collect_all_nic_cmd_log(hikp_collect_nic_log_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_port_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_xsfp_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_mac_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_ncsi_info); +} diff --git a/info_collect/hikp_collect_lib.c b/info_collect/hikp_collect_lib.c new file mode 100644 index 0000000..bada846 --- /dev/null +++ b/info_collect/hikp_collect_lib.c @@ -0,0 +1,508 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include +#include +#include +#include +#include +#include +#include "tool_lib.h" + +static char log_save_path[LOG_FILE_PATH_MAX_LEN] = {0}; +static char g_collect_name[MAX_LOG_NAME_LEN] = {0}; + +static bool hikp_nic_drv_check(char *nic_name) +{ + char drv_path[LOG_FILE_PATH_MAX_LEN] = {0}; + struct dirent *ptr = NULL; + bool hns3_if = false; + DIR *dir = NULL; + int ret; + + ret = snprintf(drv_path, LOG_FILE_PATH_MAX_LEN, "%s%s/%s", HIKP_NIC_NAME_DIR, + nic_name, HIKP_NIC_DRV_DIR); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) + return false; + + if ((dir = opendir(drv_path)) == NULL) + return false; + + while ((ptr = readdir(dir)) != NULL) { + if (strcmp(ptr->d_name, HIKP_NIC_DRV_NAME) == 0) { + hns3_if = true; + break; + } + } + + closedir(dir); + return hns3_if; +} + +void hikp_collect_all_nic_cmd_log(collect_cmd_handler_t hikp_collect_one_nic_log) +{ + struct dirent *ptr = NULL; + DIR *dir = NULL; + int ret; + + if (!hikp_collect_one_nic_log) { + HIKP_ERROR_PRINT("Invalid parameters!\n"); + return; + } + + dir = opendir(HIKP_NIC_NAME_DIR); + if (!dir) { + HIKP_ERROR_PRINT("failed to open path!\n"); + return; + } + + while ((ptr = readdir(dir)) != NULL) { + if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0)) { + continue; + } else if (ptr->d_type == DT_LNK) { + if (hikp_nic_drv_check(ptr->d_name)) { + ret = hikp_collect_one_nic_log((void *)ptr->d_name); + if (ret) { + HIKP_WARN_PRINT("failed to collect log for: %s", ptr->d_name); + break; + } + } + } + } + + closedir(dir); +} + +static bool is_cmd_valid(struct info_collect_cmd *cmd, unsigned int args_num) +{ + unsigned int i; + + if (cmd == NULL || cmd->log_name == NULL || args_num == 0 || args_num >= ARGS_MAX_NUM) + return false; + + for (i = 0; i < args_num; i++) + if (cmd->args[i] == NULL) + return false; + + return true; +} + +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; + int ret; + + localtime_r(&time_seconds, &timeinfo); + if (name != NULL) + (void)snprintf((char *)collect_name, MAX_LOG_NAME_LEN, + "collect_%s_%04d%02d%02d%02d%02d%02d", + name, timeinfo.tm_year + START_YEAR, + timeinfo.tm_mon + 1, timeinfo.tm_mday, + timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec); + else + (void)snprintf((char *)collect_name, MAX_LOG_NAME_LEN, + "collect_%04d%02d%02d%02d%02d%02d", + timeinfo.tm_year + START_YEAR, timeinfo.tm_mon + 1, + timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, + timeinfo.tm_sec); + + ret = snprintf((char *)log_save_path, LOG_FILE_PATH_MAX_LEN, + HIKP_COLLECT_LOG_DIR_PATH"%s", collect_name); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) + return -EINVAL; + + if (!is_dir_exist((const char*)log_save_path)) { + if (tool_mk_dir((const char*)log_save_path)) { + HIKP_ERROR_PRINT("mkdir %s failed, errno is %d\n", + log_save_path, errno); + memset(log_save_path, 0, LOG_FILE_PATH_MAX_LEN); + return -ENOENT; + } + } + + ret = snprintf((char *)g_collect_name, MAX_LOG_NAME_LEN, "%s", collect_name); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) + return -EINVAL; + + return 0; +} + +static int hikp_get_save_path(char *file_path, unsigned int file_path_len) +{ + int ret; + + if (access(log_save_path, F_OK) != 0) + return -ENOENT; + + ret = snprintf((char *)file_path, file_path_len, "%s", log_save_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) + return -EINVAL; + + return 0; +} + +int hikp_get_file_path(char *file_path, uint32_t file_path_len, + char *group) +{ + char tmp_path[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + ret = hikp_get_save_path(tmp_path, LOG_FILE_PATH_MAX_LEN); + if (ret < 0) { + HIKP_ERROR_PRINT("get file save path failed: %d\n", ret); + return ret; + } + + if (group != NULL) + ret = snprintf(file_path, file_path_len, "%s/%s", + tmp_path, group); + else + ret = snprintf(file_path, file_path_len, "%s", + tmp_path); + + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create file path fail: %d\n", ret); + return -EINVAL; + } + + if (!is_dir_exist((const char*)file_path)) { + if (tool_mk_dir((const char*)file_path)) { + HIKP_ERROR_PRINT("mkdir %s failed: %d\n", + file_path, errno); + return -ENOENT; + } + } + + return 0; +} + +static int hikp_collect_cmd_exec(const struct info_collect_cmd *cmd) +{ + pid_t pid; + int status; + + pid = fork(); + if (pid == 0) { + /* + * When the command execution fails, exit the child + * process just like when it succeeds. + * */ + if (execvp(cmd->args[ARGS_IDX0], cmd->args) < 0) { + HIKP_ERROR_PRINT("execvp failed: %d\n", errno); + exit(EXIT_FAILURE); + } + } else if (pid > 0) { + /* Parent process */ + waitpid(pid, &status, 0); + } else { + HIKP_ERROR_PRINT("fork failed!\n"); + return -ECHILD; + } + + return 0; +} + +int hikp_collect_exec(void *data) +{ + struct info_collect_cmd *cmd = (struct info_collect_cmd *)data; + struct info_collect_cmd echo_cmd = {0}; + char result[MAX_LOG_NAME_LEN] = {0}; + int len = 0; + int ret; + int i; + + echo_cmd.args[ARGS_IDX0] = "echo"; + echo_cmd.args[ARGS_IDX1] = result; + echo_cmd.args[ARGS_IDX2] = NULL; + for (i = 0; i < ARGS_MAX_NUM && cmd->args[i] != NULL; i++) { + ret = snprintf(result + len, + MAX_LOG_NAME_LEN - len - 1, + "%s ", cmd->args[i]); + len += ret; + if (ret < 0 || len >= (MAX_LOG_NAME_LEN - 1)) { + HIKP_INFO_PRINT("Error getting command args"); + break; + } + } + + ret = hikp_collect_cmd_exec(&echo_cmd); + if (ret) + return ret; + + return hikp_collect_cmd_exec(cmd); +} + +int hikp_collect_log(char *group, char *log_name, collect_cmd_handler_t func, void *data) +{ + unsigned char file_name[MAX_LOG_NAME_LEN] = {0}; + char file_dir[LOG_FILE_PATH_MAX_LEN] = {0}; + char file_path[LOG_FILE_PATH_MAX_LEN] = {0}; + int stdout_fd = dup(STDOUT_FILENO); + int stderr_fd = dup(STDERR_FILENO); + FILE *log_file; + int ret; + + if (log_name == NULL) { + HIKP_ERROR_PRINT("log name is NULL"); + return -EINVAL; + } + + ret = generate_file_name(file_name, MAX_LOG_NAME_LEN, + (const unsigned char*)log_name); + if (ret < 0) + return ret; + + ret = hikp_get_file_path(file_dir, LOG_FILE_PATH_MAX_LEN, group); + if (ret < 0) + return ret; + + ret = snprintf(file_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", file_dir, file_name); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create log file path fail: %d\n", ret); + return -EINVAL; + } + + log_file = fopen(file_path, "a"); + if (log_file == NULL) { + HIKP_ERROR_PRINT("open %s failed.", file_path); + return -ENOENT; + } + + (void)chmod(file_path, S_IRUSR | S_IWUSR | S_IRGRP); + + fflush(stdout); + fflush(stderr); + + /* Copy the standard output and error information to log_file */ + dup2(fileno(log_file), STDOUT_FILENO); + dup2(fileno(log_file), STDERR_FILENO); + + ret = func(data); + + fflush(stdout); + fflush(stderr); + + /* Redirect stdout and stderr back to the terminal */ + dup2(stdout_fd, STDOUT_FILENO); + dup2(stderr_fd, STDERR_FILENO); + + fclose(log_file); + close(stdout_fd); + close(stderr_fd); + + return ret; +} + +int hikp_compress_log(void) +{ + char file_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char tar_name[LOG_FILE_PATH_MAX_LEN] = {0}; + struct info_collect_cmd tar_cmd = {0}; + struct info_collect_cmd rm_cmd = {0}; + int ret; + + ret = hikp_get_save_path(file_path, LOG_FILE_PATH_MAX_LEN); + if (ret < 0) { + HIKP_ERROR_PRINT("get save path fail: %d\n", ret); + return ret; + } + + ret = snprintf((char *)tar_name, LOG_FILE_PATH_MAX_LEN, "%s.tar.gz", + file_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create tar path fail: %d\n", ret); + return -EINVAL; + } + + tar_cmd.args[ARGS_IDX0] = "tar"; + tar_cmd.args[ARGS_IDX1] = "-zPcf"; + tar_cmd.args[ARGS_IDX2] = tar_name; + tar_cmd.args[ARGS_IDX3] = "-C"; + tar_cmd.args[ARGS_IDX4] = HIKP_COLLECT_LOG_DIR_PATH; + tar_cmd.args[ARGS_IDX5] = g_collect_name; + tar_cmd.args[ARGS_IDX6] = NULL; + + ret = hikp_collect_exec(&tar_cmd); + if (ret) + return ret; + + /* Delete the original log after the log is packaged. */ + rm_cmd.args[ARGS_IDX0] = "rm"; + rm_cmd.args[ARGS_IDX1] = "-rf"; + rm_cmd.args[ARGS_IDX2] = file_path; + rm_cmd.args[ARGS_IDX3] = NULL; + + return hikp_collect_exec(&rm_cmd); +} + +int hikp_move_files(struct info_collect_cmd *mv_cmd) +{ + char dest_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char tmp_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char *src_path = mv_cmd->args[ARGS_IDX1]; + char *sub_group = mv_cmd->log_name; + int ret; + + if (strcmp(mv_cmd->args[ARGS_IDX0], "mv") != 0) { + HIKP_ERROR_PRINT("input cmd failed: %s.\n", mv_cmd->args[ARGS_IDX0]); + return -EINVAL; + } + + if (src_path == NULL || access(src_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access source path: %s\n", src_path); + return -ENOENT; + } + + ret = hikp_get_file_path(tmp_path, LOG_FILE_PATH_MAX_LEN, mv_cmd->group); + if (ret < 0) { + HIKP_ERROR_PRINT("get destination path fail: %d\n", ret); + return ret; + } + + if (sub_group == NULL) + ret = snprintf(dest_path, LOG_FILE_PATH_MAX_LEN, "%s", tmp_path); + else + ret = snprintf(dest_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", + tmp_path, sub_group); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create destination path failed: %d\n", ret); + return -EINVAL; + } + + mv_cmd->args[ARGS_IDX2] = dest_path; + mv_cmd->args[ARGS_IDX3] = NULL; + + return hikp_collect_exec((void *)mv_cmd); +} + +int hikp_save_files(struct info_collect_cmd *save_cmd) +{ + char save_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char tmp_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char *source_path = save_cmd->args[ARGS_IDX2]; + char *sub_group = save_cmd->log_name; + int ret; + + if (strcmp(save_cmd->args[ARGS_IDX0], "cp") != 0) { + HIKP_ERROR_PRINT("input cmd failed: %s.\n", save_cmd->args[ARGS_IDX0]); + return -EINVAL; + } + + if (source_path == NULL || access(source_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access source path: %s\n", source_path); + return -ENOENT; + } + + ret = hikp_get_file_path(tmp_path, LOG_FILE_PATH_MAX_LEN, save_cmd->group); + if (ret < 0) { + HIKP_ERROR_PRINT("get save path fail: %d\n", ret); + return ret; + } + + if (sub_group == NULL) + ret = snprintf(save_path, LOG_FILE_PATH_MAX_LEN, "%s", tmp_path); + else + ret = snprintf(save_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", + tmp_path, sub_group); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create save path failed: %d\n", ret); + return -EINVAL; + } + + save_cmd->args[ARGS_IDX3] = save_path; + save_cmd->args[ARGS_IDX4] = NULL; + + return hikp_collect_exec((void *)save_cmd); +} + +int hikp_collect_cat_glob_exec(void *data) +{ + struct info_collect_cmd *cmd = (struct info_collect_cmd *)data; + glob_t glb_buff; + size_t i; + int ret; + + if (!is_cmd_valid(cmd, ARGS_IDX2)) + return -EINVAL; + + if (strcmp(cmd->args[ARGS_IDX0], "cat")) + return -EINVAL; + + ret = glob(cmd->args[ARGS_IDX1], GLOB_TILDE, NULL, &glb_buff); + if (ret) { + HIKP_ERROR_PRINT("failed to generate cat paths: %s\n", cmd->args[ARGS_IDX1]); + return ret; + } + + for (i = 0; i < glb_buff.gl_pathc; i++) { + cmd->args[ARGS_IDX1] = glb_buff.gl_pathv[i]; + ret = hikp_collect_exec((void *)cmd); + if(ret) + HIKP_INFO_PRINT("cat %s failed\n", glb_buff.gl_pathv[i]); + } + + globfree(&glb_buff); + + return 0; +} + +int hikp_collect_cp_glob_exec(void *data) +{ + struct info_collect_cmd *cmd = (struct info_collect_cmd *)data; + char log_name[MAX_LOG_NAME_LEN] = {0}; + char tmp[MAX_LOG_NAME_LEN] = {0}; + glob_t glb_buff; + size_t i; + int ret; + + if (!is_cmd_valid(cmd, ARGS_IDX3)) + return -EINVAL; + + if (strcmp(cmd->args[ARGS_IDX0], "cp")) + return -EINVAL; + + ret = glob(cmd->args[ARGS_IDX2], GLOB_TILDE, NULL, &glb_buff); + if (ret) { + HIKP_ERROR_PRINT("failed to generate cp paths: %s\n", cmd->args[ARGS_IDX2]); + return ret; + } + + ret = snprintf(tmp, MAX_LOG_NAME_LEN, "%s", cmd->log_name); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("log name is invalid\n"); + globfree(&glb_buff); + return -EINVAL; + } + + for (i = 0; i < glb_buff.gl_pathc; i++) { + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_%zu", tmp, i); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("create log name failed\n"); + globfree(&glb_buff); + return -EINVAL; + } + + cmd->log_name = log_name; + cmd->args[ARGS_IDX2] = glb_buff.gl_pathv[i]; + ret = hikp_save_files(cmd); + if(ret) + HIKP_INFO_PRINT("cp %s failed\n", glb_buff.gl_pathv[i]); + } + + globfree(&glb_buff); + + return 0; +} diff --git a/info_collect/hikp_collect_lib.h b/info_collect/hikp_collect_lib.h new file mode 100644 index 0000000..2c59bf0 --- /dev/null +++ b/info_collect/hikp_collect_lib.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2024 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_COLLECT_LIB_H +#define HIKP_COLLECT_LIB_H + +#ifndef NULL +#define NULL ((void *)0) +#endif + +#define ARGS_IDX0 0 +#define ARGS_IDX1 1 +#define ARGS_IDX2 2 +#define ARGS_IDX3 3 +#define ARGS_IDX4 4 +#define ARGS_IDX5 5 +#define ARGS_IDX6 6 +#define ARGS_IDX7 7 +#define ARGS_IDX8 8 +#define ARGS_IDX9 9 +#define ARGS_IDX10 10 +#define ARGS_IDX11 11 +#define ARGS_MAX_NUM 12 +#define LOG_FILE_PATH_MAX_LEN 512 +#define HIKP_COLLECT_LOG_DIR_PATH "/var/log/hikp/" +#define HIKP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) +#define HIKP_NIC_NAME_DIR "/sys/class/net/" +#define HIKP_NIC_DRV_DIR "device/driver/module/drivers/" +#define HIKP_NIC_DRV_NAME "pci:hns3" + +typedef int (*collect_cmd_handler_t)(void *); + +struct info_collect_cmd { + char *group; + char *log_name; + char *args[ARGS_MAX_NUM]; +}; + +int hikp_compress_log(void); +int hikp_create_save_path(const char *name); +int hikp_get_file_path(char *file_path, unsigned int file_path_len, + char *group); +int hikp_collect_exec(void *data); +int hikp_collect_log(char *group, char *log_name, + collect_cmd_handler_t func, void *data); +int hikp_move_files(struct info_collect_cmd *mv_cmd); +int hikp_save_files(struct info_collect_cmd *save_cmd); +int hikp_collect_cat_glob_exec(void *data); +int hikp_collect_cp_glob_exec(void *data); +void hikp_collect_all_nic_cmd_log(collect_cmd_handler_t hikp_collect_one_nic_log); +#endif /* HIKP_COLLECT_LIB_H */ diff --git a/info_collect/hikp_collect_main.c b/info_collect/hikp_collect_main.c new file mode 100644 index 0000000..c413346 --- /dev/null +++ b/info_collect/hikp_collect_main.c @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "tool_cmd.h" + +static enum info_collect_type g_info_collect_type = COLLECT_UNKNOWN_TYPE; +static enum info_collect_type get_info_collect_type(void) +{ + return g_info_collect_type; +} + +static void set_info_collect_type(enum info_collect_type type) +{ + g_info_collect_type = type; +} + +static int info_collect_acc(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_ACC); + return 0; +} + +static int info_collect_imp(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_IMP); + return 0; +} + +static int info_collect_nic(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_NIC); + return 0; +} + +static int info_collect_pcie(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_PCIE); + return 0; +} + +static int info_collect_roce(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_ROCE); + return 0; +} + +static int info_collect_sas(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SAS); + return 0; +} + +static int info_collect_sata(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SATA); + return 0; +} + +static int info_collect_serdes(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SERDES); + return 0; +} + +static int info_collect_socip(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SOCIP); + return 0; +} + +static int info_collect_all(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_ALL); + return 0; +} + +static void collect_all_log(void) +{ + collect_pcie_info(); + collect_acc_log(); + collect_imp_log(); + collect_nic_log(); + collect_roce_log(); + collect_sas_log(); + collect_sata_log(); + collect_serdes_log(); + collect_socip_log(); +} + +static int info_collect_excute_funs_call(uint32_t collect_type) +{ + const char *type_name[] = {"acc", "imp", "nic", "pcie", "roce", "sas", + "sata", "serdes", "socip", "all"}; + int ret; + + if (collect_type == COLLECT_UNKNOWN_TYPE) + return -EINVAL; + + ret = hikp_create_save_path(type_name[collect_type]); + if (ret) { + HIKP_ERROR_PRINT("create save path fail: %d\n", ret); + return ret; + } + + switch (collect_type) { + case COLLECT_ACC: + collect_acc_log(); + break; + case COLLECT_IMP: + collect_imp_log(); + break; + case COLLECT_NIC: + collect_nic_log(); + break; + case COLLECT_PCIE: + collect_pcie_info(); + break; + case COLLECT_ROCE: + collect_roce_log(); + break; + case COLLECT_SAS: + collect_sas_log(); + break; + case COLLECT_SATA: + collect_sata_log(); + break; + case COLLECT_SERDES: + collect_serdes_log(); + break; + case COLLECT_SOCIP: + collect_socip_log(); + break; + case COLLECT_ALL: + collect_all_log(); + break; + default: + return -EINVAL; + } + + collect_common_log(); + ret = hikp_compress_log(); + + return ret; +} + + +static void info_collect_execute(struct major_cmd_ctrl *self) +{ + const char *suc_msg[] = { + "collect acc info success.", + "collect imp info success.", + "collect nic info success.", + "collect pcie info success.", + "collect roce info success.", + "collect sas info success.", + "collect sata info success.", + "collect serdes info success.", + "collect socip info success.", + "collect all info success.", + }; + const char *err_msg[] = { + "collect acc info error.", + "collect imp info error.", + "collect nic info error.", + "collect pcie info error.", + "collect roce info error.", + "collect sas info error.", + "collect sata info error.", + "collect serdes info error.", + "collect socip info error.", + "collect all info error.", + "collect info failed, unknown type.", + }; + enum info_collect_type type; + int ret; + + type = get_info_collect_type(); + ret = info_collect_excute_funs_call(type); + set_info_collect_type(COLLECT_UNKNOWN_TYPE); + if (ret == 0) { + printf("%s\n", suc_msg[type]); + } else { + (void)snprintf(self->err_str, sizeof(self->err_str), "%s\n", err_msg[type]); + self->err_no = ret; + } +} + +static int info_collect_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", "-acc", "--acc", "collect acc info\n"); + printf(" %s, %-25s %s\n", "-imp", "--imp", "collect imp info\n"); + printf(" %s, %-25s %s\n", "-nic", "--nic", "collect nic info\n"); + printf(" %s, %-25s %s\n", "-pcie", "--pcie", "collect pcie info\n"); + printf(" %s, %-25s %s\n", "-roce", "--roce", "collect roce info\n"); + printf(" %s, %-25s %s\n", "-sas", "--sas", "collect sas info\n"); + printf(" %s, %-25s %s\n", "-sata", "--sata", "collect sata info\n"); + printf(" %s, %-25s %s\n", "-serdes", "--serdes", "collect serdes info\n"); + printf(" %s, %-25s %s\n", "-socip", "--socip", "collect socip info\n"); + printf(" %s, %-25s %s\n", "-all", "--all", "collect all info\n"); + printf("\n"); + + return 0; +} + +static void cmd_info_collect_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = info_collect_execute; + + cmd_option_register("-h", "--help", false, info_collect_help); + cmd_option_register("-acc", "--acc", false, info_collect_acc); + cmd_option_register("-imp", "--imp", false, info_collect_imp); + cmd_option_register("-nic", "--nic", false, info_collect_nic); + cmd_option_register("-pcie", "--pcie", false, info_collect_pcie); + cmd_option_register("-roce", "--roce", false, info_collect_roce); + cmd_option_register("-sas", "--sas", false, info_collect_sas); + cmd_option_register("-sata", "--sata", false, info_collect_sata); + cmd_option_register("-serdes", "--serdes", false, info_collect_serdes); + cmd_option_register("-socip", "--socip", false, info_collect_socip); + cmd_option_register("-all", "--all", false, info_collect_all); +} + +HIKP_CMD_DECLARE("info_collect", "information collect", cmd_info_collect_init); diff --git a/info_collect/hikp_collect_nic.c b/info_collect/hikp_collect_nic.c new file mode 100644 index 0000000..23c4e49 --- /dev/null +++ b/info_collect/hikp_collect_nic.c @@ -0,0 +1,368 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_nic_fd.h" +#include "hikp_nic_gro.h" +#include "hikp_nic_ppp.h" +#include "hikp_nic_qos.h" +#include "hikp_nic_queue.h" +#include "hikp_nic_rss.h" +#include "hikp_nic_torus.h" +#include "hikp_nic_fec.h" +#include "hikp_nic_dfx.h" +#include "hikp_nic_info.h" +#include "hikp_nic_notify_pkt.h" +#include "hikp_nic_port_fault.h" +#include "hikp_nic_mac_dump.h" + +static void collect_nic_debugfs_log(void) +{ + struct info_collect_cmd nic_cmd_copy = { + .group = GROUP_NIC, + .log_name = "debugfs", + .args = {"cp", "-rf", "/sys/kernel/debug/hns3/", NULL}, + }; + int ret; + + ret = hikp_save_files(&nic_cmd_copy); + if (ret) + HIKP_ERROR_PRINT("collect_nic_log debugfs failed, %d\n", ret); +} + +static int collect_hikp_nic_fd_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + /* collect nic_fd hw_info */ + printf("hikptool nic_fd -i %s -du hw_info\n", (char *)nic_name); + hikp_nic_set_fd_idx(NIC_FD_HW_INFO_DUMP, -1); + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_fd_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set bdf for %s.\n", (char *)nic_name); + return ret; + } + hikp_nic_fd_cmd_execute(&self); + + /* collect nic_fd rules and counters */ + printf("hikptool nic_fd -i %s -du rules -st 1\n", (char *)nic_name); + hikp_nic_set_fd_idx(NIC_FD_RULES_INFO_DUMP, 1); + hikp_nic_fd_cmd_execute(&self); + printf("hikptool nic_fd -i %s -du counter -st 1\n", (char *)nic_name); + hikp_nic_set_fd_idx(NIC_FD_COUNTER_STATS_DUMP, 1); + hikp_nic_fd_cmd_execute(&self); + + return 0; +} + +static int collect_hikp_nic_gro_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_gro -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_gro_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_gro_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_ppp_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"mac", "vlan", "mng", "promisc", "vlan_offload"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_ppp_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + for (i = NIC_MAC_TBL_DUMP; i <= NIC_VLAN_OFFLOAD_DUMP; ++i) { + printf("hikptool nic_ppp -i %s -du %s\n", (char *)nic_name, + sub_cmd_name[i - NIC_MAC_TBL_DUMP]); + hikp_nic_ppp_set_cmd_param(i-1); + hikp_nic_ppp_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_qos_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"pkt_buf", "dcb", "pause"}; + const char *dir_name[] = {"rx", "tx"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_qos_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + for (i = NIC_PACKET_BUFFER_DUMP; i <= NIC_PAUSE_DUMP; ++i) { + printf("hikptool nic_qos -i %s -g %s\n", (char *)nic_name, sub_cmd_name[i]); + hikp_nic_qos_set_cmd_feature_idx(i); + hikp_nic_qos_cmd_execute(&self); + } + + hikp_nic_qos_set_cmd_feature_idx(NIC_PFC_STORM_PARA_DUMP); + for (i = NIC_RX_QOS; i <= NIC_TX_QOS; ++i) { + printf("hikptool nic_qos -i %s -g pfc_storm_para -d %s\n", (char *)nic_name, + dir_name[i]); + hikp_nic_qos_set_cmd_direction(i); + hikp_nic_qos_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_queue_log(void *nic_name) +{ + const char *dir_name[] = {"tx", "rx"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int j, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_queue_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + printf("hikptool nic_queue -i %s -du queue_en -a on\n", (char *)nic_name); + hikp_nic_queue_cmd_set_param(QUEUE_EN_INFO, -1, NIC_QUEUE_DIR_UNKNOWN); + hikp_nic_queue_cmd_execute(&self); + printf("hikptool nic_queue -i %s -du func_map\n", (char *)nic_name); + hikp_nic_queue_cmd_set_param(QUEUE_FUNC_MAP, -1, NIC_QUEUE_DIR_UNKNOWN); + hikp_nic_queue_cmd_execute(&self); + + for (j = NIC_TX_QUEUE; j <= NIC_RX_QUEUE; ++j) { + printf("hikptool nic_queue -i %s -du basic_info -d %s -q 0\n", (char *)nic_name, + dir_name[j]); + hikp_nic_queue_cmd_set_param(QUEUE_BASIC_INFO, 0, j); + hikp_nic_queue_cmd_execute(&self); + printf("hikptool nic_queue -i %s -du intr_map -d %s -a on\n", (char *)nic_name, + dir_name[j]); + hikp_nic_queue_cmd_set_param(QUEUE_INTR_MAP, -1, j); + hikp_nic_queue_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_rss_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"algo", "key", "tuple", "reta", "tc_mode"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_rss_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + for (i = RSS_ALGO_DUMP; i <= RSS_TC_MODE_DUMP; ++i) { + printf("hikptool nic_rss -i %s -g %s\n", (char *)nic_name, sub_cmd_name[i]); + hikp_nic_rss_cmd_set_feature_idx(i); + hikp_nic_rss_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_torus_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_nic_torus_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + printf("hikptool nic_torus -i %s\n", (char *)nic_name); + hikp_nic_torus_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_fec_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_nic_fec_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + printf("hikptool nic_fec -i %s\n", (char *)nic_name); + hikp_nic_fec_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_dfx_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"SSU", "IGU_EGU", "PPP", "NCSI", "BIOS", "RCB", "TXDMA", + "MASTER"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_dfx_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + for (i = SSU_DFX_REG_DUMP; i <= MASTER_DFX_REG_DUMP; ++i) { + printf("hikptool nic_dfx -i %s -m %s\n", (char *)nic_name, sub_cmd_name[i]); + hikp_nic_dfx_set_cmd_para(i); + hikp_nic_dfx_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_info_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_info -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_info_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_info_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_notify_pkt_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_notify_pkt -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_notify_pkt_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_notify_pkt_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_port_fault_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_port_fault -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_port_fault_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_port_fault_cmd_execute(&self); + return 0; +} + +static int collect_one_nic_hikp_log_compact(char *net_name, char *module, collect_cmd_handler_t hikp_pfn) +{ + char log_name[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + ret = snprintf(log_name, LOG_FILE_PATH_MAX_LEN, "%s_%s", net_name, module); + if (ret < 0 || (uint32_t)ret >= LOG_FILE_PATH_MAX_LEN) + return -EINVAL; + + return hikp_collect_log(GROUP_NIC, log_name, hikp_pfn, (void *)net_name); +} + +static int collect_one_nic_hikp_log(void *net_name) +{ + struct collect_nic_hikp_log_meta { + const char *module_name; + collect_cmd_handler_t hikp_pfn; + } nic_hikp_log_meta[] = { + { "nic_fd", collect_hikp_nic_fd_log }, + { "nic_gro", collect_hikp_nic_gro_log }, + { "nic_ppp", collect_hikp_nic_ppp_log }, + { "nic_qos", collect_hikp_nic_qos_log }, + { "nic_queue", collect_hikp_nic_queue_log }, + { "nic_rss", collect_hikp_nic_rss_log }, + { "nic_torus", collect_hikp_nic_torus_log }, + { "nic_fec", collect_hikp_nic_fec_log }, + { "nic_dfx", collect_hikp_nic_dfx_log }, + { "nic_info", collect_hikp_nic_info_log }, + { "nic_notify_pkt", collect_hikp_nic_notify_pkt_log }, + { "nic_port_fault", collect_hikp_nic_port_fault_log }, + }; + size_t i; + int ret; + + for (i = 0; i < HIKP_ARRAY_SIZE(nic_hikp_log_meta); ++i) { + ret = collect_one_nic_hikp_log_compact((char *)net_name, + nic_hikp_log_meta[i].module_name, + nic_hikp_log_meta[i].hikp_pfn); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + nic_hikp_log_meta[i].module_name, ret); + } + + return 0; +} + +void collect_nic_log(void) +{ + collect_nic_debugfs_log(); + hikp_collect_all_nic_cmd_log(collect_one_nic_hikp_log); +} diff --git a/info_collect/hikp_collect_pcie.c b/info_collect/hikp_collect_pcie.c new file mode 100644 index 0000000..d3cd7ad --- /dev/null +++ b/info_collect/hikp_collect_pcie.c @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2024 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikptdev_plug.h" +#include "pcie_link_ltssm.h" +#include "pcie_statistics.h" +#include "pcie_common.h" +#include "pcie_reg_dump.h" + +#define PCIE_DEV_LEN 512 +#define PCIE_DEV_PATH "/sys/bus/pci/devices" +#define MAX_NIMBUS_NUM_ALL 8 + +/* Optimization barrier */ +#ifndef barrier +/* The "volatile" is due to gcc bugs */ +# define barrier() __asm__ __volatile__("": : :"memory") +#endif + +struct pcie_id_info { + uint32_t chip_id; + uint32_t port_id; +}; + +/* get pcie config space info */ +static void collect_pcie_common(char *pcie_dev_name) +{ + struct info_collect_cmd pcie_cmd_arr = {0}; + int ret; + + pcie_cmd_arr.group = GROUP_PCIE; + pcie_cmd_arr.log_name = pcie_dev_name; + pcie_cmd_arr.args[ARGS_IDX0] = "lspci"; + pcie_cmd_arr.args[ARGS_IDX1] = "-vvvxxxx"; + pcie_cmd_arr.args[ARGS_IDX2] = "-s"; + pcie_cmd_arr.args[ARGS_IDX3] = pcie_dev_name; + pcie_cmd_arr.args[ARGS_IDX4] = NULL; + ret = hikp_collect_log(pcie_cmd_arr.group, pcie_cmd_arr.log_name, + hikp_collect_exec, (void *)&pcie_cmd_arr); + if (ret) + HIKP_ERROR_PRINT("collect_pcie_common failed: %d\n", ret); +} + +static void collect_pcie_single_cfg(void) +{ + char dev_name[PCIE_DEV_LEN]; + struct dirent *ptr = NULL; + DIR *dir = NULL; + + if ((dir = opendir(PCIE_DEV_PATH)) == NULL) { + perror("failed to open path \n"); + return; + } + + while ((ptr = readdir(dir)) != NULL) { + if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0)) { + continue; + } else if (ptr->d_type == DT_LNK) { + memset(dev_name, 0, sizeof(dev_name)); + strncpy(dev_name, ptr->d_name, sizeof(dev_name) - 1); + dev_name[sizeof(dev_name) - 1] = '\0'; + collect_pcie_common(dev_name); + } + } + + closedir(dir); +} + +/* get pcie config tree info */ +static void collect_pcie_cfg_tree(void) +{ + struct info_collect_cmd pcie_cmd_arr = { + .group = GROUP_PCIE, + .log_name = "pcie_tree", + .args = {"lspci", "-tv", NULL}, + }; + int ret; + + ret = hikp_collect_log(pcie_cmd_arr.group, pcie_cmd_arr.log_name, + hikp_collect_exec, (void *)&pcie_cmd_arr); + if (ret) + HIKP_ERROR_PRINT("collect_pcie_cfg_tree failed: %d\n", ret); +} + +static int pcie_mv_dumplog(void) +{ + struct info_collect_cmd pcie_cmd_arr = { 0 }; + + pcie_cmd_arr.group = GROUP_PCIE; + pcie_cmd_arr.args[ARGS_IDX0] = "mv"; + pcie_cmd_arr.args[ARGS_IDX1] = dumpreg_log_file; + + return hikp_move_files(&pcie_cmd_arr); +} + +static int collect_pcie_local_info(void *data) +{ + struct pcie_id_info *info = (struct pcie_id_info *)data; + uint32_t port_id; + + port_id = info->port_id; + printf("chip_id:%u, port_id:%u\n", info->chip_id, port_id); + /* do dump action for each port */ + /* step 1 pcie trace */ + printf("hikptool pcie_trace -i %u -s\n", port_id); + (void)pcie_ltssm_trace_show(port_id); + /* step 2 pcie link status */ + printf("hikptool pcie_trace -i %u -f\n", port_id); + (void)pcie_ltssm_link_status_get(port_id); + /* step 3 pcie err cnt */ + printf("hikptool pcie_info -i %u -es\n", port_id); + (void)pcie_error_state_get(port_id); + /* step 4 pcie pm trace */ + printf("hikptool pcie_trace -i %u -pm\n", port_id); + (void)pcie_pm_trace(port_id); + + return 0; +} + +static int pcie_port_distribution_info(void *data) +{ + uint32_t chip_id = *(uint32_t *)(data); + int ret; + + printf("hikptool pcie_info -i %u -d\n", chip_id); + ret = pcie_port_distribution_get(chip_id); + if (ret) + HIKP_ERROR_PRINT("pcie_port_distribution_get failed: %d\n", ret); + return ret; +} + +static void collect_pcie_local(void) +{ + struct pcie_info_req_para req_data = { 0 }; + char name[MAX_LOG_NAME_LEN + 1] = { 0 }; + struct pcie_port_info *port_info = NULL; + struct hikp_cmd_ret *cmd_ret = NULL; + struct hikp_cmd_header req_header; + struct pcie_id_info info; + uint32_t port_num; + uint32_t port_id; + uint32_t i, j; + int ret; + + for (i = 0; i < MAX_NIMBUS_NUM_ALL; i++) { + req_data.interface_id = i; + + memset(name, 0, MAX_LOG_NAME_LEN + 1); + (void)snprintf(name, MAX_LOG_NAME_LEN, "pcie_local_nimbus_%u", i); + + ret = hikp_collect_log(GROUP_PCIE, name, pcie_port_distribution_info, (void *)&i); + if (ret) { + HIKP_INFO_PRINT("Nimbus:%u hikp_collect_log pcie_port_distribution_info unsuccessful!\n", i); + return; + } + + hikp_cmd_init(&req_header, PCIE_MOD, PCIE_INFO, INFO_DISTRIBUTION); + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + ret = port_distribution_rsp_data_check(cmd_ret, &port_num); + if (ret) { + HIKP_ERROR_PRINT("port_distribution_rsp_data_check failed: %d\n", ret); + hikp_cmd_free(&cmd_ret); + return; + } + + port_info = (struct pcie_port_info *)cmd_ret->rsp_data; + for (j = 0; j < port_num; j++) { + port_id = port_info->info_pair[j].port_id; + info.chip_id = i; + info.port_id = port_info->info_pair[j].port_id; + + memset(name, 0, MAX_LOG_NAME_LEN + 1); + (void)snprintf(name, MAX_LOG_NAME_LEN, "pcie_local_port_%u", j); + + ret = hikp_collect_log(GROUP_PCIE, name, collect_pcie_local_info, (void *)&info); + if (ret) { + HIKP_ERROR_PRINT("hikp_collect_log collect_pcie_local_info failed: %d\n", ret); + hikp_cmd_free(&cmd_ret); + return; + } + /* step 1 pcie dumpreg core level */ + (void)pcie_dumpreg_do_dump(port_id, DUMP_GLOBAL_LEVEL); + (void)pcie_mv_dumplog(); + /* step 2 pcie dumpreg port level */ + (void)pcie_dumpreg_do_dump(port_id, DUMP_PORT_LEVEL); + (void)pcie_mv_dumplog(); + } + hikp_cmd_free(&cmd_ret); + } +} + +void collect_pcie_info(void) +{ + collect_pcie_cfg_tree(); + + collect_pcie_single_cfg(); + + collect_pcie_local(); +} diff --git a/info_collect/hikp_collect_roce.c b/info_collect/hikp_collect_roce.c new file mode 100644 index 0000000..fffceb1 --- /dev/null +++ b/info_collect/hikp_collect_roce.c @@ -0,0 +1,488 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_roce_bond.h" +#include "hikp_roce_global_cfg.h" +#include "hikp_roce_rst.h" +#include "hikp_roce_timer.h" +#include "hikp_roce_pkt.h" +#include "hikp_roce_mdb.h" +#include "hikp_roce_caep.h" +#include "hikp_roce_qmm.h" +#include "hikp_roce_trp.h" +#include "hikp_roce_tsp.h" +#include "hikp_roce_scc.h" +#include "hikp_roce_gmv.h" + +static void collect_roce_devinfo_log(void) +{ + const struct info_collect_cmd roce_devinfo_cmd = { + .group = GROUP_ROCE, + .log_name = "ibv_devinfo", + .args = {"ibv_devinfo", NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_devinfo_cmd.group, + roce_devinfo_cmd.log_name, + hikp_collect_exec, + (void *)&roce_devinfo_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_devinfo_cmd.log_name, ret); +} + +static void collect_roce_cc_param_log(void) +{ + struct info_collect_cmd roce_cc_param_cmd = { + .group = GROUP_ROCE, + .log_name = "cc_param", + .args = {"cp", "-rf", + "/sys/class/infiniband/*/ports/1/cc_param", NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_cc_param_cmd.group, + roce_cc_param_cmd.log_name, + hikp_collect_cp_glob_exec, + (void *)&roce_cc_param_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_cc_param_cmd.log_name, ret); +} + +static void collect_roce_sw_stats_log(void) +{ + struct info_collect_cmd roce_sw_stats_cmd = { + .group = GROUP_ROCE, + .log_name = "sw_stat", + .args = {"cat", "/sys/kernel/debug/hns_roce/*/sw_stat/sw_stat", + NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_sw_stats_cmd.group, + roce_sw_stats_cmd.log_name, + hikp_collect_cat_glob_exec, + (void *)&roce_sw_stats_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_sw_stats_cmd.log_name, ret); +} + +static void collect_roce_res_stats_log(void) +{ + const struct info_collect_cmd roce_res_stats_cmd = { + .group = GROUP_ROCE, + .log_name = "rdma_res_show", + .args = {"rdma", "res", "show", NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_res_stats_cmd.group, + roce_res_stats_cmd.log_name, + hikp_collect_exec, + (void *)&roce_res_stats_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_res_stats_cmd.log_name, ret); +} + +static int collect_hikp_roce_gmv_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t gmv_index; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_gmv_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_gmv bdf for %s.\n", + (char *)nic_name); + return ret; + } + + for (gmv_index = 0; gmv_index < ROCE_MAX_HIKPTOOL_GMV; gmv_index++) { + printf("hikptool roce_gmv -i %s -x %u\n", (char *)nic_name, gmv_index); + hikp_roce_set_gmv_index(gmv_index); + hikp_roce_gmv_execute(&self); + } + + return 0; +} + +static int collect_hikp_roce_scc_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_scc_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_scc bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_scc -i %s -m COMMON\n", (char *)nic_name); + hikp_roce_set_scc_submodule(SCC_COMMON); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m DCQCN\n", (char *)nic_name); + hikp_roce_set_scc_submodule(DCQCN); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m DIP\n", (char *)nic_name); + hikp_roce_set_scc_submodule(DIP); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m HC3\n", (char *)nic_name); + hikp_roce_set_scc_submodule(HC3); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m LDCP\n", (char *)nic_name); + hikp_roce_set_scc_submodule(LDCP); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m CFG\n", (char *)nic_name); + hikp_roce_set_scc_submodule(CFG); + hikp_roce_scc_execute(&self); + + return 0; +} + +static int collect_hikp_roce_tsp_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t bankid; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_tsp_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_tsp bdf for %s.\n", + (char *)nic_name); + return ret; + } + + hikp_roce_set_tsp_submodule(TSP_COMMON); + for (bankid = 0; bankid <= MAX_TSP_BANK_NUM; bankid++) { + hikp_roce_set_tsp_bankid(bankid); + + printf("hikptool roce_tsp -i %s -m COMMON -b %u\n", (char *)nic_name, bankid); + hikp_roce_tsp_execute(&self); + } + + hikp_roce_set_tsp_submodule(TGP_TMP); + for (bankid = 0; bankid <= MAX_TGP_TMP_BANK_NUM; bankid++) { + hikp_roce_set_tsp_bankid(bankid); + + printf("hikptool roce_tsp -i %s -m TGP_TMP -b %u\n", (char *)nic_name, bankid); + hikp_roce_tsp_execute(&self); + } + + printf("hikptool roce_tsp -i %s -m TDP\n", (char *)nic_name); + hikp_roce_set_tsp_submodule(TDP); + hikp_roce_tsp_execute(&self); + + return 0; +} + +static int collect_hikp_roce_trp_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t bankid; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_trp_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_trp bdf for %s.\n", + (char *)nic_name); + return ret; + } + + hikp_roce_set_trp_submodule(TRP_COMMON); + for (bankid = 0; bankid <= TRP_MAX_BANK_NUM; bankid++) { + hikp_roce_set_trp_bankid(bankid); + + printf("hikptool roce_trp -i %s -m COMMON -b %u\n", (char *)nic_name, bankid); + hikp_roce_trp_execute(&self); + } + + printf("hikptool roce_trp -i %s -m TRP_RX\n", (char *)nic_name); + hikp_roce_set_trp_submodule(TRP_RX); + hikp_roce_trp_execute(&self); + + hikp_roce_set_trp_submodule(GEN_AC); + for (bankid = 0; bankid <= GAC_MAX_BANK_NUM; bankid++) { + hikp_roce_set_trp_bankid(bankid); + + printf("hikptool roce_trp -i %s -m GEN_AC -b %u\n", (char *)nic_name, bankid); + hikp_roce_trp_execute(&self); + } + + hikp_roce_set_trp_submodule(PAYL); + for (bankid = 0; bankid <= PAYL_MAX_BANK_NUM; bankid++) { + hikp_roce_set_trp_bankid(bankid); + + printf("hikptool roce_trp -i %s -m PAYL -b %u\n", (char *)nic_name, bankid); + hikp_roce_trp_execute(&self); + } + + return 0; +} + +static int collect_hikp_roce_qmm_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t bankid; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_qmm_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_qmm bdf for %s.\n", + (char *)nic_name); + return ret; + } + + for (bankid = 0; bankid <= QMM_BANK_NUM; bankid++) { + hikp_roce_set_qmm_bankid(bankid); + + printf("hikptool roce_qmm -i %s -b %u\n", (char *)nic_name, bankid); + hikp_roce_set_qmm_ext_flag(false); + hikp_roce_qmm_execute(&self); + + printf("hikptool roce_qmm -i %s -b %u -e\n", (char *)nic_name, bankid); + hikp_roce_set_qmm_ext_flag(true); + hikp_roce_qmm_execute(&self); + } + + return 0; +} + +static int collect_hikp_roce_caep_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_caep_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_caep bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_caep -i %s\n", (char *)nic_name); + hikp_roce_set_caep_mode(CAEP_ORIGIN); + hikp_roce_caep_execute(&self); + + printf("hikptool roce_caep -i %s -e\n", (char *)nic_name); + hikp_roce_set_caep_mode(CAEP_EXT); + hikp_roce_caep_execute(&self); + + return 0; +} + +static int collect_hikp_roce_mdb_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_mdb_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_mdb bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_mdb -i %s\n", (char *)nic_name); + hikp_roce_set_mdb_mode(ROCE_MDB_CMD); + hikp_roce_mdb_execute(&self); + + printf("hikptool roce_mdb -i %s -e\n", (char *)nic_name); + hikp_roce_set_mdb_mode(ROCE_MDB_CMD_EXT); + hikp_roce_mdb_execute(&self); + + return 0; +} + +static int collect_hikp_roce_pkt_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_pkt_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_pkt bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_pkt -i %s\n", (char *)nic_name); + hikp_roce_pkt_execute(&self); + + return 0; +} + +static int collect_hikp_roce_timer_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_timer_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_timer bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_timer -i %s\n", (char *)nic_name); + hikp_roce_timer_execute(&self); + + return 0; +} + +static int collect_hikp_roce_rst_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_rst_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_rst bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_rst -i %s\n", (char *)nic_name); + hikp_roce_rst_execute(&self); + + return 0; +} + +static int collect_hikp_roce_global_cfg_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_global_cfg_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce global_cfg bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_global_cfg -i %s\n", (char *)nic_name); + hikp_roce_global_cfg_execute(&self); + + return 0; +} + +static int collect_hikp_roce_bond_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_bond_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce bond bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_bond -i %s\n", (char *)nic_name); + hikp_roce_bond_execute(&self); + + return 0; +} + +static void collect_one_roce_hikp_log_compact(char *net_name, char *module, + collect_cmd_handler_t hikp_pfn) +{ + char log_name[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + ret = snprintf(log_name, LOG_FILE_PATH_MAX_LEN, "%s_%s", net_name, + module); + if (ret < 0 || (uint32_t)ret >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("failed to set %s path %d\n", net_name, ret); + return; + } + + ret = hikp_collect_log(GROUP_ROCE, log_name, hikp_pfn, (void *)net_name); + if (ret) + HIKP_ERROR_PRINT("failed to get %s info %d\n", net_name, ret); +} + +static int collect_one_roce_hikp_log(void *net_name) +{ + struct collect_roce_hikp_log_meta { + const char *module_name; + collect_cmd_handler_t hikp_pfn; + } roce_hikp_log_meta[] = { + { "roce_bond", collect_hikp_roce_bond_log }, + { "roce_global_cfg", collect_hikp_roce_global_cfg_log }, + { "roce_rst", collect_hikp_roce_rst_log }, + { "roce_timer", collect_hikp_roce_timer_log }, + { "roce_pkt", collect_hikp_roce_pkt_log }, + { "roce_mdb", collect_hikp_roce_mdb_log }, + { "roce_caep", collect_hikp_roce_caep_log }, + { "roce_qmm", collect_hikp_roce_qmm_log }, + { "roce_trp", collect_hikp_roce_trp_log }, + { "roce_tsp", collect_hikp_roce_tsp_log }, + { "roce_scc", collect_hikp_roce_scc_log }, + { "roce_gmv", collect_hikp_roce_gmv_log }, + }; + size_t i; + + for (i = 0; i < HIKP_ARRAY_SIZE(roce_hikp_log_meta); ++i) { + collect_one_roce_hikp_log_compact((char *)net_name, + roce_hikp_log_meta[i].module_name, + roce_hikp_log_meta[i].hikp_pfn); + } + + return 0; +} + +void collect_roce_log(void) +{ + collect_roce_devinfo_log(); + collect_roce_cc_param_log(); + collect_roce_sw_stats_log(); + collect_roce_res_stats_log(); + hikp_collect_all_nic_cmd_log(collect_one_roce_hikp_log); +} diff --git a/info_collect/hikp_collect_sas.c b/info_collect/hikp_collect_sas.c new file mode 100644 index 0000000..11022dc --- /dev/null +++ b/info_collect/hikp_collect_sas.c @@ -0,0 +1,453 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "sas_tools_include.h" +#include "sas_common.h" +#include "sas_analy_queue.h" +#include "sas_dump_reg.h" +#include "sas_read_dev.h" +#include "sas_read_errcode.h" +#include "sata_dump_reg.h" + +#define CHIP_MAX_SIZE 10 +#define DIE_MAX_SIZE 10 + +typedef int (*reg_info_func_t)(uint32_t, uint32_t); + +enum sata_dump_type { + SATA_DUMP_UNKNOWN = 0, + SATA_DUMP_GLOBAL, + SATA_DUMP_PORTX, +}; + +struct reg_op { + char *func_name; + reg_info_func_t func; +}; + +static int sas_sata_reg_log(void *data) +{ + struct reg_op *op = (struct reg_op *)data; + bool stop_flag = false; + uint32_t i, j; + int ret; + + for (i = 0; i < CHIP_MAX_SIZE; i++) { + for (j = 0; j < DIE_MAX_SIZE; j++) { + ret = op->func(i, j); + if (ret) { + HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", op->func_name, + i, j, ret); + /* + * Stop collection when the die id is 0, indicating that the + * current chip id is not supported. + * */ + if (j == 0) + stop_flag = true; + + break; + } + } + + if (stop_flag) + break; + } + + return 0; +} + +static void collect_sas_path_log(char *group) +{ + struct info_collect_cmd sas_path_cmd = { + .log_name = "ls_by-path", + .args = {"ls", "-l", "/dev/disk/by-path/", NULL}, + }; + int ret; + + ret = hikp_collect_log(group, sas_path_cmd.log_name, + hikp_collect_exec, (void *)&sas_path_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", sas_path_cmd.log_name, ret); +} + +static void collect_sas_phy_log(void) +{ + struct info_collect_cmd sas_phy_cmds[] = { + { + .log_name = "phy-invalid_dword_count", + .args = {"cat", "/sys/class/sas_phy/*/invalid_dword_count", NULL}, + }, + { + .log_name = "phy-negotiated_linkrate", + .args = {"cat", "/sys/class/sas_phy/*/negotiated_linkrate", NULL}, + }, + { + .log_name = "phy-enable", + .args = {"cat", "/sys/class/sas_phy/*/enable", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_phy_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SAS, sas_phy_cmds[i].log_name, + hikp_collect_cat_glob_exec, (void *)&sas_phy_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sas_phy_cmds[i].log_name, ret); + } +} + +static void collect_sas_host_log(void) +{ + struct info_collect_cmd sas_host_cmds[] = { + { + .log_name = "host-nr_hw_queues", + .args = {"cat", "/sys/class/scsi_host/host*/nr_hw_queues", NULL}, + }, + { + .log_name = "host-intr", + .args = {"cat", "/sys/class/scsi_host/host*/intr*", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_host_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SAS, sas_host_cmds[i].log_name, + hikp_collect_cat_glob_exec, (void *)&sas_host_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sas_host_cmds[i].log_name, ret); + } +} + +static void collect_sas_disk_log(void) +{ + struct info_collect_cmd sas_disk_cmds[] = { + { + .log_name = "disk-scheduler", + .args = {"cat", "/sys/block/sd*/queue/scheduler", NULL}, + }, + { + .log_name = "disk-max", + .args = {"cat", "/sys/block/sd*/queue/max*", NULL}, + }, + { + .log_name = "disk-state", + .args = {"cat", "/sys/block/sd*/device/state", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_disk_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SAS, sas_disk_cmds[i].log_name, + hikp_collect_cat_glob_exec, (void *)&sas_disk_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sas_disk_cmds[i].log_name, ret); + } +} + +static int collect_sas_lsscsi_log_exec(void *data) +{ + const struct info_collect_cmd sas_lsscsi_cmds[] = { + { + .args = {"lsscsi", "-lg", NULL}, + }, + { + .args = {"lsscsi", "-pvt", NULL}, + }, + { + .args = {"lsscsi", "-H", NULL}, + }, + }; + size_t i, size; + (void)data; + int ret; + + size = HIKP_ARRAY_SIZE(sas_lsscsi_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&sas_lsscsi_cmds[i]); + if (ret) + return ret; + } + + return 0; +} + +static void collect_sas_lsscsi_log(char *group) +{ + int ret; + + ret = hikp_collect_log(group, "lsscsi", collect_sas_lsscsi_log_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("collect lsscsi log failed: %d\n", ret); +} + +static void collect_sas_copy_files(void) +{ + struct info_collect_cmd sas_copy_cmds[] = { + { + .group = GROUP_SAS, + .log_name = "debugfs", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_sas/", NULL}, + }, + { + .group = GROUP_SAS, + .log_name = "parameters_hw", + .args = {"cp", "-rf", "/sys/module/hisi_sas_v3_hw/parameters/", NULL}, + }, + { + .group = GROUP_SAS, + .log_name = "parameters_main", + .args = {"cp", "-rf", "/sys/module/hisi_sas_main/parameters/", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_copy_cmds); + for (i = 0; i < size; i++) { + ret = hikp_save_files(&sas_copy_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("cp %s failed: %d\n", + sas_copy_cmds[i].args[ARGS_IDX2], ret); + } +} + +static int sas_anacq_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + int ret; + + printf("hikptool sas_anacq -c %u -d %u -s\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANACQ_NUM; + ret = sas_analy_cmd(&cmd); + if (ret) { + HIKP_ERROR_PRINT("collect cq number failed: %d\n", ret); + return ret; + } + + printf("hikptool sas_anacq -c %u -d %u -p\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANACQ_PRT; + ret = sas_analy_cmd(&cmd); + if (ret) + HIKP_ERROR_PRINT("collect cq read/write pointer failed: %d\n", ret); + + return ret; +} + +static int sas_anadq_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + int ret; + + printf("hikptool sas_anadq -c %u -d %u -s\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANADQ_NUM; + ret = sas_analy_cmd(&cmd); + if (ret) { + HIKP_ERROR_PRINT("collect dq num failed: %d\n", ret); + return ret; + } + + printf("hikptool sas_anadq -c %u -d %u -p\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANADQ_PRT; + ret = sas_analy_cmd(&cmd); + if (ret) + HIKP_ERROR_PRINT("collect dq read/write pointer failed: %d\n", ret); + + return ret; +} + +static int sas_dump_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + printf("hikptool sas_dump -c %u -d %u -g\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = DUMP_GLOBAL; + ret = sas_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump global failed: %d\n", ret); + return ret; + } + + for (i = 0; i <= SAS_MAX_PHY_NUM; i++) { + printf("hikptool sas_dump -c %u -d %u -p %u\n", cmd.chip_id, cmd.die_id, i); + cmd.sas_cmd_type = DUMP_PHYX; + cmd.phy_id = i; + ret = sas_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump phy %u failed: %d\n", i, ret); + return ret; + } + } + + printf("hikptool sas_dump -c %u -d %u -b\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = DUMP_AXI; + ret = sas_reg_dump(&cmd); + if (ret) + HIKP_ERROR_PRINT("dump axi failed: %d\n", ret); + + return ret; +} + +static int sas_dev_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + + printf("hikptool sas_dev -c %u -d %u -l\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = DEV_LINK; + return sas_dev(&cmd); +} + +static int sas_errcode_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + for (i = 0; i < SAS_MAX_ERR_NUM; i++) { + printf("hikptool sas_errcode -c %u -d %u -t %u\n", cmd.chip_id, cmd.die_id, i); + cmd.sas_cmd_type = i; + ret = sas_errcode_read(&cmd); + if (ret) { + HIKP_ERROR_PRINT("collect errcode %u info failed: %d\n", i, ret); + return ret; + } + } + + return 0; +} + +static void collect_sas_reg_log(void) +{ + struct reg_op op = {0}; + int ret; + + op.func = sas_anacq_info; + op.func_name = "sas_anacq_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_anacq", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_anadq_info; + op.func_name = "sas_anadq_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_anadq", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_dump_info; + op.func_name = "sas_dump_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_dump", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_dev_info; + op.func_name = "sas_dev_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_dev", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_errcode_info; + op.func_name = "sas_errcode_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_errcode", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); +} + +void collect_sas_log(void) +{ + collect_sas_phy_log(); + collect_sas_host_log(); + collect_sas_disk_log(); + collect_sas_copy_files(); + collect_sas_path_log(GROUP_SAS); + collect_sas_lsscsi_log(GROUP_SAS); + collect_sas_reg_log(); +} + +static int sata_reg_dump_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sata_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + printf("hikptool sata_dump -c %u -d %u -g\n", cmd.chip_id, cmd.die_id); + cmd.sata_cmd_type = SATA_DUMP_GLOBAL; + ret = sata_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump global failed: %d\n", ret); + return ret; + } + + cmd.sata_cmd_type = SATA_DUMP_PORTX; + for (i = 0; i <= 1; i++) { + printf("hikptool sata_dump -c %u -d %u -p %u\n", cmd.chip_id, cmd.die_id, i); + cmd.phy_id = i; + ret = sata_reg_dump(&cmd); + if (ret) { + HIKP_INFO_PRINT("dump port%u reg failed: %d\n", i, ret); + return ret; + } + } + + return 0; +} + +static void collect_sata_reg_log(void) +{ + struct reg_op op = { + .func = sata_reg_dump_info, + .func_name = "sata_reg_dump_info", + }; + int ret; + + ret = hikp_collect_log(GROUP_SATA, "reg_dump", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); +} + +void collect_sata_log(void) +{ + collect_sas_path_log(GROUP_SATA); + collect_sas_lsscsi_log(GROUP_SATA); + collect_sata_reg_log(); +} diff --git a/info_collect/hikp_collect_serdes.c b/info_collect/hikp_collect_serdes.c new file mode 100644 index 0000000..31f29b3 --- /dev/null +++ b/info_collect/hikp_collect_serdes.c @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2024 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_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_serdes.h" + +#define MAX_CHIP_NUM_SUPPORT 8 +#define HIP10_DIE_NUM 2 +#define HIP11_DIE_NUM 4 +#define HIP10_DIE_MACRO_NUM 7 +#define HIP11_DIE_MACRO_NUM 4 + +struct serdes_macro_info { + uint8_t macro_id; + uint8_t ds_num; +}; + +struct serdes_log_cmd { + struct cmd_serdes_param *cmd; + unsigned char die_id; +}; + +struct serdes_macro_info g_hip10[] = { + {0, 4}, /* 0, 4: macro_id, ds_num */ + {1, 4}, /* 1, 4: macro_id, ds_num */ + {2, 8}, /* 2, 8: macro_id, ds_num */ + {3, 8}, /* 3, 8: macro_id, ds_num */ + {4, 8}, /* 4, 8: macro_id, ds_num */ + {5, 8}, /* 5, 8: macro_id, ds_num */ + {6, 8}, /* 6, 8: macro_id, ds_num */ +}; + +struct serdes_macro_info g_hip11[] = { + {0, 4}, /* 0, 4: macro_id, ds_num */ + {1, 8}, /* 1, 8: macro_id, ds_num */ + {2, 4}, /* 2, 4: macro_id, ds_num */ + {3, 4}, /* 3, 4: macro_id, ds_num */ +}; + +static int is_chip_hip11(void) +{ + return get_chip_type() == CHIP_HIP11; +} + +static unsigned char serdes_get_die_num(void) +{ + return is_chip_hip11() ? HIP11_DIE_NUM : HIP10_DIE_NUM; +} + +static unsigned char serdes_get_die_macro_num(void) +{ + return is_chip_hip11() ? HIP11_DIE_MACRO_NUM : HIP10_DIE_MACRO_NUM; +} + +static struct serdes_macro_info *serdes_get_macro_info(void) +{ + return is_chip_hip11() ? g_hip11 : g_hip10; +} + +static int collect_serdes_info_process(void *data) +{ + struct serdes_log_cmd *log_cmd = (struct serdes_log_cmd *)data; + struct serdes_macro_info *macro_info = serdes_get_macro_info(); + unsigned char die_macro_num = serdes_get_die_macro_num(); + struct cmd_serdes_param *cmd = log_cmd->cmd; + const char *info_cmd_str[] = {"", "-k"}; + unsigned char die_id = log_cmd->die_id; + /* 0, 1: brief info, detail info */ + unsigned char subcmd_list[] = {0, 1}; + unsigned char k, p; + int ret; + + for (k = 0; k < die_macro_num; k++) { + cmd->macro_id = die_id * die_macro_num + k; + cmd->start_sds_id = 0; + cmd->sds_num = macro_info[k].ds_num; + for (p = 0; p < sizeof(subcmd_list) / sizeof(subcmd_list[0]); p++) { + cmd->sub_cmd = subcmd_list[p]; + printf("hikptool serdes_info -i %u -s m%ud%u -n %u %s\n", + cmd->chip_id, cmd->macro_id, cmd->start_sds_id, + cmd->sds_num, info_cmd_str[cmd->sub_cmd]); + ret = hikp_serdes_get_reponse(cmd); + if (ret) { + HIKP_ERROR_PRINT("collect chip%u die%u macro%u " + "serdes_info%u failed: %d\n", + cmd->chip_id, die_id, k, subcmd_list[p], ret); + + if (ret == -EINVAL) + return ret; + } + } + } + + return 0; +} + +static void collect_serdes_info_log(void) +{ + struct cmd_serdes_param serdes_info_cmd = {0}; + unsigned char chip_num = MAX_CHIP_NUM_SUPPORT; + unsigned char die_num = serdes_get_die_num(); + char log_name[MAX_LOG_NAME_LEN] = {0}; + struct serdes_log_cmd log_cmd = {0}; + bool stop = false; + unsigned char i, j; + int ret; + + serdes_info_cmd.cmd_type = SERDES_KEY_INFO; + for (i = 0; i < chip_num; i++) { + for (j = 0; j < die_num; j++) { + serdes_info_cmd.chip_id = i; + log_cmd.cmd = &serdes_info_cmd; + log_cmd.die_id = j; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "serdes_info_c%ud%u", i, j); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("create serdes_info log name failed\n"); + break; + } + ret = hikp_collect_log(GROUP_SERDES, log_name, + collect_serdes_info_process, + (void *)&log_cmd); + if (ret) { + /* + * Stop collection when the die id is 0 and ret is -EINVAL, + * indicating that the current chip id is not supported. + */ + if (j == 0 && ret == -EINVAL) + stop = true; + + if (ret == -EINVAL) + break; + + HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", __func__, + i, j, ret); + } + } + + if (stop) + break; + } +} + +static int collect_serdes_dump_process(void *data) +{ + const char *dump_cmd_str[HILINK_DUMP_TYPE_END] = {"cs", "ds", "csds", "ram", "subctrl"}; + struct serdes_log_cmd *log_cmd = (struct serdes_log_cmd *)data; + struct serdes_macro_info *macro_info = serdes_get_macro_info(); + unsigned char die_macro_num = serdes_get_die_macro_num(); + struct cmd_serdes_param *cmd = log_cmd->cmd; + unsigned char die_id = log_cmd->die_id; + unsigned char subcmd_list[] = {0, 1, 4}; /* 0, 1, 4: cs, ds, subctrl reg */ + unsigned char k, p, q; + int ret; + + for (k = 0; k < die_macro_num; k++) { + cmd->macro_id = die_id * die_macro_num + k; + for (q = 0; q < macro_info[k].ds_num; q++) { + cmd->start_sds_id = q; + cmd->sds_num = 1; + for (p = 0; p < sizeof(subcmd_list) / sizeof(subcmd_list[0]); p++) { + cmd->sub_cmd = subcmd_list[p]; + printf("hikptool serdes_dump -i %u -s m%ud%u -c %s\n", + cmd->chip_id, cmd->macro_id, cmd->start_sds_id, + dump_cmd_str[cmd->sub_cmd]); + ret = hikp_serdes_get_reponse(cmd); + if (ret) { + HIKP_ERROR_PRINT("collect chip%u die%u macro%u lane%u " + "serdes_dump%u failed: %d\n", + cmd->chip_id, die_id, k, q, + subcmd_list[p], ret); + + if (ret == -EINVAL) + return ret; + } + } + } + } + + return 0; +} + +static void collect_serdes_dump_log(void) +{ + struct cmd_serdes_param serdes_dump_cmd = {0}; + unsigned char chip_num = MAX_CHIP_NUM_SUPPORT; + unsigned char die_num = serdes_get_die_num(); + struct serdes_log_cmd log_cmd = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + unsigned char i, j; + bool stop = false; + int ret; + + serdes_dump_cmd.cmd_type = SERDES_DUMP_REG; + for (i = 0; i < chip_num; i++) { + for (j = 0; j < die_num; j++) { + serdes_dump_cmd.chip_id = i; + log_cmd.cmd = &serdes_dump_cmd; + log_cmd.die_id = j; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "serdes_dump_c%ud%u", i, j); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("create serdes_info log name failed\n"); + break; + } + ret = hikp_collect_log(GROUP_SERDES, log_name, + collect_serdes_dump_process, + (void *)&log_cmd); + if (ret) { + /* + * Stop collection when the die id is 0 and ret is -EINVAL, + * indicating that the current chip id is not supported. + */ + if (j == 0 && ret == -EINVAL) + stop = true; + + if (ret == -EINVAL) + break; + + HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", __func__, + i, j, ret); + } + } + + if (stop) + break; + } +} + +void collect_serdes_log(void) +{ + collect_serdes_info_log(); + collect_serdes_dump_log(); +} diff --git a/info_collect/hikp_collect_socip.c b/info_collect/hikp_collect_socip.c new file mode 100644 index 0000000..6bccf6a --- /dev/null +++ b/info_collect/hikp_collect_socip.c @@ -0,0 +1,272 @@ +/* + * Copyright (c) 2024 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikptdev_plug.h" +#include "hikp_socip.h" +#include "hikp_collect_socip.h" + +#define SOCIP_MODULENUM 7 +#define MAX_CHIPNUM 30 + +enum socip_collect_type { + GPIO, + SPI, + I2C, + SFC, + USB, + UART, + BT, +}; + +const char *g_socip_modulename[SOCIP_MODULENUM] = { + "gpio", + "spi", + "i2c", + "sfc", + "usb", + "uart", + "bt", +}; + +struct info_collect_cmd gpio_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "gpio", + .args = {"cat", "/sys/kernel/debug/gpio", NULL}, + }, +}; + +struct info_collect_cmd spi_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/kernel/debug/dw_spi*/registers", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/kernel/debug/hisi_spi*/registers", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/class/spi_master/spi*/statistics/bytes", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/class/spi_master/spi*/statistics/bytes_rx", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/class/spi_master/spi*/statistics/bytes_tx", NULL}, + }, +}; + +struct info_collect_cmd i2c_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "i2c", + .args = {"ls", "/sys/class/i2c-adapter", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "i2c", + .args = {"ls", "/sys/class/i2c-dev", NULL}, + }, +}; + +struct info_collect_cmd sfc_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "sfc", + .args = {"mtd_debug", "info", "/dev/mtd0", NULL}, + }, +}; + +struct info_collect_cmd usb_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "usb", + .args = {"cat", "/sys/kernel/debug/usb/devices", NULL}, + }, +}; + +struct info_collect_cmd uart_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "uart", + .args = {"stty", "-F", "/dev/ttyAMA0", "-a", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "uart", + .args = {"cat", "/proc/tty/driver/ttyAMA", NULL}, + }, +}; + +struct info_collect_cmd bt_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "bt", + .args = {"ls", "/dev/ipmi0", NULL}, + }, +}; + +static int socip_get_dumpregparam(struct socip_collect_dumpreg_req req_struct, + struct socip_dump_reg_req_data_t *req_data_ptr, uint8_t chip_id, int controller_num) +{ + req_data_ptr->controller_id = req_struct.controller_id[controller_num]; + if (req_data_ptr->controller_id == CONTROLLER_MAX_NUM) + return -EINVAL; + + req_data_ptr->chip_id = chip_id; + req_data_ptr->die_id = req_struct.die_id; + return 0; +} + +static int collect_socip_dumpreglog(void *version) +{ + size_t i, msize; + uint8_t chip_id; + uint32_t cpu_version = *(uint32_t *)version; + int controller_num, ret; + struct hikp_cmd_ret *cmd_ret; + struct socip_collect_dumpreg_req *req_struct; + struct socip_dump_reg_req_data_t req_data = {0}; + struct hikp_cmd_header req_header = {0}; + + switch (cpu_version) { + case CHIP_HIP09: + case CHIP_HIP10: + case CHIP_HIP10C: + req_struct = socip_hip09_hip10x_reg_arr; + msize = HIKP_ARRAY_SIZE(socip_hip09_hip10x_reg_arr); + break; + case CHIP_HIP11: + req_struct = socip_hip11_reg_arr; + msize = HIKP_ARRAY_SIZE(socip_hip11_reg_arr); + break; + default: + HIKP_ERROR_PRINT("Cpu version not support.\n"); + return 0; + } + + for (chip_id = 0; chip_id < MAX_CHIPNUM; chip_id++) { + for (i = 0; i < msize; i++) { + controller_num = 0; + while(controller_num < CONTROLLER_MAX_NUM) { + struct socip_dump_reg_req_data_t *req_data_ptr = &req_data; + ret = socip_get_dumpregparam(req_struct[i], req_data_ptr, chip_id, controller_num); + if (ret) + break; + + hikp_cmd_init(&req_header, SOCIP_MOD, HIKP_SOCIP_CMD_DUMPREG, + req_struct[i].module); + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + if (!cmd_ret || cmd_ret->status != 0) { + HIKP_ERROR_PRINT("hikp_cmd_alloc failed\n"); + hikp_cmd_free(&cmd_ret); + return 0; + } + printf("%s\n", req_struct[i].reg_info); + printf("hikptool socip_dumpreg -c %u -d %u -m %u -i %u\n",req_data.chip_id, + req_data.die_id, req_struct[i].module, req_data.controller_id); + dump_reg_info(&cmd_ret->rsp_data[0], cmd_ret->rsp_data_num); + hikp_cmd_free(&cmd_ret); + controller_num++; + } + } + } + + return 0; +} + +static int collect_socip_modulelog(void *module) +{ + size_t i, msize; + int ret; + + switch (*(int *)module) { + case GPIO: + msize = HIKP_ARRAY_SIZE(gpio_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&gpio_cmd_arr[i]); + break; + case SPI: + msize = HIKP_ARRAY_SIZE(spi_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_cat_glob_exec((void *)&spi_cmd_arr[i]); + break; + case I2C: + msize = HIKP_ARRAY_SIZE(i2c_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&i2c_cmd_arr[i]); + break; + case SFC: + msize = HIKP_ARRAY_SIZE(sfc_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&sfc_cmd_arr[i]); + break; + case USB: + msize = HIKP_ARRAY_SIZE(usb_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&usb_cmd_arr[i]); + break; + case UART: + msize = HIKP_ARRAY_SIZE(uart_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&uart_cmd_arr[i]); + break; + case BT: + msize = HIKP_ARRAY_SIZE(bt_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&bt_cmd_arr[i]); + break; + default: + ret = 0; + break; + } + + return ret; +} + +void collect_socip_log(void) +{ + int i, ret; + uint32_t cpu_version = get_chip_type(); + + for (i = 0; i < SOCIP_MODULENUM; i++) { + ret = hikp_collect_log(GROUP_SOCIP, (char *)g_socip_modulename[i], + collect_socip_modulelog, (void *)&i); + if (ret) { + HIKP_ERROR_PRINT("collect_socip_log %s arr failed: %d\n", + g_socip_modulename[i], ret); + } + } + + ret = hikp_collect_log(GROUP_SOCIP, "dumpreg", collect_socip_dumpreglog, (void *)&cpu_version); + if (ret) + HIKP_ERROR_PRINT("collect_socip_log dumpreg failed: %d\n", ret); +} diff --git a/info_collect/hikp_collect_socip.h b/info_collect/hikp_collect_socip.h new file mode 100644 index 0000000..b8bb879 --- /dev/null +++ b/info_collect/hikp_collect_socip.h @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2024 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_COLLECT_SOCIP_H +#define HIKP_COLLECT_SOCIP_H + +#define MIN_DIE_ID 0 +#define NIMBUS_A_ID 0 +#define TOTEM_A_ID 1 +#define NIMBUS_B_ID 2 +#define TOTEM_C_ID 2 +#define TOTEM_B_ID 3 +#define INVALID_DIE_ID 0xFF +#define MAX_DIE_ID 3 +#define CONTROLLER_MAX_NUM 12 + +#define DIE_MIN_INDEX 0 +#define CPUDIE_MIN_INDEX 0 +#define CPUDIE_A_INDEX 0 +#define CPUDIE_B_INDEX 1 +#define CPUDIE_MAX_INDEX 1 +#define IODIE_MIN_INDEX 2 +#define IODIE_A0_INDEX 2 +#define IODIE_A1_INDEX 3 +#define IODIE_B0_INDEX 4 +#define IODIE_B1_INDEX 5 +#define IODIE_MAX_INDEX 5 +#define DIE_MAX_INDEX 5 + +struct socip_collect_dumpreg_req { + char *reg_info; + uint8_t module; + uint8_t die_id; + uint8_t controller_id[CONTROLLER_MAX_NUM]; +}; + +struct socip_collect_dumpreg_req socip_hip09_hip10x_reg_arr[] = { + { + .reg_info = "gpio_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = NIMBUS_B_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_TA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = TOTEM_A_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_TB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = TOTEM_B_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, 5, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, 5, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "spi_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SPI, + .die_id = NIMBUS_A_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "spi_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SPI, + .die_id = NIMBUS_B_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "sfc_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "sfc_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_B_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "btc_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_A_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "btc_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_B_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, +}; + +struct socip_collect_dumpreg_req socip_hip11_reg_arr[] = { + { + .reg_info = "gpio_IOA0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_A0_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_IOA1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_A1_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_IOB0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_B0_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_IOB1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_B1_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_CA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = CPUDIE_A_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_CB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = CPUDIE_B_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOA0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_A0_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOA1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_A1_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOB0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_B0_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOB1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_B1_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_CA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = CPUDIE_A_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_CB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = CPUDIE_B_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "spi_CB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SPI, + .die_id = CPUDIE_B_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "sfc_CA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = CPUDIE_A_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "BTC_IOB0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = IODIE_B0_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, +}; +#endif /* HIKP_COLLECT_SOCIP_H */ diff --git a/net/nic/nic_dfx/hikp_nic_dfx.c b/net/nic/nic_dfx/hikp_nic_dfx.c index c42b8e7..3bc4e05 100644 --- a/net/nic/nic_dfx/hikp_nic_dfx.c +++ b/net/nic/nic_dfx/hikp_nic_dfx.c @@ -404,6 +404,13 @@ static const struct dfx_type_name_parse g_dfx_ssu_name_parse[] = { dfx_ssu_type_64_tx_comm_stats, HIKP_ARRAY_SIZE(dfx_ssu_type_64_tx_comm_stats)}, }; +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; +} + static void dfx_help_info(const struct major_cmd_ctrl *self) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -421,7 +428,7 @@ static int hikp_cmd_dfx_help(struct major_cmd_ctrl *self, const char *argv) return 0; } -static int hikp_nic_cmd_dfx_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_dfx_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_dfx_param.target)); if (self->err_no != 0) { @@ -714,7 +721,7 @@ static void hikp_nic_dfx_print(const struct nic_dfx_rsp_head_t *rsp_head, uint32 printf("################### ====== dump end ====== ######################\n"); } -static void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self) { struct nic_dfx_rsp_head_t rsp_head = { 0 }; struct nic_dfx_rsp_head_t tmp_head = { 0 }; diff --git a/net/nic/nic_dfx/hikp_nic_dfx.h b/net/nic/nic_dfx/hikp_nic_dfx.h index 38f76aa..d77bbc3 100644 --- a/net/nic/nic_dfx/hikp_nic_dfx.h +++ b/net/nic/nic_dfx/hikp_nic_dfx.h @@ -149,4 +149,7 @@ struct dfx_type_name_parse { uint32_t reg_num; }; +int hikp_nic_cmd_dfx_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_dfx_set_cmd_para(int idx); #endif /* HIKP_NIC_DFX_H */ diff --git a/net/nic/nic_fd/hikp_nic_fd.c b/net/nic/nic_fd/hikp_nic_fd.c index 3296ebf..f3edb4f 100644 --- a/net/nic/nic_fd/hikp_nic_fd.c +++ b/net/nic/nic_fd/hikp_nic_fd.c @@ -109,6 +109,13 @@ static const struct fd_feature_cmd g_fd_feature_cmd[] = { hikp_nic_query_fd_counter, hikp_nic_show_fd_counter}, }; +void hikp_nic_set_fd_idx(int feature_idx, int stage_no) +{ + g_fd_param.id = -1; + g_fd_param.feature_idx = feature_idx; + g_fd_param.stage_no = stage_no; +} + static int hikp_nic_fd_cmd_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); @@ -923,7 +930,7 @@ static int hikp_nic_fd_check_input_param(struct major_cmd_ctrl *self, return 0; } -static void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_fd_param.target.bdf; const struct fd_feature_cmd *fd_cmd; @@ -983,7 +990,7 @@ out: hikp_nic_fd_data_free(fd_data); } -static int hikp_nic_cmd_get_fd_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_fd_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_fd_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_fd/hikp_nic_fd.h b/net/nic/nic_fd/hikp_nic_fd.h index 3f409d0..ce363c9 100644 --- a/net/nic/nic_fd/hikp_nic_fd.h +++ b/net/nic/nic_fd/hikp_nic_fd.h @@ -224,4 +224,8 @@ struct fd_feature_cmd { void (*show)(const void *data); }; +int hikp_nic_cmd_get_fd_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_set_fd_idx(int feature_idx, int stage_no); + #endif /* HIKP_NIC_FD_H */ diff --git a/net/nic/nic_fec/hikp_nic_fec.c b/net/nic/nic_fec/hikp_nic_fec.c index 5a34bfd..13c6e13 100644 --- a/net/nic/nic_fec/hikp_nic_fec.c +++ b/net/nic/nic_fec/hikp_nic_fec.c @@ -108,7 +108,7 @@ static void hikp_nic_fec_err_show(const struct nic_fec_err_info *info) printf("#################### END #######################\n"); } -static void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_fec_target.bdf; struct nic_fec_err_info info = { 0 }; @@ -136,7 +136,7 @@ static int hikp_nic_fec_cmd_help(struct major_cmd_ctrl *self, const char *argv) return 0; } -static int hikp_nic_fec_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_fec_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_fec_target); if (self->err_no != 0) { diff --git a/net/nic/nic_fec/hikp_nic_fec.h b/net/nic/nic_fec/hikp_nic_fec.h index 7996273..79a87b5 100644 --- a/net/nic/nic_fec/hikp_nic_fec.h +++ b/net/nic/nic_fec/hikp_nic_fec.h @@ -69,4 +69,6 @@ struct nic_fec_err_info { }; }; +int hikp_nic_fec_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_FEC_H */ diff --git a/net/nic/nic_ft/hikp_nic_port_fault.c b/net/nic/nic_ft/hikp_nic_port_fault.c index 5f78cdd..331b1ec 100644 --- a/net/nic/nic_ft/hikp_nic_port_fault.c +++ b/net/nic/nic_ft/hikp_nic_port_fault.c @@ -80,7 +80,7 @@ static void hikp_nic_port_fault_show(struct nic_port_fault_status *info) printf("#################### END #######################\n"); } -static void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_port_fault_target.bdf; struct nic_port_fault_status info = { 0 }; @@ -108,7 +108,7 @@ static int hikp_nic_port_fault_cmd_help(struct major_cmd_ctrl *self, const char return 0; } -static int hikp_nic_port_fault_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_port_fault_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_port_fault_target); if (self->err_no != 0) { diff --git a/net/nic/nic_ft/hikp_nic_port_fault.h b/net/nic/nic_ft/hikp_nic_port_fault.h index 7db54f7..9c7e4b2 100644 --- a/net/nic/nic_ft/hikp_nic_port_fault.h +++ b/net/nic/nic_ft/hikp_nic_port_fault.h @@ -51,4 +51,6 @@ struct nic_port_fault_status { uint8_t hilink_ref_status; }; +int hikp_nic_port_fault_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_PORT_FAULT_H */ diff --git a/net/nic/nic_gro/hikp_nic_gro.c b/net/nic/nic_gro/hikp_nic_gro.c index 19395af..d821a47 100644 --- a/net/nic/nic_gro/hikp_nic_gro.c +++ b/net/nic/nic_gro/hikp_nic_gro.c @@ -53,7 +53,7 @@ static void hikp_nic_gro_show(const struct nic_gro_info *info) printf("#################### END #######################\n"); } -static void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_gro_target.bdf; struct nic_gro_info info = { 0 }; @@ -81,7 +81,7 @@ static int hikp_nic_gro_cmd_help(struct major_cmd_ctrl *self, const char *argv) return 0; } -static int hikp_nic_gro_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_gro_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_gro_target); if (self->err_no != 0) { diff --git a/net/nic/nic_gro/hikp_nic_gro.h b/net/nic/nic_gro/hikp_nic_gro.h index 49328e6..ae58703 100644 --- a/net/nic/nic_gro/hikp_nic_gro.h +++ b/net/nic/nic_gro/hikp_nic_gro.h @@ -43,4 +43,6 @@ struct nic_gro_info { uint32_t max_coal_bd_num; }; +int hikp_nic_gro_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_GRO_H */ diff --git a/net/nic/nic_info/hikp_nic_info.c b/net/nic/nic_info/hikp_nic_info.c index 49f143f..6fb17a2 100644 --- a/net/nic/nic_info/hikp_nic_info.c +++ b/net/nic/nic_info/hikp_nic_info.c @@ -37,7 +37,7 @@ static int hikp_nic_cmd_get_info_help(struct major_cmd_ctrl *self, const char *a return 0; } -static int hikp_nic_cmd_get_info_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_info_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_info_param.target)); if (self->err_no != 0) { @@ -305,7 +305,7 @@ static void hikp_nic_info_print_cur_vf(const struct bdf_t *bdf) } } -static void hikp_nic_info_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_info_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_info_param.target.bdf; diff --git a/net/nic/nic_info/hikp_nic_info.h b/net/nic/nic_info/hikp_nic_info.h index b1dd7dc..83323e8 100644 --- a/net/nic/nic_info/hikp_nic_info.h +++ b/net/nic/nic_info/hikp_nic_info.h @@ -77,4 +77,6 @@ enum nic_info_mac_type { MAC_TYPE_MAX, }; +void hikp_nic_info_cmd_execute(struct major_cmd_ctrl *self); +int hikp_nic_cmd_get_info_target(struct major_cmd_ctrl *self, const char *argv); #endif /* HIKP_NIC_INFO_H */ diff --git a/net/nic/nic_log/hikp_nic_log.c b/net/nic/nic_log/hikp_nic_log.c index f182d25..be23ca3 100644 --- a/net/nic/nic_log/hikp_nic_log.c +++ b/net/nic/nic_log/hikp_nic_log.c @@ -23,6 +23,7 @@ #include "hikp_nic_log.h" static struct log_param g_log_param = { 0 }; +static char g_log_path[OP_LOG_FILE_PATH_MAXLEN] = {0}; static int hikp_nic_cmd_log_help(struct major_cmd_ctrl *self, const char *argv) { @@ -49,7 +50,6 @@ static int hikp_nic_cmd_log_target(struct major_cmd_ctrl *self, const char *argv static int hikp_nic_write_data_to_file(uint8_t *data, uint32_t len) { - uint8_t file_path[OP_LOG_FILE_PATH_MAXLEN] = { 0 }; uint8_t file_name[MAX_LOG_NAME_LEN] = { 0 }; size_t write_cnt; FILE *fp = NULL; @@ -59,23 +59,23 @@ static int hikp_nic_write_data_to_file(uint8_t *data, uint32_t len) if (ret < 0) return ret; - ret = snprintf((char *)file_path, sizeof(file_path), HIKP_LOG_DIR_PATH"%s", file_name); + ret = snprintf(g_log_path, sizeof(g_log_path), HIKP_LOG_DIR_PATH"%s", file_name); if (ret < 0) { HIKP_ERROR_PRINT("creat log file path fail.\n"); return -EIO; } - (void)remove((const char *)file_path); - fp = fopen((char *)file_path, "w+"); + (void)remove((const char *)g_log_path); + fp = fopen(g_log_path, "w+"); if (fp == NULL) { - HIKP_ERROR_PRINT("open %s failed, errno is %d\n", file_path, errno); + 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", file_path, write_cnt); + HIKP_ERROR_PRINT("write %s failed, write cnt %lu.\n", g_log_path, write_cnt); - printf("dump m7 log completed, log file: %s.\n", file_path); - (void)chmod((char *)file_path, 0440); + printf("dump m7 log completed, log file: %s.\n", g_log_path); + (void)chmod(g_log_path, 0440); (void)fclose(fp); return 0; } @@ -199,6 +199,29 @@ static void hikp_nic_log_cmd_execute(struct major_cmd_ctrl *self) self->err_no = hikp_nic_dump_m7_log(self); } +const char *hikp_info_collect_get_log_path(void) +{ + return (const char *)g_log_path; +} + +int hikp_info_collect_nic_log(void *data) +{ + struct nic_log_collect_param *param = (struct nic_log_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_log_param, 0, sizeof(g_log_param)); + + ret = hikp_nic_cmd_log_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_log -i %s\n", param->net_dev_name); + hikp_nic_log_cmd_execute(major_cmd); + + return ret; +} + static void cmd_nic_log_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_log/hikp_nic_log.h b/net/nic/nic_log/hikp_nic_log.h index 2998464..cff1980 100644 --- a/net/nic/nic_log/hikp_nic_log.h +++ b/net/nic/nic_log/hikp_nic_log.h @@ -38,4 +38,11 @@ struct log_param { struct tool_target target; }; +struct nic_log_collect_param { + const char *net_dev_name; +}; + +const char *hikp_info_collect_get_log_path(void); +int hikp_info_collect_nic_log(void *data); + #endif /* HIKP_NIC_LOG_H */ diff --git a/net/nic/nic_mac/hikp_nic_mac_dump.c b/net/nic/nic_mac/hikp_nic_mac_dump.c index 5439c71..751953c 100644 --- a/net/nic/nic_mac/hikp_nic_mac_dump.c +++ b/net/nic/nic_mac/hikp_nic_mac_dump.c @@ -184,7 +184,7 @@ static int mac_cmd_dump_para_check(struct major_cmd_ctrl *self) return 0; } -static void mac_cmd_dump_execute(struct major_cmd_ctrl *self) +void mac_cmd_dump_execute(struct major_cmd_ctrl *self) { int ret; @@ -203,7 +203,7 @@ static void mac_cmd_dump_execute(struct major_cmd_ctrl *self) mac_cmd_dump_module(self, g_dump_reg_info.module_name); } -static int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv) +int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_dump_reg_info.target); if (self->err_no) { @@ -233,13 +233,35 @@ static int mac_cmd_dump_reg_help(struct major_cmd_ctrl *self, const char *argv) return 0; } -static int mac_cmd_dump_module_cfg(struct major_cmd_ctrl *self, const char *argv) +int mac_cmd_dump_module_cfg(struct major_cmd_ctrl *self, const char *argv) { g_dump_reg_info.module_name = argv; return 0; } +int hikp_info_collect_nic_mac(void *data) +{ + struct nic_mac_collect_param *param = (struct nic_mac_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_dump_reg_info, 0, sizeof(g_dump_reg_info)); + + ret = mac_cmd_dump_reg_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + ret = mac_cmd_dump_module_cfg(major_cmd, param->module_name); + if (ret) + return ret; + + printf("hikptool nic_mac -i %s -m %s\n", param->net_dev_name, param->module_name); + mac_cmd_dump_execute(major_cmd); + + return ret; +} + static void cmd_mac_dump_reg_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_mac/hikp_nic_mac_dump.h b/net/nic/nic_mac/hikp_nic_mac_dump.h index 0c58ad5..f74a99e 100644 --- a/net/nic/nic_mac/hikp_nic_mac_dump.h +++ b/net/nic/nic_mac/hikp_nic_mac_dump.h @@ -60,4 +60,15 @@ struct cmd_mac_dump { uint32_t blk_num[MOD_ID_MAX]; const char *module_name; }; + +struct nic_mac_collect_param { + const char *net_dev_name; + const char *module_name; +}; + +int hikp_info_collect_nic_mac(void *data); + +int mac_cmd_dump_module_cfg(struct major_cmd_ctrl *self, const char *argv); +int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv); +void mac_cmd_dump_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_MAC_DUMP_H */ diff --git a/net/nic/nic_mac/hikp_nic_port.c b/net/nic/nic_mac/hikp_nic_port.c index e28a040..737de07 100644 --- a/net/nic/nic_mac/hikp_nic_port.c +++ b/net/nic/nic_mac/hikp_nic_port.c @@ -630,6 +630,24 @@ static int mac_cmd_port_show_help(struct major_cmd_ctrl *self, const char *argv) return 0; } +int hikp_info_collect_nic_port(void *data) +{ + struct nic_port_collect_param *param = (struct nic_port_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_port_info, 0, sizeof(g_port_info)); + + ret = mac_cmd_get_port_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_port -i %s\n", param->net_dev_name); + mac_cmd_port_execute(major_cmd); + + return ret; +} + static void cmd_mac_get_port_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_mac/hikp_nic_port.h b/net/nic/nic_mac/hikp_nic_port.h index 69ebb53..433eba4 100644 --- a/net/nic/nic_mac/hikp_nic_port.h +++ b/net/nic/nic_mac/hikp_nic_port.h @@ -271,4 +271,10 @@ struct cmd_hot_plug_card_info { uint8_t cur_type; }; +struct nic_port_collect_param { + const char *net_dev_name; +}; + +int hikp_info_collect_nic_port(void *data); + #endif /* HIKP_NIC_PORT_H */ diff --git a/net/nic/nic_mac/hikp_nic_xsfp.c b/net/nic/nic_mac/hikp_nic_xsfp.c index 573837b..91daa52 100644 --- a/net/nic/nic_mac/hikp_nic_xsfp.c +++ b/net/nic/nic_mac/hikp_nic_xsfp.c @@ -734,6 +734,29 @@ static int hikp_xsfp_dump_raw_data(struct major_cmd_ctrl *self, const char *argv return 0; } +int hikp_info_collect_nic_xsfp(void *data) +{ + struct nic_xsfp_collect_param *param = (struct nic_xsfp_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_xsfp_dump, 0, sizeof(g_xsfp_dump)); + + ret = hikp_xsfp_get_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_xsfp -i %s\n", param->net_dev_name); + hikp_xsfp_get_info(major_cmd); + + printf("hikptool nic_xsfp -i %s -d\n", param->net_dev_name); + /* No need to judge the return value */ + (void)hikp_xsfp_dump_raw_data(major_cmd, NULL); + hikp_xsfp_get_info(major_cmd); + + return ret; +} + static void cmd_get_xsfp_info(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_mac/hikp_nic_xsfp.h b/net/nic/nic_mac/hikp_nic_xsfp.h index 50cbb2d..7db9693 100644 --- a/net/nic/nic_mac/hikp_nic_xsfp.h +++ b/net/nic/nic_mac/hikp_nic_xsfp.h @@ -549,4 +549,10 @@ struct hikp_xsfp_ctrl { uint32_t dump_param; }; +struct nic_xsfp_collect_param { + const char *net_dev_name; +}; + +int hikp_info_collect_nic_xsfp(void *data); + #endif /* HIKP_NIC_XSFP_H */ diff --git a/net/nic/nic_ncsi/hikp_nic_ncsi.c b/net/nic/nic_ncsi/hikp_nic_ncsi.c index 2e1ea11..84f6337 100644 --- a/net/nic/nic_ncsi/hikp_nic_ncsi.c +++ b/net/nic/nic_ncsi/hikp_nic_ncsi.c @@ -100,6 +100,24 @@ static int nic_ncsi_cmd_show_help(struct major_cmd_ctrl *self, const char *argv) return 0; } +int hikp_info_collect_nic_ncsi(void *data) +{ + struct nic_ncsi_collect_param *param = (struct nic_ncsi_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_ncsi_cmd_info, 0, sizeof(g_ncsi_cmd_info)); + + ret = nic_ncsi_cmd_get_port_info(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_ncsi -i %s\n", param->net_dev_name); + nic_ncsi_cmd_execute(major_cmd); + + return ret; +} + static void cmd_nic_get_ncsi_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_ncsi/hikp_nic_ncsi.h b/net/nic/nic_ncsi/hikp_nic_ncsi.h index a391d20..56ab653 100644 --- a/net/nic/nic_ncsi/hikp_nic_ncsi.h +++ b/net/nic/nic_ncsi/hikp_nic_ncsi.h @@ -54,4 +54,10 @@ struct nic_ncsi_cmd_info { bool port_flag; }; +struct nic_ncsi_collect_param { + const char *net_dev_name; +}; + +int hikp_info_collect_nic_ncsi(void *data); + #endif /* HIKP_NIC_NCSI_H */ diff --git a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c index 5cd8bfa..4efaadc 100644 --- a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c +++ b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c @@ -70,7 +70,7 @@ static void hikp_nic_notify_pkt_show(const struct nic_notify_pkt_info *info) printf("####################### END ###########################\n"); } -static void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_notify_pkt_target.bdf; struct nic_notify_pkt_info info = {0}; @@ -94,7 +94,7 @@ static int hikp_nic_notify_pkt_cmd_help(struct major_cmd_ctrl *self, const char return 0; } -static int hikp_nic_notify_pkt_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_notify_pkt_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_notify_pkt_target); if (self->err_no != 0) { diff --git a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h index 8bdb795..26a86fe 100644 --- a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h +++ b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h @@ -49,4 +49,6 @@ struct nic_notify_pkt_info { #define HIKP_NOTIFY_PKT_CFG_PKT_NUM_M GENMASK(5, 2) #define HIKP_NOTIFY_PKT_CFG_PKT_NUM_S 2 +int hikp_nic_notify_pkt_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_NOTIFY_PKT_H */ diff --git a/net/nic/nic_ppp/hikp_nic_ppp.c b/net/nic/nic_ppp/hikp_nic_ppp.c index c19a5d0..421d601 100644 --- a/net/nic/nic_ppp/hikp_nic_ppp.c +++ b/net/nic/nic_ppp/hikp_nic_ppp.c @@ -57,6 +57,13 @@ static const struct ppp_feature_cmd g_ppp_feature_cmd[] = { hikp_nic_query_ppp_by_blkid, hikp_nic_ppp_show_vlan_offload}, }; +void hikp_nic_ppp_set_cmd_param(int feature_idx) +{ + g_ppp_param.func_id = -1; + g_ppp_param.is_uc = -1; + g_ppp_param.feature_idx = feature_idx; +} + static int hikp_nic_ppp_cmd_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); @@ -1098,7 +1105,7 @@ static int hikp_nic_check_hw_res(struct hikp_nic_ppp_hw_resources *hw_res) return 0; } -static void hikp_nic_ppp_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_ppp_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_ppp_param.target.bdf; const struct ppp_feature_cmd *ppp_cmd; @@ -1157,7 +1164,7 @@ out: hikp_nic_ppp_data_free(ppp_data); } -static int hikp_nic_cmd_get_ppp_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_ppp_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ppp_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_ppp/hikp_nic_ppp.h b/net/nic/nic_ppp/hikp_nic_ppp.h index 659ed57..d629627 100644 --- a/net/nic/nic_ppp/hikp_nic_ppp.h +++ b/net/nic/nic_ppp/hikp_nic_ppp.h @@ -246,4 +246,7 @@ struct ppp_feature_cmd { void (*show)(const void *data); }; +void hikp_nic_ppp_set_cmd_param(int feature_idx); +int hikp_nic_cmd_get_ppp_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_ppp_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_PPP_H */ diff --git a/net/nic/nic_qos/hikp_nic_qos.c b/net/nic/nic_qos/hikp_nic_qos.c index c620a08..dc6f63e 100644 --- a/net/nic/nic_qos/hikp_nic_qos.c +++ b/net/nic/nic_qos/hikp_nic_qos.c @@ -33,6 +33,16 @@ static const struct qos_feature_cmd g_qos_feature_cmd[] = { hikp_nic_qos_show_pfc_storm_para}, }; +void hikp_nic_qos_set_cmd_feature_idx(int feature_idx) +{ + g_qos_param.feature_idx = feature_idx; +} + +void hikp_nic_qos_set_cmd_direction(enum nic_pfc_dir dir) +{ + g_qos_param.dir = dir; +} + static int hikp_nic_qos_cmd_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); @@ -242,7 +252,7 @@ static int hikp_nic_query_qos_feature(struct hikp_cmd_header *req_header, const return ret; } -static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) { char *revision_id = g_qos_param.revision_id; struct bdf_t *bdf = &g_qos_param.target.bdf; @@ -265,7 +275,7 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) } if (g_qos_param.feature_idx == NIC_PFC_STORM_PARA_DUMP && - g_qos_param.dir == NIC_QUEUE_DIR_NONE) { + g_qos_param.dir == NIC_QOS_DIR_NONE) { hikp_nic_qos_cmd_help(self, NULL); snprintf(self->err_str, sizeof(self->err_str), "-d/--dir param error!"); @@ -296,7 +306,7 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) printf("#################### END #######################\n"); } -static int hikp_nic_cmd_get_qos_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_qos_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_qos_param.target)); if (self->err_no != 0) { @@ -330,11 +340,11 @@ static int hikp_nic_cmd_qos_direct(struct major_cmd_ctrl *self, const char *argv) { if (strcmp(argv, "rx") == 0) { - g_qos_param.dir = NIC_RX_QUEUE; + g_qos_param.dir = NIC_RX_QOS; return 0; } if (strcmp(argv, "tx") == 0) { - g_qos_param.dir = NIC_TX_QUEUE; + g_qos_param.dir = NIC_TX_QOS; return 0; } @@ -350,7 +360,7 @@ static void cmd_nic_get_qos_init(void) struct major_cmd_ctrl *major_cmd = get_major_cmd(); g_qos_param.feature_idx = -1; - g_qos_param.dir = NIC_QUEUE_DIR_NONE; + g_qos_param.dir = NIC_QOS_DIR_NONE; major_cmd->option_count = 0; major_cmd->execute = hikp_nic_qos_cmd_execute; diff --git a/net/nic/nic_qos/hikp_nic_qos.h b/net/nic/nic_qos/hikp_nic_qos.h index 77fbdd9..6ff4e05 100644 --- a/net/nic/nic_qos/hikp_nic_qos.h +++ b/net/nic/nic_qos/hikp_nic_qos.h @@ -118,9 +118,9 @@ struct nic_qos_req_para { }; enum nic_pfc_dir { - NIC_RX_QUEUE = 0, - NIC_TX_QUEUE, - NIC_QUEUE_DIR_NONE, + NIC_RX_QOS = 0, + NIC_TX_QOS, + NIC_QOS_DIR_NONE, }; struct nic_qos_param { @@ -137,4 +137,8 @@ struct qos_feature_cmd { void (*show)(const void *data); }; +int hikp_nic_cmd_get_qos_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_qos_set_cmd_feature_idx(int feature_idx); +void hikp_nic_qos_set_cmd_direction(enum nic_pfc_dir dir); #endif /* HIKP_NIC_QOS_H */ diff --git a/net/nic/nic_queue/hikp_nic_queue.c b/net/nic/nic_queue/hikp_nic_queue.c index dafa05e..5bb4335 100644 --- a/net/nic/nic_queue/hikp_nic_queue.c +++ b/net/nic/nic_queue/hikp_nic_queue.c @@ -32,6 +32,14 @@ static const struct queue_feature_cmd g_queue_feature_cmd[] = { {"func_map", QUEUE_FUNC_MAP, hikp_nic_queue_show_func_map}, }; +void hikp_nic_queue_cmd_set_param(int feature_idx, int qid, enum nic_queue_dir dir) +{ + g_queue_param.is_display_all = true; + g_queue_param.qid = qid; + g_queue_param.dir = dir; + g_queue_param.feature_idx = feature_idx; +} + static int hikp_nic_queue_cmd_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); @@ -340,7 +348,7 @@ static bool hikp_nic_queue_check_feature_para_vaild(const struct queue_feature_c return valid; } -static void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self) { const struct queue_feature_cmd *queue_cmd; union nic_queue_feature_info *queue_data; @@ -387,7 +395,7 @@ out: free(queue_data); } -static int hikp_nic_cmd_get_queue_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_queue_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_queue_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_queue/hikp_nic_queue.h b/net/nic/nic_queue/hikp_nic_queue.h index fac39a0..ca3541a 100644 --- a/net/nic/nic_queue/hikp_nic_queue.h +++ b/net/nic/nic_queue/hikp_nic_queue.h @@ -152,4 +152,8 @@ struct queue_feature_cmd { uint32_t sub_cmd_code; void (*show)(const void *data); }; + +int hikp_nic_cmd_get_queue_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_queue_cmd_set_param(int feature_idx, int qid, enum nic_queue_dir dir); #endif /* HIKP_NIC_QUEUE_H */ diff --git a/net/nic/nic_rss/hikp_nic_rss.c b/net/nic/nic_rss/hikp_nic_rss.c index 65336ff..a7448e4 100644 --- a/net/nic/nic_rss/hikp_nic_rss.c +++ b/net/nic/nic_rss/hikp_nic_rss.c @@ -132,6 +132,11 @@ static const struct rss_feature_cmd g_rss_feature_cmd[] = { {"tc_mode", RSS_TC_MODE_DUMP, hikp_nic_rss_show_tc_mode}, }; +void hikp_nic_rss_cmd_set_feature_idx(int feature_idx) +{ + g_rss_param.feature_idx = feature_idx; +} + static int hikp_nic_rss_cmd_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); @@ -417,7 +422,7 @@ static int hikp_nic_query_rss_feature(struct hikp_cmd_header *req_header, const return ret; } -static void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self) { union nic_rss_feature_info rss_data = {0}; const struct rss_feature_cmd *rss_cmd; @@ -446,7 +451,7 @@ static void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self) printf("#################### END #######################\n"); } -static int hikp_nic_cmd_get_rss_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_rss_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_rss_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_rss/hikp_nic_rss.h b/net/nic/nic_rss/hikp_nic_rss.h index 39b3300..47aa2b9 100644 --- a/net/nic/nic_rss/hikp_nic_rss.h +++ b/net/nic/nic_rss/hikp_nic_rss.h @@ -91,4 +91,7 @@ struct rss_feature_cmd { void (*show)(const void *data); }; +int hikp_nic_cmd_get_rss_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_rss_cmd_set_feature_idx(int feature_idx); #endif /* HIKP_NIC_RSS_H */ diff --git a/net/nic/nic_torus/hikp_nic_torus.c b/net/nic/nic_torus/hikp_nic_torus.c index 5208bdc..d5e22b1 100644 --- a/net/nic/nic_torus/hikp_nic_torus.c +++ b/net/nic/nic_torus/hikp_nic_torus.c @@ -130,7 +130,7 @@ static void hikp_nic_torus_show(const struct nic_torus_info *info) printf("#################### END ##########################\n"); } -static void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_torus_target.bdf; struct nic_torus_info info = { 0 }; @@ -158,7 +158,7 @@ static int hikp_nic_torus_cmd_help(struct major_cmd_ctrl *self, const char *argv return 0; } -static int hikp_nic_torus_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_torus_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_torus_target); if (self->err_no != 0) { diff --git a/net/nic/nic_torus/hikp_nic_torus.h b/net/nic/nic_torus/hikp_nic_torus.h index e6b6552..064ffa3 100644 --- a/net/nic/nic_torus/hikp_nic_torus.h +++ b/net/nic/nic_torus/hikp_nic_torus.h @@ -73,4 +73,6 @@ struct nic_torus_info { uint32_t ets_tcg0_mapping; }; +int hikp_nic_torus_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_TORUS_H */ diff --git a/net/roce/roce_bond/hikp_roce_bond.c b/net/roce/roce_bond/hikp_roce_bond.c index 8434a0b..5256804 100644 --- a/net/roce/roce_bond/hikp_roce_bond.c +++ b/net/roce/roce_bond/hikp_roce_bond.c @@ -15,6 +15,12 @@ static struct cmd_roce_bond_param g_roce_bond_param = { 0 }; +int hikp_roce_set_bond_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_bond_param.target); +} + static int hikp_roce_bond_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -60,7 +66,7 @@ static int hikp_roce_bond_get_data(struct hikp_cmd_ret **cmd_ret, return ret; } -static void hikp_roce_bond_execute(struct major_cmd_ctrl *self) +void hikp_roce_bond_execute(struct major_cmd_ctrl *self) { hikp_roce_ext_execute(self, GET_ROCEE_BOND_CMD, hikp_roce_bond_get_data); } diff --git a/net/roce/roce_bond/hikp_roce_bond.h b/net/roce/roce_bond/hikp_roce_bond.h index 5e18723..2f61727 100644 --- a/net/roce/roce_bond/hikp_roce_bond.h +++ b/net/roce/roce_bond/hikp_roce_bond.h @@ -26,4 +26,7 @@ struct roce_bond_req_param { uint32_t block_id; }; +int hikp_roce_set_bond_bdf(char *nic_name); +void hikp_roce_bond_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_BOND_H */ diff --git a/net/roce/roce_caep/hikp_roce_caep.c b/net/roce/roce_caep/hikp_roce_caep.c index a52cd54..95795d1 100644 --- a/net/roce/roce_caep/hikp_roce_caep.c +++ b/net/roce/roce_caep/hikp_roce_caep.c @@ -15,6 +15,17 @@ static struct cmd_roce_caep_param_t g_roce_caep_param_t = { 0 }; +int hikp_roce_set_caep_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_caep_param_t.target); +} + +void hikp_roce_set_caep_mode(uint32_t mode) +{ + g_roce_caep_param_t.sub_cmd = mode; +} + static int hikp_roce_caep_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -102,7 +113,7 @@ exec_error: hikp_cmd_free(&cmd_ret); } -static void hikp_roce_caep_execute(struct major_cmd_ctrl *self) +void hikp_roce_caep_execute(struct major_cmd_ctrl *self) { if (g_roce_caep_param_t.sub_cmd == CAEP_ORIGIN) hikp_roce_caep_execute_origin(self); diff --git a/net/roce/roce_caep/hikp_roce_caep.h b/net/roce/roce_caep/hikp_roce_caep.h index becb332..770e2ab 100644 --- a/net/roce/roce_caep/hikp_roce_caep.h +++ b/net/roce/roce_caep/hikp_roce_caep.h @@ -48,4 +48,8 @@ enum roce_caep_cmd_type { CAEP_EXT, }; +int hikp_roce_set_caep_bdf(char *nic_name); +void hikp_roce_set_caep_mode(uint32_t mode); +void hikp_roce_caep_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_CAEP_H */ diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c index 18df065..ca42dfa 100644 --- a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c +++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c @@ -15,6 +15,12 @@ static struct cmd_roce_global_cfg_param g_roce_global_cfg_param = { 0 }; +int hikp_roce_set_global_cfg_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_global_cfg_param.target); +} + static int hikp_roce_global_cfg_help(struct major_cmd_ctrl *self, const char *argv) { @@ -63,7 +69,7 @@ static int hikp_roce_global_cfg_get_data(struct hikp_cmd_ret **cmd_ret, return ret; } -static void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self) +void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self) { enum roce_global_cfg_cmd_type sub_cmds[] = { ROCE_GLB_GENAC, diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.h b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h index aa1db92..eb6f359 100644 --- a/net/roce/roce_global_cfg/hikp_roce_global_cfg.h +++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h @@ -37,4 +37,7 @@ enum roce_global_cfg_cmd_type { ROCE_GLB_NICL, }; +int hikp_roce_set_global_cfg_bdf(char *nic_name); +void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_GLOBAL_CFG_H */ diff --git a/net/roce/roce_gmv/hikp_roce_gmv.c b/net/roce/roce_gmv/hikp_roce_gmv.c index 1b7db32..5f96451 100644 --- a/net/roce/roce_gmv/hikp_roce_gmv.c +++ b/net/roce/roce_gmv/hikp_roce_gmv.c @@ -16,6 +16,17 @@ static struct cmd_roce_gmv_param g_roce_gmv_param = { 0 }; +int hikp_roce_set_gmv_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_gmv_param.target); +} + +void hikp_roce_set_gmv_index(uint32_t gmv_index) +{ + g_roce_gmv_param.gmv_index = gmv_index; +} + static int hikp_roce_gmv_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -83,7 +94,7 @@ static void hikp_roce_gmv_print(uint32_t reg_num, struct roce_gmv_rsp_data *gmv_ printf("*******************************************\n"); } -static void hikp_roce_gmv_execute(struct major_cmd_ctrl *self) +void hikp_roce_gmv_execute(struct major_cmd_ctrl *self) { struct roce_gmv_req_para req_data = { 0 }; struct roce_gmv_rsp_data *gmv_rsp = NULL; diff --git a/net/roce/roce_gmv/hikp_roce_gmv.h b/net/roce/roce_gmv/hikp_roce_gmv.h index 8bc49d0..29c2e6d 100644 --- a/net/roce/roce_gmv/hikp_roce_gmv.h +++ b/net/roce/roce_gmv/hikp_roce_gmv.h @@ -38,4 +38,8 @@ enum roce_gmv_cmd_type { GMV_SHOW = 0x0, }; +int hikp_roce_set_gmv_bdf(char *nic_name); +void hikp_roce_set_gmv_index(uint32_t gmv_index); +void hikp_roce_gmv_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_GMV_H */ diff --git a/net/roce/roce_mdb/hikp_roce_mdb.c b/net/roce/roce_mdb/hikp_roce_mdb.c index a578c87..e0a7cc5 100644 --- a/net/roce/roce_mdb/hikp_roce_mdb.c +++ b/net/roce/roce_mdb/hikp_roce_mdb.c @@ -16,6 +16,17 @@ static struct cmd_roce_mdb_param g_roce_mdb_param = { 0 }; +int hikp_roce_set_mdb_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_mdb_param.target); +} + +void hikp_roce_set_mdb_mode(uint8_t mode) +{ + g_roce_mdb_param.flag = mode; +} + static int hikp_roce_mdb_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -155,7 +166,7 @@ exec_error: hikp_cmd_free(&cmd_ret); } -static void hikp_roce_mdb_execute(struct major_cmd_ctrl *self) +void hikp_roce_mdb_execute(struct major_cmd_ctrl *self) { if (g_roce_mdb_param.flag & ROCE_MDB_CMD_EXT) { g_roce_mdb_param.sub_cmd = (g_roce_mdb_param.flag & ROCE_MDB_CMD_CLEAR) ? diff --git a/net/roce/roce_mdb/hikp_roce_mdb.h b/net/roce/roce_mdb/hikp_roce_mdb.h index e8dfcca..b95bb56 100644 --- a/net/roce/roce_mdb/hikp_roce_mdb.h +++ b/net/roce/roce_mdb/hikp_roce_mdb.h @@ -20,6 +20,7 @@ #define ROCE_HIKP_REG_SWICTH 2 #define ROCE_MDB_CMD_CLEAR (1 << 0) +#define ROCE_MDB_CMD 0 #define ROCE_MDB_CMD_EXT (1 << 1) struct cmd_roce_mdb_param { @@ -49,4 +50,8 @@ enum roce_mdb_cmd_type { MDB_CLEAR_EXT, }; +int hikp_roce_set_mdb_bdf(char *nic_name); +void hikp_roce_set_mdb_mode(uint8_t mode); +void hikp_roce_mdb_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_MDB_H */ diff --git a/net/roce/roce_pkt/hikp_roce_pkt.c b/net/roce/roce_pkt/hikp_roce_pkt.c index 81bdae6..5a6b268 100644 --- a/net/roce/roce_pkt/hikp_roce_pkt.c +++ b/net/roce/roce_pkt/hikp_roce_pkt.c @@ -15,6 +15,12 @@ static struct cmd_roce_pkt_param_t g_roce_pkt_param_t = { 0 }; +int hikp_roce_set_pkt_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_pkt_param_t.target); +} + static int hikp_roce_pkt_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -96,7 +102,7 @@ static void hikp_roce_pkt_print(uint32_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_pkt_execute(struct major_cmd_ctrl *self) +void hikp_roce_pkt_execute(struct major_cmd_ctrl *self) { struct roce_pkt_req_param req_data = { 0 }; struct roce_pkt_res_param *roce_pkt_res; diff --git a/net/roce/roce_pkt/hikp_roce_pkt.h b/net/roce/roce_pkt/hikp_roce_pkt.h index 05d464e..7d23c8f 100644 --- a/net/roce/roce_pkt/hikp_roce_pkt.h +++ b/net/roce/roce_pkt/hikp_roce_pkt.h @@ -39,4 +39,7 @@ struct roce_pkt_res_param { struct roce_pkt_res reg_data; }; +int hikp_roce_set_pkt_bdf(char *nic_name); +void hikp_roce_pkt_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_PKT_H */ diff --git a/net/roce/roce_qmm/hikp_roce_qmm.c b/net/roce/roce_qmm/hikp_roce_qmm.c index 8140080..30caa5a 100644 --- a/net/roce/roce_qmm/hikp_roce_qmm.c +++ b/net/roce/roce_qmm/hikp_roce_qmm.c @@ -16,6 +16,22 @@ static struct cmd_roce_qmm_param_t g_roce_qmm_param = { 0 }; +int hikp_roce_set_qmm_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_qmm_param.target); +} + +void hikp_roce_set_qmm_ext_flag(bool ext_flag) +{ + g_roce_qmm_param.ext_flag = ext_flag; +} + +void hikp_roce_set_qmm_bankid(uint32_t bank_id) +{ + g_roce_qmm_param.bank_id = bank_id; +} + static int hikp_roce_qmm_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -249,7 +265,7 @@ exec_error: hikp_cmd_free(&cmd_ret); } -static void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) +void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) { static const struct cmd_type_info { enum roce_qmm_cmd_type sub_cmd; diff --git a/net/roce/roce_qmm/hikp_roce_qmm.h b/net/roce/roce_qmm/hikp_roce_qmm.h index eb7722b..b13a716 100644 --- a/net/roce/roce_qmm/hikp_roce_qmm.h +++ b/net/roce/roce_qmm/hikp_roce_qmm.h @@ -51,4 +51,9 @@ enum roce_qmm_cmd_type { QMM_SHOW_TOP_EXT, }; +int hikp_roce_set_qmm_bdf(char *nic_name); +void hikp_roce_set_qmm_ext_flag(bool ext_flag); +void hikp_roce_set_qmm_bankid(uint32_t bank_id); +void hikp_roce_qmm_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_QMM_H */ diff --git a/net/roce/roce_rst/hikp_roce_rst.c b/net/roce/roce_rst/hikp_roce_rst.c index 570e7f4..cfccc47 100644 --- a/net/roce/roce_rst/hikp_roce_rst.c +++ b/net/roce/roce_rst/hikp_roce_rst.c @@ -15,6 +15,12 @@ static struct cmd_roce_rst_param g_roce_rst_param = { 0 }; +int hikp_roce_set_rst_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_rst_param.target); +} + static int hikp_roce_rst_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -60,7 +66,7 @@ static int hikp_roce_rst_get_data(struct hikp_cmd_ret **cmd_ret, return ret; } -static void hikp_roce_rst_execute(struct major_cmd_ctrl *self) +void hikp_roce_rst_execute(struct major_cmd_ctrl *self) { hikp_roce_ext_execute(self, GET_ROCEE_RST_CMD, hikp_roce_rst_get_data); } diff --git a/net/roce/roce_rst/hikp_roce_rst.h b/net/roce/roce_rst/hikp_roce_rst.h index e864b68..782d0ff 100644 --- a/net/roce/roce_rst/hikp_roce_rst.h +++ b/net/roce/roce_rst/hikp_roce_rst.h @@ -26,4 +26,7 @@ struct roce_rst_req_param { uint32_t block_id; }; +int hikp_roce_set_rst_bdf(char *nic_name); +void hikp_roce_rst_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_RST_H */ diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c index f330e97..c660799 100644 --- a/net/roce/roce_scc/hikp_roce_scc.c +++ b/net/roce/roce_scc/hikp_roce_scc.c @@ -15,7 +15,7 @@ struct cmd_roce_scc_param_t g_roce_scc_param_t = { 0 }; struct roce_scc_module g_roce_scc_module[] = { - ROCE_SCC_HANDLE(COMMON), + { "COMMON", SCC_COMMON }, ROCE_SCC_HANDLE(DCQCN), ROCE_SCC_HANDLE(DIP), ROCE_SCC_HANDLE(HC3), @@ -23,6 +23,17 @@ struct roce_scc_module g_roce_scc_module[] = { ROCE_SCC_HANDLE(CFG), }; +int hikp_roce_set_scc_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_scc_param_t.target); +} + +void hikp_roce_set_scc_submodule(uint32_t module) +{ + g_roce_scc_param_t.sub_cmd = module; +} + static int hikp_roce_scc_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -78,7 +89,7 @@ static int hikp_roce_scc_clear_set(struct major_cmd_ctrl *self, const char *argv static int hikp_roce_scc_clear_module_check(void) { - if (g_roce_scc_param_t.sub_cmd == COMMON) + if (g_roce_scc_param_t.sub_cmd == SCC_COMMON) return 0; return -EINVAL; @@ -292,7 +303,7 @@ static const struct reg_name_info { const char **reg_name; uint8_t arr_len; } g_scc_reg_name_info_table[] = { - {COMMON, g_scc_common_reg_name, HIKP_ARRAY_SIZE(g_scc_common_reg_name)}, + {SCC_COMMON, g_scc_common_reg_name, HIKP_ARRAY_SIZE(g_scc_common_reg_name)}, {DCQCN, g_scc_dcqcn_reg_name, HIKP_ARRAY_SIZE(g_scc_dcqcn_reg_name)}, {DIP, g_scc_dip_reg_name, HIKP_ARRAY_SIZE(g_scc_dip_reg_name)}, {HC3, g_scc_hc3_reg_name, HIKP_ARRAY_SIZE(g_scc_hc3_reg_name)}, @@ -330,7 +341,7 @@ static void hikp_roce_scc_print(uint8_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_scc_execute(struct major_cmd_ctrl *self) +void hikp_roce_scc_execute(struct major_cmd_ctrl *self) { struct roce_scc_head res_head; uint32_t *offset_start = NULL; diff --git a/net/roce/roce_scc/hikp_roce_scc.h b/net/roce/roce_scc/hikp_roce_scc.h index 9b5c0c5..b86b59a 100644 --- a/net/roce/roce_scc/hikp_roce_scc.h +++ b/net/roce/roce_scc/hikp_roce_scc.h @@ -58,7 +58,7 @@ struct roce_scc_module { }; enum roce_scc_type { - COMMON = 1, + SCC_COMMON = 1, DCQCN, DIP, HC3, @@ -66,4 +66,8 @@ enum roce_scc_type { CFG, }; +int hikp_roce_set_scc_bdf(char *nic_name); +void hikp_roce_set_scc_submodule(uint32_t module); +void hikp_roce_scc_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_SCC_H */ diff --git a/net/roce/roce_timer/hikp_roce_timer.c b/net/roce/roce_timer/hikp_roce_timer.c index 962127b..a6af959 100644 --- a/net/roce/roce_timer/hikp_roce_timer.c +++ b/net/roce/roce_timer/hikp_roce_timer.c @@ -15,6 +15,12 @@ static struct cmd_roce_timer_params g_roce_timer_param = { 0 }; +int hikp_roce_set_timer_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_timer_param.target); +} + static int hikp_roce_timer_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -192,7 +198,7 @@ static int hikp_roce_timer_clear(struct major_cmd_ctrl *self) return 0; } -static void hikp_roce_timer_execute(struct major_cmd_ctrl *self) +void hikp_roce_timer_execute(struct major_cmd_ctrl *self) { int (*func[])(struct major_cmd_ctrl *self) = { hikp_roce_timer_show_cqc, hikp_roce_timer_show_qpc diff --git a/net/roce/roce_timer/hikp_roce_timer.h b/net/roce/roce_timer/hikp_roce_timer.h index 314547e..f82afe1 100644 --- a/net/roce/roce_timer/hikp_roce_timer.h +++ b/net/roce/roce_timer/hikp_roce_timer.h @@ -40,4 +40,7 @@ struct roce_timer_rsp_data { uint32_t timer_content[ROCE_HIKP_TIMER_REG_NUM][2]; }; +int hikp_roce_set_timer_bdf(char *nic_name); +void hikp_roce_timer_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_TIMER_H */ diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c index 68c4cf2..9b1ddb1 100644 --- a/net/roce/roce_trp/hikp_roce_trp.c +++ b/net/roce/roce_trp/hikp_roce_trp.c @@ -18,9 +18,25 @@ struct roce_trp_module g_roce_trp_module[] = { ROCE_TRP_HANDLE(TRP_RX), ROCE_TRP_HANDLE(GEN_AC), ROCE_TRP_HANDLE(PAYL), - ROCE_TRP_HANDLE(COMMON), + { "COMMON", TRP_COMMON }, }; +int hikp_roce_set_trp_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_trp_param_t.target); +} + +void hikp_roce_set_trp_bankid(uint32_t bank_id) +{ + g_roce_trp_param_t.bank_id = bank_id; +} + +void hikp_roce_set_trp_submodule(uint32_t module) +{ + g_roce_trp_param_t.sub_cmd = module; +} + static int hikp_roce_trp_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -86,7 +102,7 @@ static int hikp_roce_trp_bank_get(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_trp_bank_check(void) { switch (g_roce_trp_param_t.sub_cmd) { - case (COMMON): + case (TRP_COMMON): if (g_roce_trp_param_t.bank_id > TRP_MAX_BANK_NUM) return -EINVAL; break; @@ -341,7 +357,7 @@ static const struct reg_name_info { const char **reg_name; uint8_t arr_len; } g_trp_reg_name_info_table[] = { - {COMMON, g_trp_common_reg_name, HIKP_ARRAY_SIZE(g_trp_common_reg_name)}, + {TRP_COMMON, g_trp_common_reg_name, HIKP_ARRAY_SIZE(g_trp_common_reg_name)}, {TRP_RX, g_trp_trp_rx_reg_name, HIKP_ARRAY_SIZE(g_trp_trp_rx_reg_name)}, {GEN_AC, g_trp_gen_ac_reg_name, HIKP_ARRAY_SIZE(g_trp_gen_ac_reg_name)}, {PAYL, g_trp_payl_reg_name, HIKP_ARRAY_SIZE(g_trp_payl_reg_name)}, @@ -377,7 +393,7 @@ static void hikp_roce_trp_print(uint8_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_trp_execute(struct major_cmd_ctrl *self) +void hikp_roce_trp_execute(struct major_cmd_ctrl *self) { struct roce_trp_head res_head; uint32_t *offset_start = NULL; diff --git a/net/roce/roce_trp/hikp_roce_trp.h b/net/roce/roce_trp/hikp_roce_trp.h index 212d36f..023e290 100644 --- a/net/roce/roce_trp/hikp_roce_trp.h +++ b/net/roce/roce_trp/hikp_roce_trp.h @@ -67,7 +67,12 @@ enum roce_trp_type { TRP_RX = 1, GEN_AC, PAYL, - COMMON, + TRP_COMMON, }; +void hikp_roce_set_trp_submodule(uint32_t module); +void hikp_roce_set_trp_bankid(uint32_t bank_id); +int hikp_roce_set_trp_bdf(char *nic_name); +void hikp_roce_trp_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_TRP_H */ diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c index 9dd7956..e07e882 100644 --- a/net/roce/roce_tsp/hikp_roce_tsp.c +++ b/net/roce/roce_tsp/hikp_roce_tsp.c @@ -15,11 +15,27 @@ static struct cmd_roce_tsp_param_t g_roce_tsp_param_t = { 0 }; static struct roce_tsp_module g_roce_tsp_module[] = { - TSP_HANDLE(COMMON), + { "COMMON", TSP_COMMON }, TSP_HANDLE(TDP), TSP_HANDLE(TGP_TMP), }; +int hikp_roce_set_tsp_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_tsp_param_t.target); +} + +void hikp_roce_set_tsp_bankid(uint32_t bank_id) +{ + g_roce_tsp_param_t.bank_id = bank_id; +} + +void hikp_roce_set_tsp_submodule(uint32_t module) +{ + g_roce_tsp_param_t.sub_cmd_code = module; +} + static int hikp_roce_tsp_help(struct major_cmd_ctrl *self, const char *argv) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -85,7 +101,7 @@ static int hikp_roce_tsp_bank_get(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_tsp_bank_check(void) { switch (g_roce_tsp_param_t.sub_cmd_code) { - case (COMMON): + case (TSP_COMMON): if (g_roce_tsp_param_t.bank_id > MAX_TSP_BANK_NUM) return -EINVAL; break; @@ -194,9 +210,11 @@ static const struct reg_name_info { const char **reg_name; uint8_t arr_len; } g_tsp_reg_name_info_table[] = { - {COMMON, g_tsp_common_reg_name, HIKP_ARRAY_SIZE(g_tsp_common_reg_name)}, + {TSP_COMMON, g_tsp_common_reg_name, + HIKP_ARRAY_SIZE(g_tsp_common_reg_name)}, {TDP, g_tsp_tdp_reg_name, HIKP_ARRAY_SIZE(g_tsp_tdp_reg_name)}, - {TGP_TMP, g_tsp_tgp_tmp_reg_name, HIKP_ARRAY_SIZE(g_tsp_tgp_tmp_reg_name)}, + {TGP_TMP, g_tsp_tgp_tmp_reg_name, + HIKP_ARRAY_SIZE(g_tsp_tgp_tmp_reg_name)}, }; static void hikp_roce_tsp_print(uint32_t total_block_num, @@ -229,7 +247,7 @@ static void hikp_roce_tsp_print(uint32_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_tsp_execute(struct major_cmd_ctrl *self) +void hikp_roce_tsp_execute(struct major_cmd_ctrl *self) { struct roce_tsp_res_param *roce_tsp_res; struct roce_tsp_req_param req_data; diff --git a/net/roce/roce_tsp/hikp_roce_tsp.h b/net/roce/roce_tsp/hikp_roce_tsp.h index a35f869..12bd0a3 100644 --- a/net/roce/roce_tsp/hikp_roce_tsp.h +++ b/net/roce/roce_tsp/hikp_roce_tsp.h @@ -56,9 +56,14 @@ struct roce_tsp_module { }; enum roce_tsp_sub_cmd_code { - COMMON = 1, + TSP_COMMON = 1, TDP, TGP_TMP, }; +int hikp_roce_set_tsp_bdf(char *nic_name); +void hikp_roce_set_tsp_bankid(uint32_t bank_id); +void hikp_roce_set_tsp_submodule(uint32_t module); +void hikp_roce_tsp_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_TSP_H */ diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.c b/pcie/func_lib/pcie_func/pcie_link_ltssm.c index d3534f5..695d40f 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.c +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.c @@ -69,7 +69,7 @@ union pm_state_reg { uint64_t val; }; -static int pcie_get_ltssm_trace(uint32_t port_id, uint64_t *ltssm_status, uint32_t *ltssm_num) +int pcie_get_ltssm_trace(uint32_t port_id, uint64_t *ltssm_status, uint32_t *ltssm_num) { struct hikp_cmd_header req_header; struct hikp_cmd_ret *cmd_ret = NULL; diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.h b/pcie/func_lib/pcie_func/pcie_link_ltssm.h index 278f3e4..9d02557 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.h +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.h @@ -59,5 +59,6 @@ int pcie_ltssm_trace_clear(uint32_t port_id); int pcie_ltssm_trace_mode_set(uint32_t port_id, uint32_t mode); int pcie_ltssm_link_status_get(uint32_t port_id); int pcie_pm_trace(uint32_t port_id); +int pcie_get_ltssm_trace(uint32_t port_id, uint64_t *ltssm_status, uint32_t *ltssm_num); #endif /* PCIE_LINK_LTSSM_H */ diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c index abf0e26..0ce2e5d 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.c +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c @@ -17,13 +17,13 @@ #include #include #include -#include "tool_lib.h" #include "hikptdev_plug.h" #include "os_common.h" #include "pcie_common.h" #include "pcie_reg_dump.h" int g_pcie_dumpreg_fd; +char dumpreg_log_file[MAX_LOG_NAME_LEN + 1] = {0}; struct pcie_dumpreg_info g_reg_table_tl[] = { {0, "TL_ASPM_IDLE_CNT"}, @@ -412,6 +412,9 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) if (ret) return -EINVAL; + 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); /* Add write permission to the file */ fd_file = open(file_name, O_RDWR | O_SYNC | O_CREAT, 0600); @@ -558,7 +561,7 @@ int pcie_dumpreg_do_dump(uint32_t port_id, uint32_t dump_level) struct pcie_dump_req_para req_data = { 0 }; int ret = 0; - Info("pcie reg dump start.\n"); + Info("hikptool pcie_dumpreg -i %u -l %u -d\n", port_id, dump_level); req_data.port_id = port_id; req_data.level = dump_level; diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.h b/pcie/func_lib/pcie_func/pcie_reg_dump.h index aaf22ba..3c52a6e 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.h +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.h @@ -15,10 +15,12 @@ #define PCIE_REG_DUMP_H #include "pcie_common_api.h" +#include "tool_lib.h" #define PCIE_REG_NAME_LEN 60 #define MAX_STR_LEN 80 #define PCIE_DUMPREG_LOGFILE_NAME "pcie_dumpreg" +#define LOG_FILE_PATH_MAX_LEN 512 #define HIKP_PCIE_PCS_LANE_TBL_ENTRY(name) \ {0, STR(CONTACT(name, _00))}, {0, STR(CONTACT(name, _01))}, \ @@ -54,6 +56,8 @@ struct pcie_dumpreg_table { struct pcie_dumpreg_info *dump_info; }; +extern char dumpreg_log_file[MAX_LOG_NAME_LEN + 1]; int pcie_dumpreg_do_dump(uint32_t port_id, uint32_t dump_level); + #endif /* PCIE_REG_DUMP_H */ diff --git a/pcie/func_lib/pcie_func/pcie_statistics.c b/pcie/func_lib/pcie_func/pcie_statistics.c index be187f2..c7fee0b 100644 --- a/pcie/func_lib/pcie_func/pcie_statistics.c +++ b/pcie/func_lib/pcie_func/pcie_statistics.c @@ -29,7 +29,7 @@ static const char *g_global_ndie_name[] = { "Ndie_A", "Ndie_B", "Ndie_C", "Ndie_D" }; -static int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num) +int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num) { size_t rsp_data_size, expect_data_size; struct pcie_port_info *port_info = NULL; diff --git a/pcie/func_lib/pcie_func/pcie_statistics.h b/pcie/func_lib/pcie_func/pcie_statistics.h index c373573..d7a68e2 100644 --- a/pcie/func_lib/pcie_func/pcie_statistics.h +++ b/pcie/func_lib/pcie_func/pcie_statistics.h @@ -15,6 +15,7 @@ #define PCIE_STATISTICS_H #include "pcie_common_api.h" +#include "hikptdev_plug.h" #define GLOBAL_WIDTH_TABLE_SIZE 5 #define MAX_MACRO_ONEPORT 3 @@ -126,5 +127,6 @@ struct pcie_info_req_para { int pcie_port_distribution_get(uint32_t chip_id); int pcie_error_state_get(uint32_t port_id); int pcie_error_state_clear(uint32_t port_id); +int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num); #endif /* PCIE_STATISTICS_H */ diff --git a/sas/sas_func/sas_common.h b/sas/sas_func/sas_common.h index eed0fa5..78edf2e 100644 --- a/sas/sas_func/sas_common.h +++ b/sas/sas_func/sas_common.h @@ -16,7 +16,7 @@ #define RESP_MAX_NUM 60 #define SAS_MAX_PHY_NUM 7 -#define SAS_MAX_ERR_NUM 6 +#define SAS_MAX_ERR_NUM 5 #define SAS_ERR_NUM 4 #define SAS_QUEUE_NUM 16 #define IPTT_ICT_STATUS 29 diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c index 92e380e..2367382 100644 --- a/serdes/hikp_serdes.c +++ b/serdes/hikp_serdes.c @@ -24,6 +24,10 @@ static struct cmd_serdes_param g_serdes_param = {0xff, 0xff, 0xff, 0xff, 0xff, 0 #define SERDES_OUTPUT_MAX_SIZE 2560 static char g_serdes_data_out_buf[SERDES_OUTPUT_MAX_SIZE] = {0}; +static struct hilink_cmd_out g_out_put = {0}; + +static void hikp_serdes_info_print(struct cmd_serdes_param *cmd); +static void hikp_serdes_dump_print(struct cmd_serdes_param *cmd); static int cmd_serdes_maininfo_help(struct major_cmd_ctrl *self, const char *argv) { @@ -120,12 +124,12 @@ static int cmd_serdes_key_info_pro(struct major_cmd_ctrl *self, const char *argv } #define USEMODE_SSC_STR_MAXLEN 20 -static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, - const struct hilink_brief_info *data, uint32_t data_size) +static void hikp_serdes_brief_info_print(struct cmd_serdes_param *cmd, + const struct hilink_brief_info *data, uint32_t data_size) { uint8_t ds_id; - uint8_t start_sds_id = g_serdes_param.start_sds_id; - uint8_t sds_num = g_serdes_param.sds_num; + uint8_t start_sds_id = cmd->start_sds_id; + uint8_t sds_num = cmd->sds_num; char usemode_ssc_str[USEMODE_SSC_STR_MAXLEN] = {0}; const char *usemode_array[HILINK_USE_MODE_END] = { "default", "pcie", "sata", "sas", "hccs", @@ -136,26 +140,20 @@ static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, }; if (data_size != sds_num) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes brief info data size is wrong."); + printf("serdes brief info data size is wrong.\n"); return; } for (ds_id = 0; ds_id < sds_num; ds_id++) { if (data[ds_id].usemode >= HILINK_USE_MODE_END) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "usemode[%u] is out of range.", data[ds_id].usemode); + printf("usemode[%u] is out of range.\n", data[ds_id].usemode); return; } strncpy(usemode_ssc_str, usemode_array[data[ds_id].usemode], sizeof(usemode_ssc_str) - 1); if (data[ds_id].ssc_type >= HILINK_SSC_TYPE_END) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "ssc_type[%u] is out of range.", data[ds_id].ssc_type); + printf("ssc_type[%u] is out of range.\n", data[ds_id].ssc_type); return; } if (data[ds_id].usemode < HILINK_USE_MODE_HCCS) { @@ -165,7 +163,7 @@ static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, } printf("chip%u (M%u,ds%d) pll(%u, %u) pn(%u, %u) power(%u, %u)" "(refclk_sel:%u) rate(%u, %u Mhz) usemode(%s)\n", - g_serdes_param.chip_id, g_serdes_param.macro_id, + cmd->chip_id, cmd->macro_id, ds_id + start_sds_id, data[ds_id].tx_cs_sel, data[ds_id].rx_cs_sel, data[ds_id].tx_pn, data[ds_id].rx_pn, data[ds_id].tx_power, data[ds_id].rx_power, @@ -200,25 +198,22 @@ static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, "-------------------------------------------------" \ "--------------------------------\n") -static void hikp_serdes_detail_info_print(struct major_cmd_ctrl *self, - const struct hilink_detail_info *data, - uint32_t data_size) +static void hikp_serdes_detail_info_print(struct cmd_serdes_param *cmd, + const struct hilink_detail_info *data, uint32_t data_size) { uint32_t i; uint8_t ds_id; - uint8_t start_sds_id = g_serdes_param.start_sds_id; - uint8_t sds_num = g_serdes_param.sds_num; + uint8_t start_sds_id = cmd->start_sds_id; + uint8_t sds_num = cmd->sds_num; if (data_size != sds_num) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes detail info data size is wrong."); + printf("serdes detail info data size is wrong.\n"); return; } printf(KEY_INFO_TITLE); for (ds_id = 0; ds_id < sds_num; ds_id++) { printf("chip%u (M%u,ds%d) [%3d,%3d,%3u,%3d,%3d]", - g_serdes_param.chip_id, g_serdes_param.macro_id, ds_id + start_sds_id, + cmd->chip_id, cmd->macro_id, ds_id + start_sds_id, data[ds_id].tx_cfg.fir_pre2, data[ds_id].tx_cfg.fir_pre1, data[ds_id].tx_cfg.fir_main, data[ds_id].tx_cfg.fir_post1, data[ds_id].tx_cfg.fir_post2); @@ -243,6 +238,8 @@ static void hikp_serdes_detail_info_print(struct major_cmd_ctrl *self, static void hikp_serdes_logout_init(struct hilink_cmd_out *logout, char *buffer, uint32_t size, uint32_t type) { + memset(buffer, 0, size); + logout->str_len = size; logout->result_offset = 0; logout->out_str = buffer; @@ -282,67 +279,88 @@ static int hikp_serdes_info_para_check(struct major_cmd_ctrl *self) return 0; } -static void hikp_serdes_info_cmd_execute(struct major_cmd_ctrl *self) +static void hikp_serdes_print(struct cmd_serdes_param *cmd) +{ + if (cmd->cmd_type == SERDES_KEY_INFO) + hikp_serdes_info_print(cmd); + else if (cmd->cmd_type == SERDES_DUMP_REG) + hikp_serdes_dump_print(cmd); +} + +int hikp_serdes_get_reponse(struct cmd_serdes_param *cmd) { struct hikp_cmd_header req_header = {0}; struct hikp_cmd_ret *cmd_ret; struct hilink_cmd_in hilink_cmd = {0}; - struct hilink_brief_info *brief_info_data = NULL; - struct hilink_detail_info *detail_info_data = NULL; - struct hilink_cmd_out out_put; size_t out_out_header_size; - int ret; - - ret = hikp_serdes_info_para_check(self); - if (ret != 0) - return; - hikp_serdes_logout_init(&out_put, g_serdes_data_out_buf, SERDES_OUTPUT_MAX_SIZE, 0); + hilink_cmd.cmd_type = cmd->cmd_type; + hilink_cmd.sub_cmd = cmd->sub_cmd; + hilink_cmd.cmd_para.chip_id = cmd->chip_id; + hilink_cmd.cmd_para.macro_id = cmd->macro_id; + hilink_cmd.cmd_para.start_sds_id = cmd->start_sds_id; + hilink_cmd.cmd_para.sds_num = cmd->sds_num; - hilink_cmd.cmd_type = SERDES_KEY_INFO; - hilink_cmd.sub_cmd = g_serdes_param.sub_cmd; - hilink_cmd.cmd_para.chip_id = g_serdes_param.chip_id; - hilink_cmd.cmd_para.macro_id = g_serdes_param.macro_id; - hilink_cmd.cmd_para.start_sds_id = g_serdes_param.start_sds_id; - hilink_cmd.cmd_para.sds_num = g_serdes_param.sds_num; + hikp_serdes_logout_init(&g_out_put, g_serdes_data_out_buf, SERDES_OUTPUT_MAX_SIZE, 0); - hikp_cmd_init(&req_header, SERDES_MOD, SERDES_KEY_INFO, g_serdes_param.sub_cmd); + hikp_cmd_init(&req_header, SERDES_MOD, cmd->cmd_type, cmd->sub_cmd); cmd_ret = hikp_cmd_alloc(&req_header, &hilink_cmd, sizeof(hilink_cmd)); if (cmd_ret == NULL || cmd_ret->status != 0) { - snprintf(self->err_str, sizeof(self->err_str), "hikp_cmd_alloc err."); - self->err_no = -EINVAL; - goto err_out; + printf("hikp_cmd_alloc err.\n"); + hikp_cmd_free(&cmd_ret); + return -EINVAL; } - out_out_header_size = sizeof(out_put.str_len) + sizeof(out_put.result_offset) + - sizeof(out_put.type) + sizeof(out_put.ret_val); - memcpy(&out_put, cmd_ret->rsp_data, out_out_header_size); + out_out_header_size = sizeof(g_out_put.str_len) + sizeof(g_out_put.result_offset) + + sizeof(g_out_put.type) + sizeof(g_out_put.ret_val); + memcpy(&g_out_put, cmd_ret->rsp_data, out_out_header_size); - if ((cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size) > - SERDES_OUTPUT_MAX_SIZE) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes_info rsp_data data copy size error, data size:0x%zx max size:0x%x.", + if ((cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size) > SERDES_OUTPUT_MAX_SIZE) { + printf("serdes_info rsp_data data copy size error, data size:0x%zx max size:0x%x.", (cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size), SERDES_OUTPUT_MAX_SIZE); - goto err_out; + hikp_cmd_free(&cmd_ret); + return -EINVAL; } - memcpy(out_put.out_str, cmd_ret->rsp_data + out_out_header_size / sizeof(uint32_t), + memcpy(g_out_put.out_str, cmd_ret->rsp_data + out_out_header_size / sizeof(uint32_t), cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size); + hikp_cmd_free(&cmd_ret); + + hikp_serdes_print(cmd); + + return 0; +} - if (g_serdes_param.sub_cmd > 0) { - detail_info_data = (struct hilink_detail_info *)out_put.out_str; - hikp_serdes_detail_info_print(self, detail_info_data, - out_put.result_offset / - sizeof(struct hilink_detail_info)); +static void hikp_serdes_info_print(struct cmd_serdes_param *cmd) +{ + struct hilink_brief_info *brief_info_data = NULL; + struct hilink_detail_info *detail_info_data = NULL; + + if (cmd->sub_cmd > 0) { + detail_info_data = (struct hilink_detail_info *)g_out_put.out_str; + hikp_serdes_detail_info_print(cmd, detail_info_data, + g_out_put.result_offset / sizeof(struct hilink_detail_info)); } else { - brief_info_data = (struct hilink_brief_info *)out_put.out_str; - hikp_serdes_brief_info_print(self, brief_info_data, - out_put.result_offset / - sizeof(struct hilink_brief_info)); + brief_info_data = (struct hilink_brief_info *)g_out_put.out_str; + hikp_serdes_brief_info_print(cmd, brief_info_data, + g_out_put.result_offset / sizeof(struct hilink_brief_info)); } +} -err_out: - hikp_cmd_free(&cmd_ret); +static void hikp_serdes_info_cmd_execute(struct major_cmd_ctrl *self) +{ + int ret; + + ret = hikp_serdes_info_para_check(self); + if (ret != 0) + return; + + g_serdes_param.cmd_type = SERDES_KEY_INFO; + ret = hikp_serdes_get_reponse(&g_serdes_param); + if (ret != 0) { + self->err_no = ret; + snprintf(self->err_str, sizeof(self->err_str), "serdes_info hikp_serdes_get_reponse err\n"); + return; + } } static void cmd_serdes_maininfo_init(void) @@ -393,22 +411,27 @@ _SERDES_DUMP_SUBCMD_PRO_: return 0; } -static void hikp_serdes_dump_print(struct major_cmd_ctrl *self, - const uint32_t *data, uint32_t data_size) +static void hikp_serdes_dump_print(struct cmd_serdes_param *cmd) { + uint32_t *dump_data = (uint32_t *)g_out_put.out_str; + uint32_t data_size = g_out_put.result_offset / sizeof(uint32_t); uint32_t i; + if (g_out_put.type == 1) { /* 0:data; 1:string */ + printf("serdes dump data type is string, buffer is not enough.\n"); + return; + } + /* 2: Check whether addresses and values are paired */ if (data_size == 0 || data_size % 2 != 0) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), "serdes dump data size is wrong."); + printf("serdes dump data size is wrong.\n"); return; } printf("\n[-------Macro%uCS/DS%u-------]\nAddr Value", - g_serdes_param.macro_id, g_serdes_param.start_sds_id); + cmd->macro_id, cmd->start_sds_id); for (i = 0; i < data_size; i += 2) { /* 2: Addresses and values are paired */ - printf("\n0x%04x 0x%08x", data[i], data[i + 1]); + printf("\n0x%04x 0x%08x", dump_data[i], dump_data[i + 1]); } printf("\n"); } @@ -444,59 +467,19 @@ static int hikp_serdes_dump_para_check(struct major_cmd_ctrl *self) static void hikp_serdes_dump_cmd_execute(struct major_cmd_ctrl *self) { - struct hikp_cmd_header req_header = {0}; - struct hikp_cmd_ret *cmd_ret; - struct hilink_cmd_in hilink_cmd = {0}; - uint32_t *dump_data = NULL; - struct hilink_cmd_out out_put; - size_t out_out_header_size; int ret; ret = hikp_serdes_dump_para_check(self); if (ret != 0) return; - hikp_serdes_logout_init(&out_put, g_serdes_data_out_buf, SERDES_OUTPUT_MAX_SIZE, 0); - - hilink_cmd.cmd_type = SERDES_DUMP_REG; - hilink_cmd.sub_cmd = g_serdes_param.sub_cmd; - hilink_cmd.cmd_para.chip_id = g_serdes_param.chip_id; - hilink_cmd.cmd_para.macro_id = g_serdes_param.macro_id; - hilink_cmd.cmd_para.start_sds_id = g_serdes_param.start_sds_id; - - hikp_cmd_init(&req_header, SERDES_MOD, SERDES_DUMP_REG, g_serdes_param.sub_cmd); - cmd_ret = hikp_cmd_alloc(&req_header, &hilink_cmd, sizeof(hilink_cmd)); - if (cmd_ret == NULL || cmd_ret->status != 0) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), "hikp_cmd_alloc err."); - goto err_out; - } - out_out_header_size = sizeof(out_put.str_len) + sizeof(out_put.result_offset) + - sizeof(out_put.type) + sizeof(out_put.ret_val); - memcpy(&out_put, cmd_ret->rsp_data, out_out_header_size); - - if ((cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size) > - SERDES_OUTPUT_MAX_SIZE) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes_dump rsp_data data copy size error, data size:0x%zx max size:0x%x.", - (cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size), - SERDES_OUTPUT_MAX_SIZE); - goto err_out; - } - memcpy(out_put.out_str, cmd_ret->rsp_data + out_out_header_size / sizeof(uint32_t), - cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size); - if (out_put.type == 1) { /* 0:data; 1:string */ - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes dump data type is string, buffer is not enough."); - goto err_out; + g_serdes_param.cmd_type = SERDES_DUMP_REG; + ret = hikp_serdes_get_reponse(&g_serdes_param); + if (ret != 0) { + self->err_no = ret; + snprintf(self->err_str, sizeof(self->err_str), "serdes_dump hikp_serdes_get_reponse err\n"); + return; } - - dump_data = (uint32_t *)out_put.out_str; - hikp_serdes_dump_print(self, dump_data, out_put.result_offset / sizeof(uint32_t)); -err_out: - hikp_cmd_free(&cmd_ret); } static void cmd_serdes_dump_init(void) diff --git a/serdes/hikp_serdes.h b/serdes/hikp_serdes.h index 2c04e8a..4ea969d 100644 --- a/serdes/hikp_serdes.h +++ b/serdes/hikp_serdes.h @@ -113,7 +113,7 @@ struct cmd_serdes_param { uint8_t sds_num; uint8_t val; uint8_t sub_cmd; - uint8_t rsvd1; + uint8_t cmd_type; uint8_t rsvd2; }; @@ -210,4 +210,6 @@ struct hilink_brief_info { uint32_t rsvd_1; }; +int hikp_serdes_get_reponse(struct cmd_serdes_param *cmd); + #endif /* HIKP_SERDES_H */ diff --git a/socip/hikp_socip.h b/socip/hikp_socip.h index 8d3f31b..0b82f90 100644 --- a/socip/hikp_socip.h +++ b/socip/hikp_socip.h @@ -46,4 +46,5 @@ struct socip_dump_reg_req_data_t { uint8_t controller_id; }; +void dump_reg_info(const uint32_t *reg_data, uint32_t data_num); #endif /* HIKP_SOCIP_H */ diff --git a/socip/hikp_socip_dumpreg.c b/socip/hikp_socip_dumpreg.c index 4b6b70c..a3a20cb 100644 --- a/socip/hikp_socip_dumpreg.c +++ b/socip/hikp_socip_dumpreg.c @@ -105,7 +105,7 @@ static bool check_socip_dumpreg_param(void) return ret; } -static void dump_reg_info(const uint32_t *reg_data, uint32_t data_num) +void dump_reg_info(const uint32_t *reg_data, uint32_t data_num) { #define ONE_LINE_PRINT_DATA_NUM 4 uint32_t i; diff --git a/tool_lib/tool_lib.c b/tool_lib/tool_lib.c index 4d02bdd..62f5fbb 100644 --- a/tool_lib/tool_lib.c +++ b/tool_lib/tool_lib.c @@ -16,6 +16,46 @@ #include #include +uint32_t get_chip_type(void) +{ + char part_num_str[MIDR_BUFFER_SIZE] = {0}; + char midr_buffer[MIDR_BUFFER_SIZE] = {0}; + uint32_t chip_type = CHIP_UNKNOW; + uint64_t midr_el1; + uint32_t part_num; + FILE *file; + + file = fopen(MIDR_EL1_PATH, "r"); + if (file == NULL) { + HIKP_ERROR_PRINT("Open file: %s failed\n", MIDR_EL1_PATH); + return chip_type; + } + + if (fgets(midr_buffer, MIDR_BUFFER_SIZE, file) == NULL) { + HIKP_ERROR_PRINT("Read file: %s failed\n", MIDR_EL1_PATH); + fclose(file); + return chip_type; + } + + fclose(file); + midr_el1 = strtoul(midr_buffer, NULL, MIDR_HEX_TYPE); + part_num = (midr_el1 & 0xffff) >> PART_NUM_OFFSET; + (void)snprintf(part_num_str, MIDR_BUFFER_SIZE, "%x", part_num); + + if (strcmp(part_num_str, "d02") == 0) + chip_type = CHIP_HIP09; + else if (strcmp(part_num_str, "d03") == 0) + chip_type = CHIP_HIP10; + else if (strcmp(part_num_str, "d45") == 0) + chip_type = CHIP_HIP10C; + else if (strcmp(part_num_str, "d22") == 0) + chip_type = CHIP_HIP11; + else + chip_type = CHIP_UNKNOW; + + return chip_type; +} + int string_toui(const char *nptr, uint32_t *value) { char *endptr = NULL; diff --git a/tool_lib/tool_lib.h b/tool_lib/tool_lib.h index 34cc3e8..3bf7bf8 100644 --- a/tool_lib/tool_lib.h +++ b/tool_lib/tool_lib.h @@ -90,6 +90,22 @@ struct type_trans { #define HIKP_WARN_PRINT(x, args...) HIKP_LOG_PRINT("[ WARN ] " x, ##args) #define HIKP_INFO_PRINT(x, args...) HIKP_LOG_PRINT("[ INFO ] " x, ##args) #define HIKP_DBG_PRINT(x, args...) HIKP_LOG_PRINT("[ DBG ] " x, ##args) +#define HIKP_SET_USED(x) (void)(x) + +#define MIDR_EL1_PATH "/sys/devices/system/cpu/cpu0/regs/identification/midr_el1" +#define MIDR_BUFFER_SIZE 20 +#define PART_NUM_OFFSET 4 +#define MIDR_HEX_TYPE 16 + +enum chip_type { + CHIP_HIP09, + CHIP_HIP10, + CHIP_HIP10C, + CHIP_HIP11, + CHIP_UNKNOW, +}; + +uint32_t get_chip_type(void); int string_toui(const char *nptr, uint32_t *value); int string_toub(const char *nptr, uint8_t *value); -- Gitee From 51e5adf45e63cb8e173d5ada25aece7f98aaff96 Mon Sep 17 00:00:00 2001 From: veega2022 Date: Fri, 14 Mar 2025 20:10:53 +0800 Subject: [PATCH 2/9] hikptool: Added compilation options. The following compilation options are added: -Wuninitialized -Wundef -Wunused -Wdate-time -Wshadow -Wvla -Wdisabled-optimization -Wempty-body -Wignored-qualifiers -Wimplicit-fallthrough=3 -Wtype-limits -Wshift-negative-value -Wswitch-default -Wframe-larger-than=8192 -Wshift-overflow=2 -Wwrite-strings -Wmissing-format-attribute -Wformat-nonliteral -Wduplicated-cond -Wtrampolines -Wlogical-op -Wsuggest-attribute=format -Wduplicated-branches -Wmissing-include-dirs -Wmissing-declarations -Wreturn-local-addr -Wredundant-decls -Wfloat-conversion -Wmissing-prototypes -Wno-discarded-qualifiers -Wstrict-prototypes And alos rectify compilation alarms and errors. Signed-off-by: veega2022 --- CMakeLists.txt | 10 +++++- cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c | 16 ++++++++++ cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c | 16 ++++++++++ cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c | 10 ++++++ cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c | 13 ++++++++ libhikptdev/src/rciep/hikpt_rciep.c | 28 ++++++++++------ net/hikp_net_lib.c | 4 +-- net/nic/nic_dfx/hikp_nic_dfx.c | 2 ++ net/nic/nic_fd/hikp_nic_fd.c | 23 +++++++------ net/nic/nic_fec/hikp_nic_fec.c | 2 ++ net/nic/nic_ft/hikp_nic_port_fault.c | 2 ++ net/nic/nic_gro/hikp_nic_gro.c | 2 ++ net/nic/nic_info/hikp_nic_info.c | 2 ++ net/nic/nic_log/hikp_nic_log.c | 2 ++ net/nic/nic_mac/hikp_nic_mac_dump.c | 4 +++ net/nic/nic_mac/hikp_nic_port.c | 2 ++ net/nic/nic_mac/hikp_nic_xsfp.c | 17 ++++++---- net/nic/nic_ncsi/hikp_nic_ncsi.c | 2 ++ net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c | 2 ++ net/nic/nic_ppp/hikp_nic_ppp.c | 4 +++ net/nic/nic_qos/hikp_nic_qos.c | 2 ++ net/nic/nic_queue/hikp_nic_queue.c | 2 ++ net/nic/nic_rss/hikp_nic_rss.c | 2 ++ net/nic/nic_torus/hikp_nic_torus.c | 2 ++ net/roce/roce_bond/hikp_roce_bond.c | 4 +++ net/roce/roce_caep/hikp_roce_caep.c | 7 ++++ .../roce_global_cfg/hikp_roce_global_cfg.c | 6 +++- net/roce/roce_gmv/hikp_roce_gmv.c | 4 +++ net/roce/roce_mdb/hikp_roce_mdb.c | 8 +++++ net/roce/roce_pkt/hikp_roce_pkt.c | 5 +++ net/roce/roce_qmm/hikp_roce_qmm.c | 10 ++++-- net/roce/roce_rst/hikp_roce_rst.c | 4 +++ net/roce/roce_scc/hikp_roce_scc.c | 5 +++ net/roce/roce_timer/hikp_roce_timer.c | 11 ++++++- net/roce/roce_trp/hikp_roce_trp.c | 2 ++ net/roce/roce_tsp/hikp_roce_tsp.c | 5 +++ net/roh/hikp_roh_mac.c | 6 ++-- net/roh/hikp_roh_show_bp.c | 5 +++ net/roh/hikp_roh_show_mib.c | 5 +++ net/ub/ub_bp/hikp_ub_bp.c | 2 ++ net/ub/ub_crd/hikp_ub_crd.c | 2 ++ net/ub/ub_dfx/hikp_ub_dfx.c | 2 ++ net/ub/ub_info/hikp_ub_info.c | 2 ++ net/ub/ub_link/hikp_ub_link.c | 2 ++ net/ub/ub_ppp/hikp_unic_ppp.c | 7 ++-- pcie/func_lib/pcie_func/pcie_reg_dump.c | 2 +- pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c | 9 ++++++ pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c | 13 ++++++++ pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c | 11 +++++++ pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c | 18 +++++++++++ sas/sas_func/sas_analy_queue.c | 2 +- sas/sas_func/sas_dump_reg.c | 6 ++-- sas/sas_func/sas_read_dev.c | 6 ++-- sas/sas_func/sas_read_dqe.c | 6 ++-- sas/sas_func/sas_read_errcode.c | 2 +- sas/user_cmd/cmd_code/sas_cmd_anacq.c | 8 +++++ sas/user_cmd/cmd_code/sas_cmd_anadq.c | 8 +++++ sas/user_cmd/cmd_code/sas_cmd_common.c | 2 +- sas/user_cmd/cmd_code/sas_cmd_dev.c | 5 +++ sas/user_cmd/cmd_code/sas_cmd_dqe.c | 4 ++- sas/user_cmd/cmd_code/sas_cmd_dump.c | 8 +++++ sas/user_cmd/cmd_code/sas_cmd_errcode.c | 2 ++ sata/sata_func/sata_dump_reg.c | 4 +-- sata/user_cmd/cmd_code/sata_cmd_dump.c | 11 +++++++ serdes/hikp_serdes.c | 7 ++++ socip/hikp_socip_dumpreg.c | 2 ++ tool_lib/op_logs.c | 32 +++++++++---------- tool_lib/tool_lib.c | 2 +- tool_lib/tool_lib.h | 4 +++ 69 files changed, 377 insertions(+), 72 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f28a870..56cc932 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,7 +11,15 @@ project(hikptool C) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 -fPIC -fPIE -Wall -Werror -fno-common -std=gnu11") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \ + -O2 -fPIC -fPIE -Wall -Werror -Wextra -Wuninitialized -Wundef -Wunused -Wdate-time \ + -Wshadow -Wvla -Wdisabled-optimization -Wempty-body -Wignored-qualifiers \ + -Wimplicit-fallthrough=3 -Wtype-limits -Wshift-negative-value -Wswitch-default \ + -Wframe-larger-than=8192 -Wshift-overflow=2 -Wwrite-strings -Wmissing-format-attribute \ + -Wformat-nonliteral -Wduplicated-cond -Wtrampolines -Wlogical-op -Wsuggest-attribute=format \ + -Wduplicated-branches -Wmissing-include-dirs -Wmissing-declarations \ + -Wreturn-local-addr -Wredundant-decls -Wfloat-conversion -Wmissing-prototypes \ + -Wno-discarded-qualifiers -Wstrict-prototypes -fno-common -std=gnu11") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wfloat-equal -fstack-protector-strong -D_FORTIFY_SOURCE=2") set(CMAKE_SKIP_RPATH TRUE) diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c index 2df9dc5..208a7d4 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_cpa_cmd = { static int cxl_cpa_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -44,6 +46,8 @@ static int cxl_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl cpa set port id err %d\n", ret); @@ -56,6 +60,9 @@ static int cxl_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_cpa_err_status_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_ERR; return 0; @@ -63,6 +70,9 @@ static int cxl_cpa_err_status_show(struct major_cmd_ctrl *self, const char *argv static int cxl_cpa_mmrg_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_MMRG; return 0; @@ -70,6 +80,9 @@ static int cxl_cpa_mmrg_show(struct major_cmd_ctrl *self, const char *argv) static int cxl_cpa_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_DUMP; return 0; @@ -77,6 +90,9 @@ static int cxl_cpa_dump(struct major_cmd_ctrl *self, const char *argv) static int cxl_cpa_config(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_CONFIG; return 0; diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c index 226db1e..7ac0784 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_dl_cmd = { static int cxl_dl_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -44,6 +46,8 @@ static int cxl_dl_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl dl set port id err %d\n", ret); @@ -56,6 +60,9 @@ static int cxl_dl_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_err_status(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_ERR; return 0; @@ -63,6 +70,9 @@ static int cxl_dl_err_status(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_DUMP; return 0; @@ -70,6 +80,9 @@ static int cxl_dl_dump(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_dfx(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_DFX; return 0; @@ -77,6 +90,9 @@ static int cxl_dl_dfx(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_fsm_state(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_FSM_STATE; return 0; diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c index f444b56..0ebca4f 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_membar_cmd = { static int cxl_membar_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -42,6 +44,8 @@ static int cxl_membar_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl membar set port id err %d\n", ret); @@ -54,6 +58,9 @@ static int cxl_membar_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_membar_err_info(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_membar_cmd.cmd_type = CXL_MEMBAR_ERR; return 0; @@ -61,6 +68,9 @@ static int cxl_membar_err_info(struct major_cmd_ctrl *self, const char *argv) static int cxl_membar_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_membar_cmd.cmd_type = CXL_MEMBAR_DUMP; return 0; diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c index f83b64d..0179605 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_rcrb_cmd = { static int cxl_rcrb_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -43,6 +45,8 @@ static int cxl_rcrb_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl rcrb set port id err %d\n", ret); @@ -55,6 +59,9 @@ static int cxl_rcrb_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_rcrb_link_status(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_rcrb_cmd.cmd_type = CXL_RCRB_LINK; return 0; @@ -62,6 +69,9 @@ static int cxl_rcrb_link_status(struct major_cmd_ctrl *self, const char *argv) static int cxl_rcrb_header_info(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_rcrb_cmd.cmd_type = CXL_RCRB_HDR; return 0; @@ -69,6 +79,9 @@ static int cxl_rcrb_header_info(struct major_cmd_ctrl *self, const char *argv) static int cxl_rcrb_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_rcrb_cmd.cmd_type = CXL_RCRB_DUMP; return 0; diff --git a/libhikptdev/src/rciep/hikpt_rciep.c b/libhikptdev/src/rciep/hikpt_rciep.c index 5a38b3b..88ac16e 100644 --- a/libhikptdev/src/rciep/hikpt_rciep.c +++ b/libhikptdev/src/rciep/hikpt_rciep.c @@ -526,27 +526,35 @@ static void hikp_munmap(void) g_hikp_rsp = NULL; } +static int hikp_dev_set_iep_fd(char *iep) +{ + char path[PATH_MAX + 1] = { 0 }; + + if (strlen(iep) > PATH_MAX || realpath(iep, path) == NULL) + return -ENOENT; + + g_iep_fd = open(path, O_RDWR | O_SYNC); + if (g_iep_fd < 0) { + printf("failed to open %s.\n", iep); + return -errno; + } + + return 0; +} + int hikp_dev_init(void) { size_t i, len; int ret = 0; char *iep; - char path[PATH_MAX + 1] = { 0 }; iep = hikp_get_iep_dir(HIKP_RESOURCE_DIR); if (iep == NULL) return -ENOENT; - if (strlen(iep) > PATH_MAX || realpath(iep, path) == NULL) { - ret = -ENOENT; - goto out_free_iep; - } - g_iep_fd = open(path, O_RDWR | O_SYNC); - if (g_iep_fd < 0) { - printf("failed to open %s.\n", iep); - ret = -errno; + ret = hikp_dev_set_iep_fd(iep); + if (ret) goto out_free_iep; - } g_hikp_req = (union hikp_space_req *)mmap(0, sizeof(union hikp_space_req), PROT_READ | PROT_WRITE, MAP_SHARED, g_iep_fd, 0); diff --git a/net/hikp_net_lib.c b/net/hikp_net_lib.c index f4d4c2a..7646aad 100644 --- a/net/hikp_net_lib.c +++ b/net/hikp_net_lib.c @@ -309,7 +309,7 @@ int get_vf_dev_info_by_pf_dev_name(const char *pf_dev_name, ret = snprintf(dev_name_dir, sizeof(dev_name_dir), "%s%s%s%u%s", HIKP_NET_DEV_PATH, pf_dev_name, HIKP_VIRTFN_PATH, vf_id, HIKP_NET_PATH); - if (ret < 0 || ret >= sizeof(dev_name_dir)) { + if (ret < 0 || ret >= MAX_BUS_PCI_DIR_LEN) { HIKP_ERROR_PRINT("get vf dev_name dir fail.\n"); return -EIO; } @@ -333,7 +333,7 @@ int get_pf_dev_info_by_vf_dev_name(const char *vf_dev_name, struct tool_target * ret = snprintf(dev_name_dir, sizeof(dev_name_dir), "%s%s%s", HIKP_NET_DEV_PATH, vf_dev_name, HIKP_PHYSFN_PATH); - if (ret < 0 || ret >= sizeof(dev_name_dir)) { + if (ret < 0 || ret >= MAX_BUS_PCI_DIR_LEN) { HIKP_ERROR_PRINT("get vf dev_name dir fail.\n"); return -EIO; } diff --git a/net/nic/nic_dfx/hikp_nic_dfx.c b/net/nic/nic_dfx/hikp_nic_dfx.c index 3bc4e05..d6114de 100644 --- a/net/nic/nic_dfx/hikp_nic_dfx.c +++ b/net/nic/nic_dfx/hikp_nic_dfx.c @@ -424,6 +424,8 @@ static void dfx_help_info(const struct major_cmd_ctrl *self) static int hikp_cmd_dfx_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + dfx_help_info(self); return 0; } diff --git a/net/nic/nic_fd/hikp_nic_fd.c b/net/nic/nic_fd/hikp_nic_fd.c index f3edb4f..10fee42 100644 --- a/net/nic/nic_fd/hikp_nic_fd.c +++ b/net/nic/nic_fd/hikp_nic_fd.c @@ -118,6 +118,8 @@ void hikp_nic_set_fd_idx(int feature_idx, int stage_no) static int hikp_nic_fd_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -640,6 +642,8 @@ static int hikp_nic_query_fd_rules(struct hikp_cmd_header *req_header, const str uint32_t idx; int ret = 0; + HIKP_SET_USED(len); + if (stage >= NIC_FD_STAGE_NUM) { HIKP_ERROR_PRINT("The fd stage number(%d) is error!\n", stage + 1); return -EIO; @@ -700,6 +704,8 @@ static int hikp_nic_query_fd_counter(struct hikp_cmd_header *req_header, const s uint16_t idx; int ret = 0; + HIKP_SET_USED(len); + if (stage >= NIC_FD_STAGE_NUM) { HIKP_ERROR_PRINT("The fd stage number(%d) is error!\n", stage + 1); return -EIO; @@ -757,7 +763,7 @@ static int hikp_nic_get_fd_hw_info(const struct bdf_t *bdf, struct nic_fd_hw_inf sizeof(*hw_info)); } -static int hikp_nic_fd_alloc_rules_buf(struct nic_fd_rules *rules, uint8_t stage_num, +static int hikp_nic_fd_alloc_rules_buf(struct nic_fd_rules *rules, struct nic_fd_hw_info *hw_info, uint16_t stage_no) { uint16_t max_key_bytes; @@ -775,7 +781,7 @@ static int hikp_nic_fd_alloc_rules_buf(struct nic_fd_rules *rules, uint8_t stage return 0; } -static int hikp_nic_fd_alloc_counter_buf(struct nic_fd_counter *counter, uint8_t stage_num, +static int hikp_nic_fd_alloc_counter_buf(struct nic_fd_counter *counter, struct nic_fd_hw_info *hw_info, uint16_t stage_no) { counter[stage_no].entry = @@ -789,8 +795,7 @@ static int hikp_nic_fd_alloc_counter_buf(struct nic_fd_counter *counter, uint8_t return 0; } -static union nic_fd_feature_info *hikp_nic_fd_data_alloc(const struct fd_feature_cmd *fd_cmd, - const struct nic_fd_hw_info *hw_cfg) +static union nic_fd_feature_info *hikp_nic_fd_data_alloc(const struct fd_feature_cmd *fd_cmd) { uint16_t stage_no = g_fd_param.stage_no - 1; union nic_fd_feature_info *fd_data; @@ -803,11 +808,9 @@ static union nic_fd_feature_info *hikp_nic_fd_data_alloc(const struct fd_feature } if (strcmp(fd_cmd->feature_name, NIC_FD_RULES_NAME) == 0) - ret = hikp_nic_fd_alloc_rules_buf(fd_data->rules, NIC_FD_STAGE_NUM, - &g_fd_hw_info, stage_no); + ret = hikp_nic_fd_alloc_rules_buf(fd_data->rules, &g_fd_hw_info, stage_no); else if (strcmp(fd_cmd->feature_name, NIC_FD_COUNTER_NAME) == 0) - ret = hikp_nic_fd_alloc_counter_buf(fd_data->counter, NIC_FD_STAGE_NUM, - &g_fd_hw_info, stage_no); + ret = hikp_nic_fd_alloc_counter_buf(fd_data->counter, &g_fd_hw_info, stage_no); if (ret != 0) goto out; @@ -884,7 +887,7 @@ static int hikp_nic_fd_check_entry_index_valid(struct major_cmd_ctrl *self, hw_entry_size = fd_cmd->sub_cmd_code == NIC_FD_RULES_INFO_DUMP ? hw_info->alloc.stage_entry_num[stage_no] : hw_info->alloc.stage_counter_num[stage_no]; - if (fd_param->id >= hw_entry_size) { + if ((uint32_t)fd_param->id >= hw_entry_size) { snprintf(self->err_str, sizeof(self->err_str), "entry id(%d) must be less than hardware specifications(%u).", fd_param->id, hw_entry_size); @@ -963,7 +966,7 @@ void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self) if (ret != 0) return; - fd_data = hikp_nic_fd_data_alloc(fd_cmd, &g_fd_hw_info); + fd_data = hikp_nic_fd_data_alloc(fd_cmd); if (fd_data == NULL) { HIKP_ERROR_PRINT("Fail to alloc fd data memory.\n"); self->err_no = -ENOMEM; diff --git a/net/nic/nic_fec/hikp_nic_fec.c b/net/nic/nic_fec/hikp_nic_fec.c index 13c6e13..8de0b59 100644 --- a/net/nic/nic_fec/hikp_nic_fec.c +++ b/net/nic/nic_fec/hikp_nic_fec.c @@ -126,6 +126,8 @@ void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_fec_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_ft/hikp_nic_port_fault.c b/net/nic/nic_ft/hikp_nic_port_fault.c index 331b1ec..7d15a07 100644 --- a/net/nic/nic_ft/hikp_nic_port_fault.c +++ b/net/nic/nic_ft/hikp_nic_port_fault.c @@ -98,6 +98,8 @@ void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_port_fault_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_gro/hikp_nic_gro.c b/net/nic/nic_gro/hikp_nic_gro.c index d821a47..3e9b31a 100644 --- a/net/nic/nic_gro/hikp_nic_gro.c +++ b/net/nic/nic_gro/hikp_nic_gro.c @@ -71,6 +71,8 @@ void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_gro_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_info/hikp_nic_info.c b/net/nic/nic_info/hikp_nic_info.c index 6fb17a2..b05d6ef 100644 --- a/net/nic/nic_info/hikp_nic_info.c +++ b/net/nic/nic_info/hikp_nic_info.c @@ -25,6 +25,8 @@ static struct nic_info_param g_info_param = { 0 }; static int hikp_nic_cmd_get_info_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_log/hikp_nic_log.c b/net/nic/nic_log/hikp_nic_log.c index be23ca3..0e2d556 100644 --- a/net/nic/nic_log/hikp_nic_log.c +++ b/net/nic/nic_log/hikp_nic_log.c @@ -27,6 +27,8 @@ static char g_log_path[OP_LOG_FILE_PATH_MAXLEN] = {0}; static int hikp_nic_cmd_log_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"); diff --git a/net/nic/nic_mac/hikp_nic_mac_dump.c b/net/nic/nic_mac/hikp_nic_mac_dump.c index 751953c..e0d0891 100644 --- a/net/nic/nic_mac/hikp_nic_mac_dump.c +++ b/net/nic/nic_mac/hikp_nic_mac_dump.c @@ -217,6 +217,8 @@ int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv) static int mac_cmd_dump_reg_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -m \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -235,6 +237,8 @@ static int mac_cmd_dump_reg_help(struct major_cmd_ctrl *self, const char *argv) int mac_cmd_dump_module_cfg(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + g_dump_reg_info.module_name = argv; return 0; diff --git a/net/nic/nic_mac/hikp_nic_port.c b/net/nic/nic_mac/hikp_nic_port.c index 737de07..396c3ec 100644 --- a/net/nic/nic_mac/hikp_nic_port.c +++ b/net/nic/nic_mac/hikp_nic_port.c @@ -619,6 +619,8 @@ static int mac_cmd_get_port_target(struct major_cmd_ctrl *self, const char *argv static int mac_cmd_port_show_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_mac/hikp_nic_xsfp.c b/net/nic/nic_mac/hikp_nic_xsfp.c index 91daa52..fc24d59 100644 --- a/net/nic/nic_mac/hikp_nic_xsfp.c +++ b/net/nic/nic_mac/hikp_nic_xsfp.c @@ -313,7 +313,7 @@ static void sfp_print_dom_info(const struct sfp_page_info *info) (int8_t)info->page_a2.temperature[0], info->page_a2.temperature[1]); } -static void hikp_show_sfp_info(const uint8_t *data, uint32_t size) +static void hikp_show_sfp_info(const uint8_t *data) { struct sfp_page_info *sfp_data = (struct sfp_page_info *)data; @@ -412,7 +412,7 @@ static void qsfp_print_dom_info(const struct qsfp_page0_info *info) (int8_t)info->page_lower.temperature_msb, info->page_lower.temperature_lsb); } -static void hikp_show_qsfp_info(const uint8_t *data, uint32_t size) +static void hikp_show_qsfp_info(const uint8_t *data) { struct qsfp_page0_info *qsfp_data = (struct qsfp_page0_info *)(data); @@ -554,7 +554,7 @@ static void cmis_print_dom_info(const struct cmis_page_info *info) info->page0_lower.module_temp[1]); } -static void hikp_show_cmis_info(const uint8_t *data, uint32_t size) +static void hikp_show_cmis_info(const uint8_t *data) { struct cmis_page_info *cmis_data = (struct cmis_page_info *)data; @@ -567,17 +567,17 @@ static void hikp_show_cmis_info(const uint8_t *data, uint32_t size) static void hikp_xsfp_parse_info(const uint8_t *data, uint32_t size) { if (data[SFF_ID_OFFSET] == ID_SFP) { - hikp_show_sfp_info(data, size); + hikp_show_sfp_info(data); } else if (data[SFF_ID_OFFSET] == ID_QSFP || data[SFF_ID_OFFSET] == ID_QSFP_PLUS || data[SFF_ID_OFFSET] == ID_QSFP28) { - hikp_show_qsfp_info(data, size); + hikp_show_qsfp_info(data); } else if (data[SFF_ID_OFFSET] == ID_QSFP_DD || data[SFF_ID_OFFSET] == ID_SFP_DD || data[SFF_ID_OFFSET] == ID_QSFP_P_CMIS || data[SFF_ID_OFFSET] == ID_SFP_DD_CMIS || data[SFF_ID_OFFSET] == ID_SFP_P_CMIS) { - hikp_show_cmis_info(data, size); + hikp_show_cmis_info(data); } else { /* unknown type just dump hex data */ hikp_xsfp_dump_hex(data, size); @@ -702,6 +702,8 @@ ERR_OUT: static int hikp_xsfp_show_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i [-d]"); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -729,6 +731,9 @@ static int hikp_xsfp_get_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_xsfp_dump_raw_data(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_xsfp_dump.dump_param |= XSFP_RAW_DATA_BIT; return 0; diff --git a/net/nic/nic_ncsi/hikp_nic_ncsi.c b/net/nic/nic_ncsi/hikp_nic_ncsi.c index 84f6337..955e456 100644 --- a/net/nic/nic_ncsi/hikp_nic_ncsi.c +++ b/net/nic/nic_ncsi/hikp_nic_ncsi.c @@ -89,6 +89,8 @@ static int nic_ncsi_cmd_get_port_info(struct major_cmd_ctrl *self, const char *a static int nic_ncsi_cmd_show_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c index 4efaadc..c301dad 100644 --- a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c +++ b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c @@ -84,6 +84,8 @@ void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_notify_pkt_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_ppp/hikp_nic_ppp.c b/net/nic/nic_ppp/hikp_nic_ppp.c index 421d601..d5cf61f 100644 --- a/net/nic/nic_ppp/hikp_nic_ppp.c +++ b/net/nic/nic_ppp/hikp_nic_ppp.c @@ -66,6 +66,8 @@ void hikp_nic_ppp_set_cmd_param(int feature_idx) static int hikp_nic_ppp_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -788,6 +790,8 @@ static int hikp_nic_query_ppp_by_entryid(struct hikp_cmd_header *req_header, const struct ppp_feature_cmd *ppp_cmd; struct nic_ppp_req_para req_data = {0}; + HIKP_SET_USED(len); + req_data.bdf = *bdf; ppp_cmd = &g_ppp_feature_cmd[g_ppp_param.feature_idx]; if (strcmp(ppp_cmd->feature_name, NIC_PPP_MAC_TBL_NAME) == 0) diff --git a/net/nic/nic_qos/hikp_nic_qos.c b/net/nic/nic_qos/hikp_nic_qos.c index dc6f63e..6435f7c 100644 --- a/net/nic/nic_qos/hikp_nic_qos.c +++ b/net/nic/nic_qos/hikp_nic_qos.c @@ -45,6 +45,8 @@ void hikp_nic_qos_set_cmd_direction(enum nic_pfc_dir dir) static int hikp_nic_qos_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_queue/hikp_nic_queue.c b/net/nic/nic_queue/hikp_nic_queue.c index 5bb4335..dae634f 100644 --- a/net/nic/nic_queue/hikp_nic_queue.c +++ b/net/nic/nic_queue/hikp_nic_queue.c @@ -42,6 +42,8 @@ void hikp_nic_queue_cmd_set_param(int feature_idx, int qid, enum nic_queue_dir d static int hikp_nic_queue_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_rss/hikp_nic_rss.c b/net/nic/nic_rss/hikp_nic_rss.c index a7448e4..76cab8a 100644 --- a/net/nic/nic_rss/hikp_nic_rss.c +++ b/net/nic/nic_rss/hikp_nic_rss.c @@ -139,6 +139,8 @@ void hikp_nic_rss_cmd_set_feature_idx(int feature_idx) static int hikp_nic_rss_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/nic/nic_torus/hikp_nic_torus.c b/net/nic/nic_torus/hikp_nic_torus.c index d5e22b1..7ad5211 100644 --- a/net/nic/nic_torus/hikp_nic_torus.c +++ b/net/nic/nic_torus/hikp_nic_torus.c @@ -148,6 +148,8 @@ void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_torus_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); diff --git a/net/roce/roce_bond/hikp_roce_bond.c b/net/roce/roce_bond/hikp_roce_bond.c index 5256804..244f29c 100644 --- a/net/roce/roce_bond/hikp_roce_bond.c +++ b/net/roce/roce_bond/hikp_roce_bond.c @@ -23,6 +23,8 @@ int hikp_roce_set_bond_bdf(char *nic_name) static int hikp_roce_bond_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"); @@ -51,6 +53,8 @@ static int hikp_roce_bond_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data.bdf = g_roce_bond_param.target.bdf; req_data.block_id = block_id; diff --git a/net/roce/roce_caep/hikp_roce_caep.c b/net/roce/roce_caep/hikp_roce_caep.c index 95795d1..290aa18 100644 --- a/net/roce/roce_caep/hikp_roce_caep.c +++ b/net/roce/roce_caep/hikp_roce_caep.c @@ -28,6 +28,8 @@ void hikp_roce_set_caep_mode(uint32_t mode) static int hikp_roce_caep_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"); @@ -59,6 +61,8 @@ static int hikp_roce_caep_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data_ext.origin_param.bdf = g_roce_caep_param_t.target.bdf; req_data_ext.block_id = block_id; @@ -124,6 +128,9 @@ void hikp_roce_caep_execute(struct major_cmd_ctrl *self) static int hikp_roce_caep_ext_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_caep_param_t.sub_cmd = CAEP_EXT; return 0; diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c index ca42dfa..8b0d93a 100644 --- a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c +++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c @@ -24,6 +24,8 @@ int hikp_roce_set_global_cfg_bdf(char *nic_name) static int hikp_roce_global_cfg_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"); @@ -54,6 +56,8 @@ static int hikp_roce_global_cfg_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data.bdf = g_roce_global_cfg_param.target.bdf; req_data.block_id = block_id; @@ -81,7 +85,7 @@ void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self) ROCE_GLB_TDP_M, ROCE_GLB_NICL, }; - int i; + size_t i; for (i = 0; i < HIKP_ARRAY_SIZE(sub_cmds); i++) { g_roce_global_cfg_param.sub_cmd = sub_cmds[i]; diff --git a/net/roce/roce_gmv/hikp_roce_gmv.c b/net/roce/roce_gmv/hikp_roce_gmv.c index 5f96451..92bead1 100644 --- a/net/roce/roce_gmv/hikp_roce_gmv.c +++ b/net/roce/roce_gmv/hikp_roce_gmv.c @@ -29,6 +29,8 @@ void hikp_roce_set_gmv_index(uint32_t gmv_index) static int hikp_roce_gmv_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"); @@ -103,6 +105,8 @@ void hikp_roce_gmv_execute(struct major_cmd_ctrl *self) uint32_t reg_num; int ret; + HIKP_SET_USED(self); + req_data.bdf = g_roce_gmv_param.target.bdf; req_data.gmv_index = g_roce_gmv_param.gmv_index; hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_GMV_CMD, GMV_SHOW); diff --git a/net/roce/roce_mdb/hikp_roce_mdb.c b/net/roce/roce_mdb/hikp_roce_mdb.c index e0a7cc5..c0d028f 100644 --- a/net/roce/roce_mdb/hikp_roce_mdb.c +++ b/net/roce/roce_mdb/hikp_roce_mdb.c @@ -29,6 +29,8 @@ void hikp_roce_set_mdb_mode(uint8_t mode) static int hikp_roce_mdb_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"); @@ -54,6 +56,9 @@ static int hikp_roce_mdb_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_mdb_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_mdb_param.flag |= ROCE_MDB_CMD_CLEAR; return 0; @@ -182,6 +187,9 @@ void hikp_roce_mdb_execute(struct major_cmd_ctrl *self) static int hikp_roce_mdb_ext_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_mdb_param.flag |= ROCE_MDB_CMD_EXT; return 0; diff --git a/net/roce/roce_pkt/hikp_roce_pkt.c b/net/roce/roce_pkt/hikp_roce_pkt.c index 5a6b268..1538788 100644 --- a/net/roce/roce_pkt/hikp_roce_pkt.c +++ b/net/roce/roce_pkt/hikp_roce_pkt.c @@ -23,6 +23,8 @@ int hikp_roce_set_pkt_bdf(char *nic_name) static int hikp_roce_pkt_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"); @@ -47,6 +49,9 @@ static int hikp_roce_pkt_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_pkt_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_pkt_param_t.reset_flag = 1; return 0; } diff --git a/net/roce/roce_qmm/hikp_roce_qmm.c b/net/roce/roce_qmm/hikp_roce_qmm.c index 30caa5a..af327c2 100644 --- a/net/roce/roce_qmm/hikp_roce_qmm.c +++ b/net/roce/roce_qmm/hikp_roce_qmm.c @@ -34,6 +34,8 @@ void hikp_roce_set_qmm_bankid(uint32_t bank_id) static int hikp_roce_qmm_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"); @@ -208,7 +210,8 @@ static int hikp_roce_qmm_get_data(struct hikp_cmd_ret **cmd_ret, struct roce_qmm_req_para_ext req_data_ext; struct hikp_cmd_header req_header = { 0 }; uint32_t req_size; - int ret, i; + size_t i; + int ret; if (reg_name) { for (i = 0; i < HIKP_ARRAY_SIZE(g_qmm_reg_name_info_table); i++) { @@ -277,7 +280,7 @@ void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) {QMM_SHOW_TOP, QMM_SHOW_TOP_EXT, "TOP"}, }; - for (int i = 0; i < HIKP_ARRAY_SIZE(sub_cmd_info_table); i++) { + for (size_t i = 0; i < HIKP_ARRAY_SIZE(sub_cmd_info_table); i++) { g_roce_qmm_param.sub_name = sub_cmd_info_table[i].sub_name; if (g_roce_qmm_param.ext_flag) { g_roce_qmm_param.sub_cmd = sub_cmd_info_table[i].sub_ext_cmd; @@ -298,6 +301,9 @@ void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) static int hikp_roce_qmm_ext_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_qmm_param.ext_flag = true; return 0; diff --git a/net/roce/roce_rst/hikp_roce_rst.c b/net/roce/roce_rst/hikp_roce_rst.c index cfccc47..c49074b 100644 --- a/net/roce/roce_rst/hikp_roce_rst.c +++ b/net/roce/roce_rst/hikp_roce_rst.c @@ -23,6 +23,8 @@ int hikp_roce_set_rst_bdf(char *nic_name) static int hikp_roce_rst_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"); @@ -51,6 +53,8 @@ static int hikp_roce_rst_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data.bdf = g_roce_rst_param.target.bdf; req_data.block_id = block_id; diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c index c660799..67a2a1e 100644 --- a/net/roce/roce_scc/hikp_roce_scc.c +++ b/net/roce/roce_scc/hikp_roce_scc.c @@ -36,6 +36,8 @@ void hikp_roce_set_scc_submodule(uint32_t module) static int hikp_roce_scc_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"); @@ -82,6 +84,9 @@ static int hikp_roce_scc_module_select(struct major_cmd_ctrl *self, const char * static int hikp_roce_scc_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_scc_param_t.reset_flag = 1; return 0; diff --git a/net/roce/roce_timer/hikp_roce_timer.c b/net/roce/roce_timer/hikp_roce_timer.c index a6af959..927d8a6 100644 --- a/net/roce/roce_timer/hikp_roce_timer.c +++ b/net/roce/roce_timer/hikp_roce_timer.c @@ -23,6 +23,8 @@ int hikp_roce_set_timer_bdf(char *nic_name) static int hikp_roce_timer_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"); @@ -46,6 +48,9 @@ static int hikp_roce_timer_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_timer_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_timer_param.flag = ROCE_TIMER_CMD_CLEAR; return 0; } @@ -120,6 +125,8 @@ static int hikp_roce_timer_show_qpc(struct major_cmd_ctrl *self) struct hikp_cmd_ret *cmd_ret = NULL; int ret; + HIKP_SET_USED(self); + req_data.bdf = g_roce_timer_param.target.bdf; if (g_roce_timer_param.flag) hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_TIMER_CMD, TIMER_QPC_CLEAR); @@ -153,6 +160,8 @@ static int hikp_roce_timer_show_cqc(struct major_cmd_ctrl *self) struct hikp_cmd_ret *cmd_ret = NULL; int ret; + HIKP_SET_USED(self); + req_data.bdf = g_roce_timer_param.target.bdf; if (g_roce_timer_param.flag) hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_TIMER_CMD, TIMER_CQC_CLEAR); @@ -204,7 +213,7 @@ void hikp_roce_timer_execute(struct major_cmd_ctrl *self) hikp_roce_timer_show_cqc, hikp_roce_timer_show_qpc }; const char *function[] = {"show cqc", "show qpc"}; - int i = 0; + size_t i = 0; int ret; if (g_roce_timer_param.flag) { diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c index 9b1ddb1..67dfb8e 100644 --- a/net/roce/roce_trp/hikp_roce_trp.c +++ b/net/roce/roce_trp/hikp_roce_trp.c @@ -39,6 +39,8 @@ void hikp_roce_set_trp_submodule(uint32_t module) static int hikp_roce_trp_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"); diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c index e07e882..5fe2104 100644 --- a/net/roce/roce_tsp/hikp_roce_tsp.c +++ b/net/roce/roce_tsp/hikp_roce_tsp.c @@ -38,6 +38,8 @@ void hikp_roce_set_tsp_submodule(uint32_t module) static int hikp_roce_tsp_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"); @@ -118,6 +120,9 @@ static int hikp_roce_tsp_bank_check(void) static int hikp_roce_tsp_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_tsp_param_t.reset_flag = 1; return 0; diff --git a/net/roh/hikp_roh_mac.c b/net/roh/hikp_roh_mac.c index aa13f92..e16a3db 100644 --- a/net/roh/hikp_roh_mac.c +++ b/net/roh/hikp_roh_mac.c @@ -18,6 +18,8 @@ static struct roh_mac_param g_roh_mac_param = { 0 }; static int hikp_roh_mac_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s \n"); printf("\n %s\n", self->cmd_ptr->help_info); @@ -96,7 +98,7 @@ int hikp_roh_get_mac_type(struct major_cmd_ctrl *self, struct bdf_t bdf) return is_roh; } -static void hikp_roh_show_mac_type(struct major_cmd_ctrl *self, int mac_type) +static void hikp_roh_show_mac_type(int mac_type) { if (mac_type) printf("MAC_TYPE: ROH\n"); @@ -382,7 +384,7 @@ static void hikp_roh_mac_execute_entry(struct major_cmd_ctrl *self) HIKP_ERROR_PRINT("Failed get current mac type\n"); return; } - hikp_roh_show_mac_type(self, mac_type); + hikp_roh_show_mac_type(mac_type); break; case (CMD_SHOW_CAM_FLAG): if (hikp_roh_is_roh(self) > 0) diff --git a/net/roh/hikp_roh_show_bp.c b/net/roh/hikp_roh_show_bp.c index 0b53eda..edc1dc6 100644 --- a/net/roh/hikp_roh_show_bp.c +++ b/net/roh/hikp_roh_show_bp.c @@ -17,6 +17,8 @@ static struct cmd_roh_show_bp_param g_roh_show_bp_param = { 0 }; static int hikp_roh_show_bp_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s\n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -115,6 +117,9 @@ static void hikp_roh_show_bp_execute(struct major_cmd_ctrl *self) static int hikp_roh_show_bp_parse(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roh_show_bp_param.flag |= ROH_CMD_SHOW_BP; return 0; } diff --git a/net/roh/hikp_roh_show_mib.c b/net/roh/hikp_roh_show_mib.c index 5f03355..96dd688 100644 --- a/net/roh/hikp_roh_show_mib.c +++ b/net/roh/hikp_roh_show_mib.c @@ -151,6 +151,8 @@ static char g_roh_mac_mib_name[MIB_EVENT_COUNT][ROH_NAME_MAX] = { static int hikp_roh_show_mib_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s\n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -253,6 +255,9 @@ static void hikp_roh_show_mib_execute(struct major_cmd_ctrl *self) static int hikp_roh_show_mib_parse(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + roh_show_mib_param.flag |= ROH_CMD_SHOW_MIB; return 0; } diff --git a/net/ub/ub_bp/hikp_ub_bp.c b/net/ub/ub_bp/hikp_ub_bp.c index 179aa22..2dfe69c 100644 --- a/net/ub/ub_bp/hikp_ub_bp.c +++ b/net/ub/ub_bp/hikp_ub_bp.c @@ -17,6 +17,8 @@ static struct ub_bp_param g_ub_bp_param = { 0 }; static int hikp_ub_bp_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"); diff --git a/net/ub/ub_crd/hikp_ub_crd.c b/net/ub/ub_crd/hikp_ub_crd.c index 6d2ba21..678bc84 100644 --- a/net/ub/ub_crd/hikp_ub_crd.c +++ b/net/ub/ub_crd/hikp_ub_crd.c @@ -17,6 +17,8 @@ static struct ub_crd_param g_ub_crd_param = { 0 }; static int hikp_ub_crd_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"); diff --git a/net/ub/ub_dfx/hikp_ub_dfx.c b/net/ub/ub_dfx/hikp_ub_dfx.c index dd3a713..8a3e293 100644 --- a/net/ub/ub_dfx/hikp_ub_dfx.c +++ b/net/ub/ub_dfx/hikp_ub_dfx.c @@ -44,6 +44,8 @@ static void dfx_help_info(const struct major_cmd_ctrl *self) static int hikp_ub_dfx_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + dfx_help_info(self); return 0; } diff --git a/net/ub/ub_info/hikp_ub_info.c b/net/ub/ub_info/hikp_ub_info.c index d113f7c..ef58ff5 100644 --- a/net/ub/ub_info/hikp_ub_info.c +++ b/net/ub/ub_info/hikp_ub_info.c @@ -17,6 +17,8 @@ static struct ub_info_param g_ub_info_param = { 0 }; static int hikp_ub_info_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"); diff --git a/net/ub/ub_link/hikp_ub_link.c b/net/ub/ub_link/hikp_ub_link.c index 1cc1879..801e56e 100644 --- a/net/ub/ub_link/hikp_ub_link.c +++ b/net/ub/ub_link/hikp_ub_link.c @@ -17,6 +17,8 @@ static struct ub_link_param g_ub_link_param = { 0 }; static int hikp_ub_link_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"); diff --git a/net/ub/ub_ppp/hikp_unic_ppp.c b/net/ub/ub_ppp/hikp_unic_ppp.c index 01c1624..4c48e70 100644 --- a/net/ub/ub_ppp/hikp_unic_ppp.c +++ b/net/ub/ub_ppp/hikp_unic_ppp.c @@ -39,6 +39,8 @@ static const struct unic_ppp_feature_cmd g_unic_ppp_feature_cmd[] = { static int hikp_unic_ppp_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -209,8 +211,7 @@ static int hikp_unic_ppp_alloc_guid_tbl_entry(const struct hikp_unic_ppp_hw_reso } static union unic_ppp_feature_info* -hikp_unic_ppp_data_alloc(const struct unic_ppp_feature_cmd *unic_ppp_cmd, - const struct hikp_unic_ppp_hw_resources *hw_res) +hikp_unic_ppp_data_alloc(const struct hikp_unic_ppp_hw_resources *hw_res) { union unic_ppp_feature_info *unic_ppp_data; int ret = -1; @@ -461,7 +462,7 @@ static void hikp_unic_ppp_cmd_execute(struct major_cmd_ctrl *self) } unic_ppp_cmd = &g_unic_ppp_feature_cmd[g_unic_ppp_param.feature_idx]; - unic_ppp_data = hikp_unic_ppp_data_alloc(unic_ppp_cmd, &g_unic_ppp_hw_res); + unic_ppp_data = hikp_unic_ppp_data_alloc(&g_unic_ppp_hw_res); if (unic_ppp_data == NULL) { snprintf(self->err_str, sizeof(self->err_str), "failed to allocate unic_ppp_data memory!"); diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c index 0ce2e5d..4172637 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.c +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c @@ -446,7 +446,7 @@ static void pcie_dumpreg_write_value_to_file(const char *reg_name, uint32_t val) int ret; ret = snprintf(str, sizeof(str), " %-40s : 0x%x\n", reg_name, val); - if (ret < 0 || ret >= sizeof(str)) { + if (ret < 0 || ret >= MAX_STR_LEN) { Err("pcie dumpreg write info to logfile failed.\n"); } else { wr_ret = write(g_pcie_dumpreg_fd, str, strlen(str)); diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c index 6d1c674..8ec0404 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c @@ -29,6 +29,8 @@ struct tool_pcie_cmd g_dumpreg_cmd = { static int pcie_dumpreg_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(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first\n"); @@ -48,6 +50,8 @@ static int pcie_port_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set port id err %d.\n", ret); @@ -63,6 +67,8 @@ static int dump_level_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val = 0; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret || val < DUMP_GLOBAL_LEVEL || val > DUMP_PORT_LEVEL) { printf("info set id err, ret = %d, val = %u\n", ret, val); @@ -75,6 +81,9 @@ static int dump_level_set(struct major_cmd_ctrl *self, const char *argv) static int pcie_dumpreg_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_dumpreg_cmd.cmd_type = DUMPREG_DUMP; return 0; diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c index aeab241..f3bd46f 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c @@ -26,6 +26,8 @@ struct tool_pcie_cmd g_info_cmd = { static int pcie_info_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(" %s, %-25s %s\n", "-i", "--interface", @@ -42,6 +44,9 @@ static int pcie_info_help(struct major_cmd_ctrl *self, const char *argv) static int pcie_distribution_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_info_cmd.cmd_type = INFO_DISTRIBUTION; return 0; @@ -49,6 +54,9 @@ static int pcie_distribution_show(struct major_cmd_ctrl *self, const char *argv) static int pcie_err_state_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_info_cmd.cmd_type = INFO_ERR_STATE_SHOW; return 0; @@ -56,6 +64,9 @@ static int pcie_err_state_show(struct major_cmd_ctrl *self, const char *argv) static int pcie_err_state_clear(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_info_cmd.cmd_type = INFO_ERR_STATE_CLEAR; return 0; @@ -66,6 +77,8 @@ static int pcie_port_chip_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set id err %d\n", ret); diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c index 6e54516..a884604 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c @@ -32,6 +32,8 @@ struct tool_pcie_cmd g_regread_cmd = { static int pcie_reg_read_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(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first\n"); @@ -50,6 +52,8 @@ static int pcie_port_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set port id err %d.\n", ret); @@ -65,6 +69,8 @@ static int read_module_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = pcie_read_name2module_id(argv, &val); if (ret) { printf("undefined module \"%s\".\n", argv); @@ -80,6 +86,8 @@ static int read_offset_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set offset err %d.\n", ret); @@ -92,6 +100,9 @@ static int read_offset_set(struct major_cmd_ctrl *self, const char *argv) static int pcie_reg_read_exe(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_regread_cmd.cmd_type = REGRD_READ; return 0; diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c index 8ceb85a..7b0efde 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c @@ -27,6 +27,8 @@ struct tool_pcie_cmd g_trace_cmd = { static int pcie_trace_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(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first\n"); @@ -45,6 +47,9 @@ static int pcie_trace_help(struct major_cmd_ctrl *self, const char *argv) static int pcie_trace_clear(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_CLEAR; return 0; @@ -53,6 +58,9 @@ static int pcie_trace_clear(struct major_cmd_ctrl *self, const char *argv) static int pcie_trace_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_SHOW; return 0; @@ -60,6 +68,9 @@ static int pcie_trace_show(struct major_cmd_ctrl *self, const char *argv) static int pcie_pm_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_PM; return 0; @@ -70,6 +81,8 @@ static int pcie_trace_mode_set(struct major_cmd_ctrl *self, const char *argv) int ret; uint32_t val = 0; + HIKP_SET_USED(self); + g_trace_cmd.cmd_type = TRACE_MODE; ret = string_toui(argv, &val); if (ret || val > 1) { @@ -83,6 +96,9 @@ static int pcie_trace_mode_set(struct major_cmd_ctrl *self, const char *argv) static int pcie_link_information_get(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_INFO; return 0; } @@ -92,6 +108,8 @@ static int pcie_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("trace set port id err %d\n", ret); diff --git a/sas/sas_func/sas_analy_queue.c b/sas/sas_func/sas_analy_queue.c index f1d2e7e..3411f67 100644 --- a/sas/sas_func/sas_analy_queue.c +++ b/sas/sas_func/sas_analy_queue.c @@ -46,7 +46,7 @@ static int sas_get_res(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); diff --git a/sas/sas_func/sas_dump_reg.c b/sas/sas_func/sas_dump_reg.c index 39fa5ed..4269822 100644 --- a/sas/sas_func/sas_dump_reg.c +++ b/sas/sas_func/sas_dump_reg.c @@ -38,14 +38,14 @@ static int sas_get_reg(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return -1; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); return 0; } -static void sas_print_reg(uint32_t cmd_type, const uint32_t *reg_save, uint32_t reg_num) +static void sas_print_reg(const uint32_t *reg_save, uint32_t reg_num) { uint32_t i; @@ -71,7 +71,7 @@ int sas_reg_dump(struct tool_sas_cmd *cmd) if (ret) return ret; - sas_print_reg(cmd->sas_cmd_type, reg_save, reg_num); + sas_print_reg(reg_save, reg_num); return 0; } diff --git a/sas/sas_func/sas_read_dev.c b/sas/sas_func/sas_read_dev.c index b5d7e18..dec2935 100644 --- a/sas/sas_func/sas_read_dev.c +++ b/sas/sas_func/sas_read_dev.c @@ -22,7 +22,7 @@ static int sas_get_dev(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint32_t *reg_num) { - int i; + uint32_t i; struct hikp_cmd_header req_header; struct hikp_cmd_ret *cmd_ret; struct sas_dev_req_para req_data = { 0 }; @@ -46,7 +46,7 @@ static int sas_get_dev(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return 0; } -static void print_dev_link(const uint32_t *reg_save, uint32_t reg_num) +static void print_dev_link(const uint32_t *reg_save) { uint32_t i; uint32_t index, index1; @@ -84,7 +84,7 @@ static void sas_print_dev(const uint32_t *reg_save, uint32_t reg_num, uint32_t c } switch (cmd_type) { case DEV_LINK: - print_dev_link(reg_save, reg_num); + print_dev_link(reg_save); break; default: printf("cmd_type is error\n"); diff --git a/sas/sas_func/sas_read_dqe.c b/sas/sas_func/sas_read_dqe.c index dac2546..ae4ef68 100644 --- a/sas/sas_func/sas_read_dqe.c +++ b/sas/sas_func/sas_read_dqe.c @@ -39,14 +39,14 @@ static int sas_get_dqe(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); return 0; } -static void print_dqe_info(const void *reg_save, uint32_t reg_num) +static void print_dqe_info(const void *reg_save) { volatile struct hisi_sas_dq_info *dqe = (volatile struct hisi_sas_dq_info *)(reg_save); @@ -109,6 +109,6 @@ int sas_dqe(const struct tool_sas_cmd *cmd) printf("SAS dqe is failed\n"); return -EINVAL; } - print_dqe_info(reg_save, reg_num); + print_dqe_info(reg_save); return 0; } diff --git a/sas/sas_func/sas_read_errcode.c b/sas/sas_func/sas_read_errcode.c index d451a98..8263550 100644 --- a/sas/sas_func/sas_read_errcode.c +++ b/sas/sas_func/sas_read_errcode.c @@ -37,7 +37,7 @@ static int sas_get_errcode(const struct tool_sas_cmd *cmd, uint32_t *reg_save, u return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); diff --git a/sas/user_cmd/cmd_code/sas_cmd_anacq.c b/sas/user_cmd/cmd_code/sas_cmd_anacq.c index 6e39dae..4d9a750 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_anacq.c +++ b/sas/user_cmd/cmd_code/sas_cmd_anacq.c @@ -19,6 +19,8 @@ static int sas_anacq_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(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); @@ -34,11 +36,17 @@ static int sas_anacq_help(struct major_cmd_ctrl *self, const char *argv) static int sas_anacq_prt(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANACQ_PRT); } static int sas_anacq_num(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANACQ_NUM); } diff --git a/sas/user_cmd/cmd_code/sas_cmd_anadq.c b/sas/user_cmd/cmd_code/sas_cmd_anadq.c index e1b68b6..bff2c71 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_anadq.c +++ b/sas/user_cmd/cmd_code/sas_cmd_anadq.c @@ -19,6 +19,8 @@ static int sas_anadq_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(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); @@ -34,11 +36,17 @@ static int sas_anadq_help(struct major_cmd_ctrl *self, const char *argv) static int sas_anadq_prt(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANADQ_PRT); } static int sas_anadq_num(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANADQ_NUM); } diff --git a/sas/user_cmd/cmd_code/sas_cmd_common.c b/sas/user_cmd/cmd_code/sas_cmd_common.c index 7d4ffbb..1dafc0a 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_common.c +++ b/sas/user_cmd/cmd_code/sas_cmd_common.c @@ -23,7 +23,7 @@ static struct tool_sas_cmd g_sas_cmd = { .dqe_id = (uint32_t)(-1), }; -int sas_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t *id) +static int sas_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t *id) { int ret; uint32_t val = 0; diff --git a/sas/user_cmd/cmd_code/sas_cmd_dev.c b/sas/user_cmd/cmd_code/sas_cmd_dev.c index 6a5eae0..879e764 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_dev.c +++ b/sas/user_cmd/cmd_code/sas_cmd_dev.c @@ -19,6 +19,8 @@ static int sas_dev_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(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); @@ -33,6 +35,9 @@ static int sas_dev_help(struct major_cmd_ctrl *self, const char *argv) static int sas_dev_link(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(DEV_LINK); } diff --git a/sas/user_cmd/cmd_code/sas_cmd_dqe.c b/sas/user_cmd/cmd_code/sas_cmd_dqe.c index ba34047..b914f54 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_dqe.c +++ b/sas/user_cmd/cmd_code/sas_cmd_dqe.c @@ -19,6 +19,8 @@ static int sas_dqe_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(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); @@ -57,7 +59,7 @@ static int sas_set_queue_id(struct major_cmd_ctrl *self, const char *argv) static int sas_dqe_excute_funs_call(uint32_t cmd_type) { - if ((cmd_type != SAS_UNKNOW_CMD) && (sas_get_que_id() != (uint32_t)(-1))) + if ((cmd_type != SAS_UNKNOW_CMD) && (sas_get_que_id() != (-1))) return sas_dqe(sas_get_cmd_p()); return -EINVAL; diff --git a/sas/user_cmd/cmd_code/sas_cmd_dump.c b/sas/user_cmd/cmd_code/sas_cmd_dump.c index e7dedf0..db7d2c8 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_dump.c +++ b/sas/user_cmd/cmd_code/sas_cmd_dump.c @@ -19,6 +19,8 @@ static int sas_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(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); @@ -35,6 +37,9 @@ static int sas_dump_help(struct major_cmd_ctrl *self, const char *argv) static int sas_dump_global(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + (void)sas_set_cmd_type(DUMP_GLOBAL); return 0; } @@ -56,6 +61,9 @@ static int sas_dump_phyx(struct major_cmd_ctrl *self, char const *argv) static int sas_dump_axi(struct major_cmd_ctrl *self, char const *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + (void)sas_set_cmd_type(DUMP_AXI); return 0; } diff --git a/sas/user_cmd/cmd_code/sas_cmd_errcode.c b/sas/user_cmd/cmd_code/sas_cmd_errcode.c index eb3c5e6..ebe7d1c 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_errcode.c +++ b/sas/user_cmd/cmd_code/sas_cmd_errcode.c @@ -18,6 +18,8 @@ static int sas_errcode_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(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); diff --git a/sata/sata_func/sata_dump_reg.c b/sata/sata_func/sata_dump_reg.c index d63a14b..d9911d6 100644 --- a/sata/sata_func/sata_dump_reg.c +++ b/sata/sata_func/sata_dump_reg.c @@ -46,7 +46,7 @@ static int sata_get_reg(const struct tool_sata_cmd *cmd, uint32_t *reg_save, uin return 0; } -static void sata_print_reg(uint32_t cmd_type, const uint32_t *reg_save, uint32_t reg_num) +static void sata_print_reg(const uint32_t *reg_save, uint32_t reg_num) { uint32_t i; @@ -72,7 +72,7 @@ int sata_reg_dump(struct tool_sata_cmd *cmd) if (ret) return ret; - sata_print_reg(cmd->sata_cmd_type, sata_reg_save, sata_reg_num); + sata_print_reg(sata_reg_save, sata_reg_num); return 0; } diff --git a/sata/user_cmd/cmd_code/sata_cmd_dump.c b/sata/user_cmd/cmd_code/sata_cmd_dump.c index d38ff1c..2b74712 100644 --- a/sata/user_cmd/cmd_code/sata_cmd_dump.c +++ b/sata/user_cmd/cmd_code/sata_cmd_dump.c @@ -26,6 +26,8 @@ struct tool_sata_cmd g_sata_dump_cmd = { static int sata_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(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); @@ -56,16 +58,25 @@ static int sata_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t * static int sata_set_chip_id(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sata_set_id(self, argv, &g_sata_dump_cmd.chip_id); } static int sata_set_die_id(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sata_set_id(self, argv, &g_sata_dump_cmd.die_id); } static int sata_dump_global(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_sata_dump_cmd.sata_cmd_type = DUMP_GLOBAL; return 0; } diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c index 2367382..01776df 100644 --- a/serdes/hikp_serdes.c +++ b/serdes/hikp_serdes.c @@ -31,6 +31,8 @@ static void hikp_serdes_dump_print(struct cmd_serdes_param *cmd); static int cmd_serdes_maininfo_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s -n [-k]"); printf("\n %s, e.g. hikptool serdes_info -i 0 -s m3d0 -n 4 -k\n", @@ -119,6 +121,9 @@ static int cmd_serdes_lane_num(struct major_cmd_ctrl *self, const char *argv) static int cmd_serdes_key_info_pro(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_serdes_param.sub_cmd = 1; return 0; } @@ -379,6 +384,8 @@ static void cmd_serdes_maininfo_init(void) static int cmd_serdes_dump_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-c -i -s "); printf("\n %s, e.g. hikptool serdes_dump -c cs -i 0 -s m0d0\n", diff --git a/socip/hikp_socip_dumpreg.c b/socip/hikp_socip_dumpreg.c index a3a20cb..b3b3ed7 100644 --- a/socip/hikp_socip_dumpreg.c +++ b/socip/hikp_socip_dumpreg.c @@ -39,6 +39,8 @@ static struct dump_reg_param_t g_dump_reg_param[SOCIP_DUMP_REG_PARAM_NUM] = {0}; static int cmd_socip_dump_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-c -d -m -i "); printf("\n %s\n", self->cmd_ptr->help_info); diff --git a/tool_lib/op_logs.c b/tool_lib/op_logs.c index 6f28ecd..c1c7d02 100644 --- a/tool_lib/op_logs.c +++ b/tool_lib/op_logs.c @@ -246,7 +246,7 @@ int op_log_initialise(const char *log_dir) memset(log_path, '\0', OP_LOG_FILE_PATH_MAXLEN); memset(g_op_log, '\0', OP_LOG_FILE_PATH_MAXLEN); ret = snprintf(log_path, sizeof(log_path), "%s", log_dir); - if (ret < 0 || ret >= sizeof(log_path)) + if (ret < 0 || (size_t)ret >= sizeof(log_path)) return -EINVAL; if (!is_dir_exist(log_path)) { @@ -275,22 +275,17 @@ int op_log_initialise(const char *log_dir) void op_log_record_input(const int argc, const char **argv) { char input_str[OP_LOG_FILE_W_MAXSIZE + 1] = {0}; - struct op_log_print_t log_info[] = { - {"%s", g_cmd_exec_time}, - {"[%s]", input_str}, - }; - size_t i, arr_size; int offset = 0; char *arg; int ret; memset(g_input_buf, 0, sizeof(g_input_buf)); - if (argv == NULL || argc == 0) + if (argv == NULL || argc <= 0) return; arg = input_str; - for (i = 0; i < argc; i++) { + for (int i = 0; i < argc; i++) { ret = snprintf(arg, (sizeof(input_str) - (arg - input_str)), "%s ", argv[i]); if (ret < 0 || ret >= (int)(sizeof(input_str) - (arg - input_str))) return; @@ -299,15 +294,18 @@ void op_log_record_input(const int argc, const char **argv) } input_str[strlen(input_str) - 1] = 0; - arr_size = HIKP_ARRAY_SIZE(log_info); - for (i = 0; i < arr_size; i++) { - ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset), - log_info[i].format, log_info[i].str); - if (ret < 0 || ret >= (OP_LOG_FILE_W_MAXSIZE + 1 - offset)) - return; - - offset += ret; + ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset), + "%s", g_cmd_exec_time); + if (ret < 0 || ret >= (OP_LOG_FILE_W_MAXSIZE + 1 - offset)) { + printf("snprintf exec time failed, ret 0x%x\n", ret); + return; } + + offset += ret; + ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset), + "[%s]", input_str); + if (ret < 0 || ret >= (OP_LOG_FILE_W_MAXSIZE + 1 - offset)) + printf("snprintf exec cmd failed, ret 0x%x\n", ret); } void op_log_record_result(int ret, const char *tool_name, const char *log_dir) @@ -393,7 +391,7 @@ static int signal_fcntl(const char *name, uint32_t operation, int *fd) return uda_fcntl(lock_file, operation, fd); } -void signal_op_log_write(int signal_code) +static void signal_op_log_write(int signal_code) { char log_str[] = "[00:00:00] [KILLED<00>].\r\n"; int op_log_fd; diff --git a/tool_lib/tool_lib.c b/tool_lib/tool_lib.c index 62f5fbb..3dc5dad 100644 --- a/tool_lib/tool_lib.c +++ b/tool_lib/tool_lib.c @@ -245,7 +245,7 @@ int tool_flock(const char *name, uint32_t operation, int *fd, const char *log_di } ret = snprintf(lock_file, sizeof(lock_file), "%s", log_dir); - if (ret < 0 || ret >= sizeof(lock_file)) { + if (ret < 0 || (size_t)ret >= sizeof(lock_file)) { HIKP_ERROR_PRINT("generate flock [%s] folder name failed, errno is %d\n", log_dir, errno); return -errno; diff --git a/tool_lib/tool_lib.h b/tool_lib/tool_lib.h index 3bf7bf8..24b1fbb 100644 --- a/tool_lib/tool_lib.h +++ b/tool_lib/tool_lib.h @@ -90,6 +90,10 @@ struct type_trans { #define HIKP_WARN_PRINT(x, args...) HIKP_LOG_PRINT("[ WARN ] " x, ##args) #define HIKP_INFO_PRINT(x, args...) HIKP_LOG_PRINT("[ INFO ] " x, ##args) #define HIKP_DBG_PRINT(x, args...) HIKP_LOG_PRINT("[ DBG ] " x, ##args) + +/* definition to mark a variable or function parameter as used so + * as to avoid a compiler warning + */ #define HIKP_SET_USED(x) (void)(x) #define MIDR_EL1_PATH "/sys/devices/system/cpu/cpu0/regs/identification/midr_el1" -- Gitee From e1b1c2d1e656859313bce19cf7d49aa52f66151b Mon Sep 17 00:00:00 2001 From: moubingquan Date: Fri, 20 Dec 2024 15:03:30 +0800 Subject: [PATCH 3/9] The query result of pcie_dumpreg does not match the register list. Rectify the problem that the pcie_regdump command dump registers do not match the register table. Signed-off-by: moubingquan --- pcie/func_lib/pcie_func/pcie_reg_dump.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c index 4172637..ad7cc7f 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.c +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c @@ -64,10 +64,8 @@ struct pcie_dumpreg_info g_reg_table_tl[] = { {0, "TL_RX_NONPOST_CNT"}, {0, "TL_RX_CPL_CNT"}, {0, "TL_RX_LOC_TLP_CNT"}, - {0, "TL_RX_ERR_STATUS"}, {0, "TL_CFGSPACE_BDF"}, {0, "TL_TX_UR_CNT"}, - {0, "TL_RX_ERR_STATUS"}, }; struct pcie_dumpreg_info g_reg_table_dl[] = { @@ -126,7 +124,6 @@ struct pcie_dumpreg_info g_reg_table_mac[] = { {0, "MAC_REG_DEBUG_PIPE9"}, {0, "MAC_REG_DEBUG_PIPE10"}, {0, "MAC_REG_DEBUG_PIPE11"}, - {0, "MAC_LEAVE_L0_INFO"}, {0, "DFX_APB_LANE_ERROR_STATUS_0"}, {0, "DFX_APB_LANE_ERROR_STATUS_1"}, {0, "MAC_REG_PHY_RXDATA_TS_REG"}, @@ -255,7 +252,6 @@ struct pcie_dumpreg_info g_reg_table_iob_rx[] = { {0, "DFX_IOB_RX_CNT_RESP_RX"}, {0, "DFX_IOB_RX_CNT_RESP_LOC"}, {0, "DFX_IOB_RX_CNT_RESP_RECV"}, - {0, "IOB_RX_INT_STATUS"}, {0, "DFX_IOB_RX_AMB_WR_CNT_0"}, {0, "DFX_IOB_RX_AMB_WR_CNT_1"}, {0, "DFX_IOB_RX_AMB_RD_CNT_0"}, @@ -369,8 +365,8 @@ struct pcie_dumpreg_info g_reg_table_core_glb[] = { {0, "CORE_INT_FE_RO_2"}, {0, "PORT07_LINK_MODE"}, {0, "PORT815_LINK_MODE"}, - {0, "PCIE_LINK_DOWN_CLR_PORT_EN_REG"}, - {0, "CORE_CLK_FLG_REG"}, + {0, "PCIE_LINK_DOWN_CLR_PORT_EN"}, + {0, "CORE_CLK_FLG"}, }; struct pcie_dumpreg_info g_reg_table_core_tl[] = { -- Gitee From 7b338701a9639b89c421bdff06d4eb666da420b4 Mon Sep 17 00:00:00 2001 From: Jie Hai Date: Tue, 17 Dec 2024 15:29:28 +0800 Subject: [PATCH 4/9] hikptool/hccs: support dump hccs info 1. support dump HCCS topology. e.g. hikptool hccs -g topo 2. support dump HCCS port fixed attributes. e.g. hikptool hccs -g fixed_attr -c \ -d -p 3. support dump HCCS port dfx information. e.g. hikptool hccs -g dfx_info -c \ -d -p Signed-off-by: Huisong Li Signed-off-by: Jie Hai --- CMakeLists.txt | 1 + hccs/hikp_hccs.c | 807 ++++++++++++++++++++++++++++ hccs/hikp_hccs.h | 161 ++++++ libhikptdev/include/hikptdev_plug.h | 1 + 4 files changed, 970 insertions(+) create mode 100644 hccs/hikp_hccs.c create mode 100644 hccs/hikp_hccs.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 56cc932..72f2dab 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -45,6 +45,7 @@ file(GLOB_RECURSE HIKPTOOL_SRC ${CMAKE_CURRENT_SOURCE_DIR}/sata/*.c ${CMAKE_CURRENT_SOURCE_DIR}/serdes/*.c ${CMAKE_CURRENT_SOURCE_DIR}/socip/*.c + ${CMAKE_CURRENT_SOURCE_DIR}/hccs/*.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/hccs/hikp_hccs.c b/hccs/hikp_hccs.c new file mode 100644 index 0000000..5ef4222 --- /dev/null +++ b/hccs/hikp_hccs.c @@ -0,0 +1,807 @@ +/* + * Copyright (c) 2024-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 "tool_cmd.h" +#include "hikpt_rciep.h" +#include "hikp_hccs.h" + +enum hccs_link_fsm { + HCCS_PORT_RESET = 1, + HCCS_PORT_SETUP, + HCCS_PORT_CONFIG, + HCCS_PORT_READY +}; + +const struct { + enum hccs_link_fsm link_fsm; + const char *str; +} link_fsm_map[] = { + {HCCS_PORT_RESET, "reset"}, + {HCCS_PORT_SETUP, "setup"}, + {HCCS_PORT_CONFIG, "config"}, + {HCCS_PORT_READY, "link-up"}, +}; + +static struct hccs_param g_hccs_param = { 0 }; +static struct hikp_plat_hccs_info g_hccs_info = { 0 }; + +static int hikp_hccs_get_plat_topo(struct hccs_param *param, + union hccs_feature_info *info); +static void hikp_hccs_show_topo(union hccs_feature_info *data); +static int hikp_hccs_get_port_attr(struct hccs_param *param, + union hccs_feature_info *info); +static void hikp_hccs_show_port_attr(union hccs_feature_info *feature_info); +static int hikp_hccs_get_port_dfx_info(struct hccs_param *param, + union hccs_feature_info *info); +static void hikp_hccs_show_port_dfx_info(union hccs_feature_info *feature_info); +static int hikp_plat_hccs_hw_info(struct hikp_plat_hccs_info *hccs_info); +static int hikp_hccs_get_die_num(uint8_t chip_id, struct hikp_plat_hccs_info *hccs_info); + +static const struct hikp_hccs_feature_cmd g_hccs_feature_cmd[] = { + {"topo", HCCS_GET_PORT_IDS_ON_DIE, hikp_hccs_get_plat_topo, + hikp_hccs_show_topo, 0}, + {"fixed_attr", HCCS_GET_PORT_FIXED_ATTR, hikp_hccs_get_port_attr, + hikp_hccs_show_port_attr, HCCS_PORT_INFO_MASK}, + {"dfx_info", HCCS_GET_PORT_DFX_INFO, hikp_hccs_get_port_dfx_info, + hikp_hccs_show_port_dfx_info, HCCS_PORT_INFO_MASK}, +}; + +static int hikp_hccs_cmd_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"); + printf(" %s, %-25s %s\n", "-c", "--chip_id=", "target chip"); + printf(" %s, %-25s %s\n", "-d", "--die_id=", "target die"); + printf(" %s, %-25s %s\n", "-p", "--port_id=", "target port"); + printf(" %s\n", + "[-g/--get ]\n" + " topo : get hccs_typo info, no target specified.\n" + " fixed_attr : get fixed attributes for port specified by -c X -d X -p X.\n" + " dfx_info : get dfx info for port specified by -c X -d X -p X.\n"); + return 0; +} + +static int hikp_hccs_cmd_send(struct hikp_cmd_header *req_header, + struct hikp_hccs_req *req_data, + void *buff, size_t buff_len, + struct hikp_hccs_rsp_head *rsp_head) +{ + struct hikp_cmd_ret *cmd_ret; + struct hikp_hccs_rsp *rsp; + uint64_t cur_blk_size; + int ret; + + cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(struct hikp_hccs_req)); + ret = hikp_rsp_normal_check(cmd_ret); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to query from firmware! ret = %d.\n", ret); + goto out; + } + + rsp = (struct hikp_hccs_rsp *)cmd_ret->rsp_data; + cur_blk_size = rsp->rsp_head.cur_blk_size; + if (cur_blk_size == 0) { + HIKP_ERROR_PRINT("Firmware reported zero data size!\n"); + ret = -EINVAL; + goto out; + } + if (cur_blk_size > buff_len || + cur_blk_size > sizeof(struct hikp_hccs_rsp)) { + 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)); + ret = -EINVAL; + goto out; + } + + memcpy(buff, rsp->rsp_data, rsp->rsp_head.cur_blk_size); + rsp_head->total_blk_num = rsp->rsp_head.total_blk_num; + rsp_head->cur_blk_size = rsp->rsp_head.cur_blk_size; + +out: + hikp_cmd_free(&cmd_ret); + return ret; +} + +static int hikp_hccs_query(struct hikp_cmd_header *req_header, + struct hikp_hccs_req *req_data, + void *buff, size_t buff_len) +{ + struct hikp_hccs_rsp_head rsp_head = {0}; + uint16_t total_blk_size = 0; + uint16_t total_blk_num; + uint16_t blk_id = 0; + int ret; + + ret = hikp_hccs_cmd_send(req_header, req_data, buff, buff_len, &rsp_head); + if (ret != 0) + return ret; + total_blk_num = rsp_head.total_blk_num; + total_blk_size += rsp_head.cur_blk_size; + for (blk_id = 1; blk_id < total_blk_num; blk_id++) { + if (buff_len <= total_blk_size) { + HIKP_ERROR_PRINT("No enough buffer to get block-(%u) context.\n", + blk_id); + return -EINVAL; + } + + req_data->head.blk_id = blk_id; + ret = hikp_hccs_cmd_send(req_header, req_data, + (uint8_t *)buff + total_blk_size, + buff_len - total_blk_size, &rsp_head); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get context for block-(%u)!\n", + blk_id); + return -EINVAL; + } + total_blk_size += rsp_head.cur_blk_size; + } + + return 0; +} + +static int hikp_hccs_get_chip_num(struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_chip_num_rsp_data rsp_data = {0}; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_CHIP_NUM, 0); + ret = hikp_hccs_query(&req_header, &req, + &rsp_data, sizeof(struct hccs_chip_num_rsp_data)); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get chip number from firmware, ret = %d!\n", ret); + return ret; + } + + if (rsp_data.chip_num == 0) { + HIKP_ERROR_PRINT("The chip number obtained from firmware is zero!\n"); + return -EINVAL; + } + hccs_info->chip_num = rsp_data.chip_num; + + return 0; +} + +static int hikp_hccs_get_die_num(uint8_t chip_id, struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_die_num_rsp_data rsp_data = {0}; + struct hikp_cmd_header req_header = {0}; + struct hccs_die_num_req_para *req_param; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_DIE_NUM, 0); + req_param = (struct hccs_die_num_req_para *)&req.req_data; + req_param->chip_id = chip_id; + ret = hikp_hccs_query(&req_header, &req, + &rsp_data, sizeof(struct hccs_die_num_rsp_data)); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get die number from firmware, ret = %d!\n", ret); + return ret; + } + + hccs_info->chip_info[chip_id].die_num = rsp_data.die_num; + return 0; +} + +static int hikp_hccs_get_die_info(struct hccs_die_info *die_info, + uint8_t chip_id, uint8_t die_idx) +{ + struct hccs_die_info_rsp_data rsp_data = {0}; + struct hccs_die_info_req_para *req_param; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_DIE_INFO, 0); + req_param = (struct hccs_die_info_req_para *)&req.req_data; + req_param->chip_id = chip_id; + req_param->die_idx = die_idx; + ret = hikp_hccs_query(&req_header, &req, + &rsp_data, sizeof(struct hccs_die_info_rsp_data)); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get die information from firmware, ret = %d!\n", ret); + return ret; + } + + die_info->die_id = rsp_data.die_id; + die_info->port_num = rsp_data.port_num; + return 0; +} + +static int hikp_hccs_get_all_die_info(struct hikp_plat_hccs_info *hccs_info) +{ + uint8_t chip_id, die_idx, die_num; + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + bool has_die = false; + int ret; + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + chip_info = &hccs_info->chip_info[chip_id]; + die_num = chip_info->die_num; + if (die_num == 0) + continue; + + has_die = true; + die_info = (struct hccs_die_info *)calloc(die_num, sizeof(struct hccs_die_info)); + if (die_info == NULL) { + HIKP_ERROR_PRINT("Failed to allocate memory for die information!\n"); + return -ENOMEM; + } + chip_info->die_info = die_info; + for (die_idx = 0; die_idx < die_num; die_idx++, die_info++) { + ret = hikp_hccs_get_die_info(die_info, chip_id, die_idx); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get die information for die idx %u!\n", + die_idx); + return ret; + } + } + } + + return has_die ? 0 : -EINVAL; +} + +static int hikp_hccs_get_ports_on_die(uint8_t *port_ids, uint16_t port_num, + uint8_t chip_id, uint8_t die_id) +{ + struct hccs_die_ports_req_para *req_param; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_PORT_IDS_ON_DIE, 0); + req_param = (struct hccs_die_ports_req_para *)&req.req_data; + req_param->chip_id = chip_id; + req_param->die_id = die_id; + ret = hikp_hccs_query(&req_header, &req, + port_ids, sizeof(uint8_t) * port_num); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get port ids from firmware, ret = %d!\n", ret); + return ret; + } + + return 0; +} + +static int hikp_hccs_get_all_port_info(struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + struct hccs_die_info *dies; + uint8_t chip_id, die_idx; + bool has_port = false; + int ret; + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + chip_info = &hccs_info->chip_info[chip_id]; + dies = chip_info->die_info; + has_port = false; + for (die_idx = 0; die_idx < chip_info->die_num; die_idx++) { + die_info = &dies[die_idx]; + if (die_info->port_num == 0) + continue; + + has_port = true; + die_info->port_ids = (uint8_t *)calloc(die_info->port_num, + sizeof(uint8_t)); + if (die_info->port_ids == NULL) + return -ENOMEM; + + ret = hikp_hccs_get_ports_on_die(die_info->port_ids, die_info->port_num, + chip_id, die_info->die_id); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get port ids for " + "chip (%u) die idx (%u)!\n", + chip_id, die_idx); + return ret; + } + } + } + + return has_port ? 0 : -EINVAL; +} + +static int hikp_hccs_get_chip_info(struct hikp_plat_hccs_info *hccs_info) +{ + uint8_t chip_id; + int ret; + + ret = hikp_hccs_get_chip_num(hccs_info); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get chip num!\n"); + return ret; + } + + hccs_info->chip_info = (struct hccs_chip_info *)calloc(hccs_info->chip_num, + sizeof(struct hccs_chip_info)); + if (hccs_info->chip_info == NULL) { + HIKP_ERROR_PRINT("Failed to allocate memory for chip info!\n"); + return -ENOMEM; + } + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + ret = hikp_hccs_get_die_num(chip_id, hccs_info); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get die num!\n"); + return ret; + } + } + + return 0; +} + +static int hikp_plat_hccs_hw_info(struct hikp_plat_hccs_info *hccs_info) +{ + int ret; + + ret = hikp_hccs_get_chip_info(hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get chip info, ret = %d!\n", ret); + return ret; + } + + ret = hikp_hccs_get_all_die_info(hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get all die info, ret = %d!\n", ret); + return ret; + } + + ret = hikp_hccs_get_all_port_info(hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get all port info, ret = %d!\n", ret); + return ret; + } + return 0; +} + +static int hikp_hccs_get_plat_topo(struct hccs_param *param, + union hccs_feature_info *info) +{ + int ret; + + HIKP_SET_USED(param); + HIKP_SET_USED(info); + + ret = hikp_plat_hccs_hw_info(&g_hccs_info); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get HCCS hardware info, ret = %d!\n", ret); + return ret; + } + return 0; +} + +static void hikp_plat_hccs_free(struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + uint8_t chip_id, die_idx; + + if (hccs_info->chip_info == NULL) + return; + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + chip_info = &hccs_info->chip_info[chip_id]; + die_info = chip_info->die_info; + if (die_info == NULL) + continue; + + for (die_idx = 0; die_idx < chip_info->die_num; die_idx++) { + if (die_info[die_idx].port_ids == NULL) + continue; + free(die_info[die_idx].port_ids); + die_info[die_idx].port_ids = NULL; + } + free(die_info); + chip_info->die_info = NULL; + } + free(hccs_info->chip_info); + hccs_info->chip_info = NULL; +} + +static bool hikp_hccs_die_id_valid(struct hikp_plat_hccs_info *hccs_info, + struct hccs_param *param, uint8_t *die_idx) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + uint8_t idx; + + chip_info = &hccs_info->chip_info[param->chip_id]; + die_info = chip_info->die_info; + for (idx = 0; idx < chip_info->die_num; idx++) { + if (param->die_id != die_info[idx].die_id) + continue; + *die_idx = idx; + return true; + } + return false; +} + +static bool hikp_hccs_port_id_valid(struct hikp_plat_hccs_info *hccs_info, + struct hccs_param *param, uint8_t die_idx) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + uint8_t port_id, *port_ids; + + chip_info = &hccs_info->chip_info[param->chip_id]; + die_info = &chip_info->die_info[die_idx]; + port_ids = die_info->port_ids; + + for (port_id = 0; port_id < die_info->port_num; port_id++) { + if (param->port_id == port_ids[port_id]) + return true; + } + + return false; +} + +static bool hikp_hccs_req_param_check(struct hikp_plat_hccs_info *hccs_info, + struct hccs_param *param) +{ + uint8_t die_idx; + + if (param->chip_id >= hccs_info->chip_num) { + HIKP_ERROR_PRINT("param error: chip id %u exceed chip number %u!\n", + param->chip_id, hccs_info->chip_num); + return false; + } + + if (!hikp_hccs_die_id_valid(hccs_info, param, &die_idx)) { + HIKP_ERROR_PRINT("Param error: die%u not found on chip%u!\n", + param->die_id, param->chip_id); + return false; + } + + if (!hikp_hccs_port_id_valid(hccs_info, param, die_idx)) { + HIKP_ERROR_PRINT("Param error: port id %u not found on chip%u die%u!\n", + param->port_id, param->chip_id, param->die_id); + return false; + } + + return true; +} + +static int hikp_hccs_get_port_attr(struct hccs_param *param, + union hccs_feature_info *info) +{ + struct hccs_port_attr_req_para *req_para; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + ret = hikp_plat_hccs_hw_info(&g_hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get HCCS hardware info for " + "port attributes, ret = %d.\n", ret); + return ret; + } + + if (!hikp_hccs_req_param_check(&g_hccs_info, param)) + return -EINVAL; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_PORT_FIXED_ATTR, 0); + req_para = (struct hccs_port_attr_req_para *)&req.req_data; + req_para->chip_id = param->chip_id; + req_para->die_id = param->die_id; + req_para->port_id = param->port_id; + ret = hikp_hccs_query(&req_header, &req, + info, sizeof(union hccs_feature_info)); + if (ret != 0) + return ret; + return 0; +} + +static int hikp_hccs_get_port_dfx_info(struct hccs_param *param, + union hccs_feature_info *info) +{ + struct hikp_hccs_rsp_head rsp_head = {0}; + struct hikp_cmd_header req_header = {0}; + struct hccs_port_dfx_info_vld *dfx_info; + struct hccs_port_dfx_req_para *dfx_req; + struct hikp_hccs_req req = {0}; + int ret; + + ret = hikp_plat_hccs_hw_info(&g_hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get HCCS hardware info for dfx info, ret = %d\n", + ret); + return ret; + } + + if (!hikp_hccs_req_param_check(&g_hccs_info, param)) + return -EINVAL; + + dfx_info = &info->dfx_info; + dfx_req = (struct hccs_port_dfx_req_para *)&req.req_data; + dfx_req->chip_id = param->chip_id; + dfx_req->port_id = param->port_id; + dfx_req->die_id = param->die_id; + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_PORT_DFX_INFO, 0); + ret = hikp_hccs_cmd_send(&req_header, &req, + &dfx_info->info, + sizeof(struct hccs_port_dfx_info), + &rsp_head); + if (ret != 0) + return ret; + + dfx_info->vld_size = rsp_head.cur_blk_size; + + return 0; +} + +static void hikp_hccs_show_topo(union hccs_feature_info *data) +{ + uint8_t chip_id, die_idx, die_num, port_idx, *port_ids; + struct hccs_die_info *die_info; + struct hccs_die_info *dies; + + HIKP_SET_USED(data); + + for (chip_id = 0; chip_id < g_hccs_info.chip_num; chip_id++) { + die_num = g_hccs_info.chip_info[chip_id].die_num; + dies = g_hccs_info.chip_info[chip_id].die_info; + printf("--chip%u\n", chip_id); + if (die_num == 0) + continue; + for (die_idx = 0; die_idx < die_num; die_idx++) { + die_info = &dies[die_idx]; + printf("\t--die%u\n", die_info->die_id); + port_ids = die_info->port_ids; + if (die_info->port_num == 0) + continue; + + for (port_idx = 0; port_idx < die_info->port_num; port_idx++) + printf("\t\t--hccs%u\n", port_ids[port_idx]); + } + } +} + +static void hikp_hccs_show_port_attr(union hccs_feature_info *feature_info) +{ + struct hccs_port_fixed_attr *info = &feature_info->attr; + + printf("%-16s\tHCCS-V%u\n" + "%-16s\tx%u\n" + "%-16s\t%uMbps\n" + "%-16s\t%u\n", + "hccs_type", info->hccs_type, + "lane_mode", info->lane_mode, + "speed", info->speed, + "enabled", info->enabled); +} + +static const char *hikp_hccs_link_fsm_to_str(uint8_t link_fsm) +{ + size_t i; + + for (i = 0; i < sizeof(link_fsm_map) / sizeof(link_fsm_map[0]); i++) { + if (link_fsm_map[i].link_fsm == link_fsm) + return link_fsm_map[i].str; + } + + return "unknown"; +} + +static void hikp_hccs_show_port_dfx_info(union hccs_feature_info *feature_info) +{ + struct hccs_port_dfx_info_vld *info_vld = &feature_info->dfx_info; + struct hccs_port_dfx_info *info = &info_vld->info; + size_t vld_size; + + vld_size = (size_t)info_vld->vld_size; + if (vld_size >= sizeof(info->link_fsm)) { + printf("%-16s\t%s\n", "link_fsm", hikp_hccs_link_fsm_to_str(info->link_fsm)); + vld_size -= sizeof(info->link_fsm); + } + + if (vld_size >= sizeof(info->cur_lane_num)) { + printf("%-16s\t%u\n", "cur_lane_num", info->cur_lane_num); + vld_size -= sizeof(info->cur_lane_num); + } + + if (vld_size >= sizeof(info->lane_mask)) { + printf("%-16s\t0x%x\n", "lane_mask", info->lane_mask); + vld_size -= sizeof(info->lane_mask); + } + + if (vld_size >= sizeof(info->crc_err_cnt)) { + printf("%-16s\t%u\n", "crc_err_cnt", info->crc_err_cnt); + vld_size -= sizeof(info->crc_err_cnt); + } + + if (vld_size >= sizeof(info->retry_cnt)) { + printf("%-16s\t%u\n", "retry_cnt", info->retry_cnt); + vld_size -= sizeof(info->retry_cnt); + } + + if (vld_size >= sizeof(info->phy_reinit_cnt)) { + printf("%-16s\t%u\n", "phy_reinit_cnt", info->phy_reinit_cnt); + vld_size -= sizeof(info->phy_reinit_cnt); + } + + if (vld_size >= sizeof(info->tx_credit)) { + printf("%-16s\t%u\n", "tx_credit", info->tx_credit); + vld_size -= sizeof(info->tx_credit); + } +} + +static void hikp_hccs_cmd_execute(struct major_cmd_ctrl *self) +{ + const struct hikp_hccs_feature_cmd *hccs_cmd; + union hccs_feature_info info = {0}; + int ret; + + if (g_hccs_param.feature_idx == -1) { + hikp_hccs_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "-g/--get param error!"); + self->err_no = -EINVAL; + return; + } + + hccs_cmd = &g_hccs_feature_cmd[g_hccs_param.feature_idx]; + if (g_hccs_param.param_mask != hccs_cmd->param_needed) { + hikp_hccs_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "Parameter mismatched!"); + self->err_no = -EINVAL; + return; + } + + ret = hikp_hccs_get_chip_num(&g_hccs_info); + if (ret < 0) { + self->err_no = ret; + return; + } + + if (g_hccs_info.chip_num == 1) { + snprintf(self->err_str, sizeof(self->err_str), + "The command is just supported on multi-sockets!\n"); + self->err_no = -EINVAL; + return; + } + + ret = hccs_cmd->query(&g_hccs_param, &info); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "Failed to query %s, ret = %d.", + hccs_cmd->feature_name, ret); + self->err_no = ret; + hikp_plat_hccs_free(&g_hccs_info); + return; + } + + printf("############## HCCS: %s info ############\n", hccs_cmd->feature_name); + hccs_cmd->show(&info); + printf("#################### END #######################\n"); + + hikp_plat_hccs_free(&g_hccs_info); +} + +static int hikp_hccs_cmd_feature_select(struct major_cmd_ctrl *self, const char *argv) +{ + size_t feat_size = HIKP_ARRAY_SIZE(g_hccs_feature_cmd); + size_t i; + + for (i = 0; i < feat_size; i++) { + if (strcmp(argv, g_hccs_feature_cmd[i].feature_name) == 0) { + g_hccs_param.feature_idx = i; + return 0; + } + } + + hikp_hccs_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "-g/--get param error!!!"); + self->err_no = -EINVAL; + + return self->err_no; +} + +static int hikp_hccs_cmd_parse_chip(struct major_cmd_ctrl *self, const char *argv) +{ + uint32_t chip_id; + + self->err_no = string_toui(argv, &chip_id); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), + "Failed to parse -c/--chip_id parameter."); + return self->err_no; + } + if (chip_id > UINT8_MAX) { + snprintf(self->err_str, sizeof(self->err_str), + "chip id should not be greater than %u.", UINT8_MAX); + self->err_no = -EINVAL; + return self->err_no; + } + + g_hccs_param.param_mask |= HCCS_ENABLE_CHIP_ID; + g_hccs_param.chip_id = (uint8_t)chip_id; + + return 0; +} + +static int hikp_hccs_cmd_parse_die(struct major_cmd_ctrl *self, const char *argv) +{ + uint32_t die_id; + + self->err_no = string_toui(argv, &die_id); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), + "Failed to parse -d/--die_id parameter."); + return self->err_no; + } + + if (die_id > UINT8_MAX) { + snprintf(self->err_str, sizeof(self->err_str), + "die id should not be greater than %u.", UINT8_MAX); + self->err_no = -EINVAL; + return self->err_no; + } + + g_hccs_param.param_mask |= HCCS_ENABLE_DIE_ID; + g_hccs_param.die_id = (uint8_t)die_id; + + return 0; +} + +static int hikp_hccs_cmd_parse_port(struct major_cmd_ctrl *self, const char *argv) +{ + uint32_t port_id; + + self->err_no = string_toui(argv, &port_id); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), + "Failed to parse -p/--port_id parameter."); + return self->err_no; + } + + if (port_id > UINT8_MAX) { + snprintf(self->err_str, sizeof(self->err_str), + "port id should not be greater %u.", UINT8_MAX); + self->err_no = -EINVAL; + return self->err_no; + } + + g_hccs_param.param_mask |= HCCS_ENABLE_PORT_ID; + g_hccs_param.port_id = (uint8_t)port_id; + return 0; +} + +static void hikp_hccs_cmd_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + g_hccs_param.feature_idx = -1; + + major_cmd->option_count = 0; + major_cmd->execute = hikp_hccs_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_hccs_cmd_help); + cmd_option_register("-g", "--get", true, hikp_hccs_cmd_feature_select); + cmd_option_register("-c", "--chip_id", true, hikp_hccs_cmd_parse_chip); + cmd_option_register("-d", "--die_id", true, hikp_hccs_cmd_parse_die); + cmd_option_register("-p", "--port_id", true, hikp_hccs_cmd_parse_port); +} + +HIKP_CMD_DECLARE("hccs", "dump HCCS information.", hikp_hccs_cmd_init); diff --git a/hccs/hikp_hccs.h b/hccs/hikp_hccs.h new file mode 100644 index 0000000..8ccc01a --- /dev/null +++ b/hccs/hikp_hccs.h @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2024-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_HCCS_H +#define HIKP_HCCS_H + +#include + +enum hikp_hccs_cmd_type { + HCCS_GET_CHIP_NUM = 0, + HCCS_GET_DIE_NUM, + HCCS_GET_DIE_INFO, + HCCS_GET_PORT_IDS_ON_DIE, + HCCS_GET_PORT_FIXED_ATTR, + HCCS_GET_PORT_DFX_INFO, +}; + +struct hccs_die_info { + uint8_t die_id; + uint16_t port_num; + uint8_t *port_ids; +}; + +struct hccs_chip_info { + uint8_t chip_id; + uint8_t die_num; + struct hccs_die_info *die_info; +}; + +struct hccs_port_fixed_attr { + uint8_t hccs_type; /* HCCS_V1, HCCS_V2 and etc. */ + uint8_t lane_mode; + uint16_t speed; /* Unit Mbps. */ + uint8_t enabled; /* Indicate if port is enabled. */ + uint8_t rsv[3]; +}; + +struct hccs_port_dfx_info { + uint8_t link_fsm; + uint8_t cur_lane_num; + uint16_t lane_mask; + uint32_t crc_err_cnt; + uint32_t retry_cnt; + uint32_t phy_reinit_cnt; + uint32_t tx_credit; + uint32_t rsv1[54]; +}; + +struct hccs_port_dfx_info_vld { + struct hccs_port_dfx_info info; + uint8_t vld_size; /* Indicate the valid bytes firmware reported. */ +}; + +union hccs_feature_info { + struct hccs_port_fixed_attr attr; + struct hccs_port_dfx_info_vld dfx_info; +}; + +struct hccs_chip_num_rsp_data { + uint8_t chip_num; +}; + +struct hccs_die_num_req_para { + uint8_t chip_id; +}; + +struct hccs_die_num_rsp_data { + uint8_t die_num; +}; + +struct hccs_die_info_req_para { + uint8_t chip_id; + uint8_t die_idx; +}; + +struct hccs_die_info_rsp_data { + uint8_t die_id; + uint8_t rsv; + uint16_t port_num; +}; + +struct hccs_die_ports_req_para { + uint8_t chip_id; + uint8_t die_id; +}; + +struct hccs_port_attr_req_para { + uint8_t chip_id; + uint8_t die_id; + uint8_t port_id; +}; + +struct hccs_port_dfx_req_para { + uint8_t chip_id; + uint8_t die_id; + uint8_t port_id; +}; + +struct hikp_hccs_rsp_head { + uint16_t total_blk_num; + uint8_t cur_blk_size; /* real data size, not contain header size. */ + uint8_t rsv; +}; + +#define HCCS_MAX_RSP_DATA 59 +struct hikp_hccs_rsp { + struct hikp_hccs_rsp_head rsp_head; /* 4 Byte */ + uint32_t rsp_data[HCCS_MAX_RSP_DATA]; +}; + +struct hikp_hccs_req_head { + uint16_t blk_id; + uint16_t rsv; +}; + +#define HCCS_MAX_REQ_DATA 31 +struct hikp_hccs_req { + struct hikp_hccs_req_head head; /* 4 Byte */ + uint32_t req_data[HCCS_MAX_REQ_DATA]; +}; + +#define HCCS_ENABLE_CHIP_ID HI_BIT(0) +#define HCCS_ENABLE_DIE_ID HI_BIT(1) +#define HCCS_ENABLE_PORT_ID HI_BIT(2) +#define HCCS_PORT_INFO_MASK (HCCS_ENABLE_CHIP_ID | HCCS_ENABLE_DIE_ID | \ + HCCS_ENABLE_PORT_ID) + +struct hccs_param { + int feature_idx; + uint8_t chip_id; + uint8_t die_id; + uint32_t port_id; + /* mask for param passed by user, see HCCS_ENABLE_XXX. */ + uint16_t param_mask; +}; + +struct hikp_plat_hccs_info { + uint8_t chip_num; + struct hccs_chip_info *chip_info; +}; + +#define HIKP_HCCS_FEATURE_NAME_LEN 20 +struct hikp_hccs_feature_cmd { + const char feature_name[HIKP_HCCS_FEATURE_NAME_LEN]; + uint32_t cmd_code; + int (*query)(struct hccs_param *param, union hccs_feature_info *info); + void (*show)(union hccs_feature_info *data); + uint16_t param_needed; +}; + +#endif /* HIKP_HCCS_H */ diff --git a/libhikptdev/include/hikptdev_plug.h b/libhikptdev/include/hikptdev_plug.h index 2123935..d45a654 100644 --- a/libhikptdev/include/hikptdev_plug.h +++ b/libhikptdev/include/hikptdev_plug.h @@ -44,6 +44,7 @@ enum cmd_module_type { DPDK_MOD = 9, CXL_MOD = 10, UB_MOD = 11, + HCCS_MOD = 16 }; void hikp_unlock(void); -- Gitee From 05068c03151a9f14af4b808163a3b29cbdd2fb7b Mon Sep 17 00:00:00 2001 From: moubingquan Date: Wed, 8 Jan 2025 10:49:19 +0800 Subject: [PATCH 5/9] The PCS-layer register print command is deleted. The register print of the PCS layer is deleted. Currently, the register of this module does not need to be dumped. Signed-off-by: moubingquan --- pcie/func_lib/pcie_func/pcie_reg_dump.c | 15 --------------- pcie/func_lib/pcie_func/pcie_reg_dump.h | 10 ---------- 2 files changed, 25 deletions(-) diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c index ad7cc7f..cb59d2c 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.c +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c @@ -131,20 +131,6 @@ struct pcie_dumpreg_info g_reg_table_mac[] = { {0, "MAC_POWERDOWN_VALUE_REG"}, }; -struct pcie_dumpreg_info g_reg_table_pcs[] = { - HIKP_PCIE_PCS_LANE_TBL_ENTRY(SERDES_STATUS_RPT), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(EBUF_STATUS), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(GEN3_DEC_ENC_STATUS), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(WAKE_STATUS), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(RECV_DET_OR_PWR_CHAGE), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(EQEVAL_STATUS), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(LANE_INTR_STATUS), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(M_PCS_RPT_REG), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(MSG_BUS_DFX), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(DETECT_CLK_FLG_REG), - HIKP_PCIE_PCS_LANE_TBL_ENTRY(SDS_CFG_REG_REG), -}; - struct pcie_dumpreg_info g_reg_table_iob_tx[] = { {0, "IOB_TX_ECAM_CONTROL0"}, {0, "IOB_TX_ECAM_CONTROL1"}, @@ -456,7 +442,6 @@ struct pcie_dumpreg_table g_dump_info_glb[] = { {HIKP_ARRAY_SIZE(g_reg_table_iob_rx), g_reg_table_iob_rx}, {HIKP_ARRAY_SIZE(g_reg_table_ap_glb), g_reg_table_ap_glb}, {HIKP_ARRAY_SIZE(g_reg_table_core_glb), g_reg_table_core_glb}, - {HIKP_ARRAY_SIZE(g_reg_table_pcs), g_reg_table_pcs}, {HIKP_ARRAY_SIZE(g_reg_table_core_tl), g_reg_table_core_tl}, {HIKP_ARRAY_SIZE(g_reg_table_dfx_core_tl), g_reg_table_dfx_core_tl}, }; diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.h b/pcie/func_lib/pcie_func/pcie_reg_dump.h index 3c52a6e..c74ce56 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.h +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.h @@ -22,16 +22,6 @@ #define PCIE_DUMPREG_LOGFILE_NAME "pcie_dumpreg" #define LOG_FILE_PATH_MAX_LEN 512 -#define HIKP_PCIE_PCS_LANE_TBL_ENTRY(name) \ - {0, STR(CONTACT(name, _00))}, {0, STR(CONTACT(name, _01))}, \ - {0, STR(CONTACT(name, _02))}, {0, STR(CONTACT(name, _03))}, \ - {0, STR(CONTACT(name, _04))}, {0, STR(CONTACT(name, _05))}, \ - {0, STR(CONTACT(name, _06))}, {0, STR(CONTACT(name, _07))}, \ - {0, STR(CONTACT(name, _08))}, {0, STR(CONTACT(name, _09))}, \ - {0, STR(CONTACT(name, _10))}, {0, STR(CONTACT(name, _11))}, \ - {0, STR(CONTACT(name, _12))}, {0, STR(CONTACT(name, _13))}, \ - {0, STR(CONTACT(name, _14))}, {0, STR(CONTACT(name, _15))} - enum pcie_dump_level { DUMP_GLOBAL_LEVEL = 1, DUMP_PORT_LEVEL = 2, -- Gitee From 1b62cbd78e7bcb6789dea10b95bcc692ac355a96 Mon Sep 17 00:00:00 2001 From: moubingquan Date: Wed, 15 Jan 2025 10:24:28 +0800 Subject: [PATCH 6/9] hikptool/pcie: Resolved the problem that it takes a long time to write files The write function takes a long time to write files when the FIO pressure is heavy. Therefore, the function needs to be changed to fwrite with cache. Signed-off-by: moubingquan --- pcie/func_lib/pcie_func/pcie_reg_dump.c | 34 +++++++++++-------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c index cb59d2c..ba6641e 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.c +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c @@ -22,7 +22,7 @@ #include "pcie_common.h" #include "pcie_reg_dump.h" -int g_pcie_dumpreg_fd; +FILE *g_pcie_dumpreg_fd = NULL; char dumpreg_log_file[MAX_LOG_NAME_LEN + 1] = {0}; struct pcie_dumpreg_info g_reg_table_tl[] = { @@ -381,7 +381,7 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) { char file_name[MAX_LOG_NAME_LEN + 1] = { 0 }; char info_str[MAX_LOG_NAME_LEN + 1] = { 0 }; - int fd_file; + FILE *fd_file = NULL; int ret; ret = snprintf(info_str, sizeof(info_str), "%s_port%u_level%u", @@ -399,8 +399,8 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) (void)remove((const char *)file_name); /* Add write permission to the file */ - fd_file = open(file_name, O_RDWR | O_SYNC | O_CREAT, 0600); - if (fd_file < 0) { + fd_file = fopen(file_name, "w+"); + if (fd_file == NULL) { Err("open %s failed.\n", file_name); return -EPERM; } @@ -409,30 +409,26 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) return 0; } -static int pcie_close_dumpreg_log_file(void) +static void pcie_close_dumpreg_log_file(void) { - int ret; - - ret = fchmod(g_pcie_dumpreg_fd, 0400); - close(g_pcie_dumpreg_fd); + fclose(g_pcie_dumpreg_fd); /* Revoke write permission of file */ - g_pcie_dumpreg_fd = -1; - - return ret; + chmod(dumpreg_log_file, 0400); + g_pcie_dumpreg_fd = NULL; } static void pcie_dumpreg_write_value_to_file(const char *reg_name, uint32_t val) { char str[MAX_STR_LEN] = { 0 }; - ssize_t wr_ret; + size_t wr_ret; int ret; ret = snprintf(str, sizeof(str), " %-40s : 0x%x\n", reg_name, val); if (ret < 0 || ret >= MAX_STR_LEN) { Err("pcie dumpreg write info to logfile failed.\n"); } else { - wr_ret = write(g_pcie_dumpreg_fd, str, strlen(str)); - if (wr_ret == -1) + wr_ret = fwrite(str, 1, strlen(str), g_pcie_dumpreg_fd); + if (wr_ret != strlen(str)) Err("write info to logfile failed.\n"); } } @@ -470,7 +466,7 @@ static int pcie_dumpreg_write_header_to_file(uint32_t version, const struct pcie_dump_req_para *req_data) { char str[MAX_STR_LEN] = {0}; - ssize_t wr_ret; + size_t wr_ret; int ret; ret = snprintf(str, sizeof(str), "Command Version[%u], dump_level[%u], port_id[%u]\n\n", @@ -480,8 +476,8 @@ static int pcie_dumpreg_write_header_to_file(uint32_t version, return -EIO; } - wr_ret = write(g_pcie_dumpreg_fd, str, strlen(str)); - if (wr_ret == -1) { + wr_ret = fwrite(str, 1, strlen(str), g_pcie_dumpreg_fd); + if (wr_ret != strlen(str)) { Err("write header to logfile failed.\n"); return -EIO; } @@ -566,7 +562,7 @@ int pcie_dumpreg_do_dump(uint32_t port_id, uint32_t dump_level) Info("pcie reg dump finish.\n"); close_file_ret: - (void)pcie_close_dumpreg_log_file(); + pcie_close_dumpreg_log_file(); free_cmd_ret: hikp_cmd_free(&cmd_ret); -- Gitee From fddbe5505455e282cf7584f58df6ab85ff4e7a6e Mon Sep 17 00:00:00 2001 From: wangzijian Date: Tue, 25 Feb 2025 07:11:27 +0800 Subject: [PATCH 7/9] Hikptool add support dump SDMA register information according to the usage environment. 1. support dump SDMA channel status reg e.g. hikptool sdma_dump -s -c -d 2. support dump SDMA pc reg e.g. hikptool sdma_dump -p -c -d -n 3. support dump SDMA vc reg e.g. hikptool sdma_dump -v -c -d -n Signed-off-by: wangzijian --- CMakeLists.txt | 1 + libhikptdev/include/hikptdev_plug.h | 3 +- sdma/sdma_func/sdma_common.h | 31 +++++ sdma/sdma_func/sdma_dump_reg.c | 133 ++++++++++++++++++++++ sdma/sdma_func/sdma_dump_reg.h | 28 +++++ sdma/user_cmd/sdma_cmd_dump.c | 171 ++++++++++++++++++++++++++++ sdma/user_cmd/sdma_tools_include.h | 24 ++++ 7 files changed, 390 insertions(+), 1 deletion(-) create mode 100644 sdma/sdma_func/sdma_common.h create mode 100644 sdma/sdma_func/sdma_dump_reg.c create mode 100644 sdma/sdma_func/sdma_dump_reg.h create mode 100644 sdma/user_cmd/sdma_cmd_dump.c create mode 100644 sdma/user_cmd/sdma_tools_include.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 72f2dab..4f4eb03 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -46,6 +46,7 @@ file(GLOB_RECURSE HIKPTOOL_SRC ${CMAKE_CURRENT_SOURCE_DIR}/serdes/*.c ${CMAKE_CURRENT_SOURCE_DIR}/socip/*.c ${CMAKE_CURRENT_SOURCE_DIR}/hccs/*.c + ${CMAKE_CURRENT_SOURCE_DIR}/sdma/*.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 d45a654..375fb89 100644 --- a/libhikptdev/include/hikptdev_plug.h +++ b/libhikptdev/include/hikptdev_plug.h @@ -44,7 +44,8 @@ enum cmd_module_type { DPDK_MOD = 9, CXL_MOD = 10, UB_MOD = 11, - HCCS_MOD = 16 + HCCS_MOD = 16, + SDMA_MOD = 17 }; void hikp_unlock(void); diff --git a/sdma/sdma_func/sdma_common.h b/sdma/sdma_func/sdma_common.h new file mode 100644 index 0000000..40969b8 --- /dev/null +++ b/sdma/sdma_func/sdma_common.h @@ -0,0 +1,31 @@ +/* + * 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 SDMA_COMMON_H +#define SDMA_COMMON_H + +#define RESP_MAX_NUM 160 + +/* SDMA command code */ +enum sdma_cmd_type { + SDMA_DUMP = 0, +}; + +enum sdma_dump_cmd_type { + DUMP_UNKNOWN = 0, + DUMP_CHN_STATUS, + DUMP_CHN_PC, + DUMP_CHN_VC, +}; + +#endif /* SDMA_COMMON_H */ diff --git a/sdma/sdma_func/sdma_dump_reg.c b/sdma/sdma_func/sdma_dump_reg.c new file mode 100644 index 0000000..7440fb6 --- /dev/null +++ b/sdma/sdma_func/sdma_dump_reg.c @@ -0,0 +1,133 @@ +/* + * 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 "sdma_common.h" +#include "sdma_dump_reg.h" + +#define TARGET_DIR "/sys/devices/platform/" +#define PREFIX "HISI0431" +#define PREFIX_LEN 8 + +int sdma_dev_check(void) +{ + struct dirent *entry; + DIR *dir; + + dir = opendir(TARGET_DIR); + if (dir == NULL) { + perror("opendir"); + return -errno; + } + + while ((entry = readdir(dir)) != NULL) { + if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) + continue; + + if (strlen(entry->d_name) >= PREFIX_LEN) { + if (strncmp(entry->d_name, PREFIX, PREFIX_LEN) == 0) { + closedir(dir); + return 0; + } + } + } + + closedir(dir); + return -ENODEV; +} + +static int sdma_rsp_normal_check(const struct hikp_cmd_ret *cmd_ret) +{ + if (cmd_ret == NULL) + return -ENOSPC; + + if (cmd_ret->status != 0) + return -EINVAL; + + if (cmd_ret->rsp_data_num > RESP_MAX_NUM) + return -E2BIG; + + return 0; +} + +static int sdma_get_reg(const struct tool_sdma_cmd *cmd, uint32_t *reg_save, uint32_t *reg_num) +{ + struct sdma_dump_req_para req_data = { 0 }; + struct hikp_cmd_header req_header = { 0 }; + struct hikp_cmd_ret *cmd_ret; + uint32_t i; + int ret; + + req_data.chip_id = cmd->chip_id; + req_data.die_id = cmd->die_id; + req_data.chn_id = cmd->chn_id; + + hikp_cmd_init(&req_header, SDMA_MOD, SDMA_DUMP, cmd->sdma_cmd_type); + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + ret = sdma_rsp_normal_check(cmd_ret); + if (ret) { + printf("check cmd ret failed, ret: %d.\n", ret); + hikp_cmd_free(&cmd_ret); + return ret; + } + *reg_num = cmd_ret->rsp_data_num; + for (i = 0; i < *reg_num; i++) + reg_save[i] = cmd_ret->rsp_data[i]; + + hikp_cmd_free(&cmd_ret); + + return 0; +} + +static void sdma_print_reg(const uint32_t *reg_save, uint32_t reg_num) +{ + uint32_t i; + + if (reg_num == 0) { + printf("SDMA dump is failed\n"); + return; + } + printf(" sdma reg dump list:\n"); + for (i = 0; i < reg_num; i++) + printf(" 0x%08x\n", reg_save[i]); +} + +int sdma_reg_dump(struct tool_sdma_cmd *cmd) +{ + uint32_t sdma_reg_save[RESP_MAX_NUM] = { 0 }; + uint32_t sdma_reg_num = 0; + int ret; + + if (cmd == NULL) + return -EINVAL; + + ret = sdma_dev_check(); + if (ret) { + printf("The current environment not support this feature!\n"); + return ret; + } + + ret = sdma_get_reg(cmd, sdma_reg_save, &sdma_reg_num); + if (ret) + return ret; + + sdma_print_reg(sdma_reg_save, sdma_reg_num); + + return 0; +} diff --git a/sdma/sdma_func/sdma_dump_reg.h b/sdma/sdma_func/sdma_dump_reg.h new file mode 100644 index 0000000..51c4e66 --- /dev/null +++ b/sdma/sdma_func/sdma_dump_reg.h @@ -0,0 +1,28 @@ +/* + * 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 SDMA_DUMP_REG_H +#define SDMA_DUMP_REG_H + +#include "sdma_tools_include.h" + +struct sdma_dump_req_para { + uint32_t chip_id; + uint32_t die_id; + uint32_t chn_id; +}; + +int sdma_dev_check(void); +int sdma_reg_dump(struct tool_sdma_cmd *cmd); + +#endif /* SDMA_DUMP_REG_H */ diff --git a/sdma/user_cmd/sdma_cmd_dump.c b/sdma/user_cmd/sdma_cmd_dump.c new file mode 100644 index 0000000..6f4fcc2 --- /dev/null +++ b/sdma/user_cmd/sdma_cmd_dump.c @@ -0,0 +1,171 @@ +/* + * 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 "hikptdev_plug.h" +#include "tool_lib.h" +#include "tool_cmd.h" +#include "sdma_tools_include.h" +#include "sdma_common.h" +#include "sdma_dump_reg.h" + +struct tool_sdma_cmd g_sdma_dump_cmd = { + .sdma_cmd_type = DUMP_UNKNOWN, + .chip_id = (uint32_t)(-1), + .die_id = (uint32_t)(-1), + .chn_id = (uint32_t)(-1), +}; + +static int sdma_dump_help(struct major_cmd_ctrl *self, const char *argv) +{ + int ret; + + ret = sdma_dev_check(); + if (ret) { + printf("The current environment not support this feature!\n"); + return ret; + } + HIKP_SET_USED(argv); + + printf("\n Usage: %s\n", self->cmd_ptr->name); + printf("\n %s\n", self->cmd_ptr->help_info); + printf(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n"); + printf(" %s, %-25s %s\n", "-d", "--dieid", "please input die id[x] first\n"); + printf(" %s, %-25s %s\n", "-n", "--chnid", "please input chn id[x] first\n"); + printf("\n Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit\n"); + printf(" %s, %-25s %s\n", "-s", "--chnstatus", "dump sdma channel status dfx reg\n"); + printf("\tParameter Limitation: -c --chipid and -d --dieid is necessary,"); + printf(" -n --chnid is invalid\n"); + printf("\tUsage: -s -c [chipid] -d [dieid], e.g. -s -c 0 -d 0\n\n"); + printf(" %s, %-25s %s\n", "-p", "--pc", "dump sdma pc channel dfx reg\n"); + printf("\tParameter Limitation: All three parameters are necessary,"); + printf(" the -n --chnid range is limited to 0-31\n"); + printf("\tUsage: -p -c [chipid] -d [dieid] -n [chnid], e.g. -p -c 0 -d 0 -n 31\n\n"); + printf(" %s, %-25s %s\n", "-v", "--vc", "dump sdma vc channel dfx reg\n"); + printf("\tParameter Limitation: All three parameters are necessary,"); + printf(" the -n --chnid range is limited to 0-159\n"); + printf("\tUsage: -v -c [chipid] -d [dieid] -n [chnid], e.g. -v -c 0 -d 0 -n 159\n\n"); + printf("\n"); + + return 0; +} + +static int sdma_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t *id) +{ + uint32_t val = 0; + int ret; + + ret = string_toui(argv, &val); + if (ret) { + snprintf(self->err_str, sizeof(self->err_str), "Invalid id."); + self->err_no = ret; + return ret; + } + *id = val; + return ret; +} + +static int sdma_set_chip_id(struct major_cmd_ctrl *self, const char *argv) +{ + return sdma_set_id(self, argv, &g_sdma_dump_cmd.chip_id); +} + +static int sdma_set_die_id(struct major_cmd_ctrl *self, const char *argv) +{ + return sdma_set_id(self, argv, &g_sdma_dump_cmd.die_id); +} + +static int sdma_set_chn_id(struct major_cmd_ctrl *self, const char *argv) +{ + return sdma_set_id(self, argv, &g_sdma_dump_cmd.chn_id); +} + +static int sdma_dump_chn_status(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + g_sdma_dump_cmd.sdma_cmd_type = DUMP_CHN_STATUS; + return 0; +} + +static int sdma_dump_chn_pc(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + g_sdma_dump_cmd.sdma_cmd_type = DUMP_CHN_PC; + return 0; +} + +static int sdma_dump_chn_vc(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + g_sdma_dump_cmd.sdma_cmd_type = DUMP_CHN_VC; + return 0; +} + +static int sdma_dump_excute_function_call(uint32_t cmd_type) +{ + if (cmd_type != DUMP_UNKNOWN) + return sdma_reg_dump(&g_sdma_dump_cmd); + + return -EINVAL; +} + +static void sdma_dump_execute(struct major_cmd_ctrl *self) +{ + int ret; + const char *suc_msg[] = { + "", + "sdma_dump_chn_status success.", + "sdma_dump_dfx_pc success.", + "sdma_dump_dfx_vc success." + }; + const char *err_msg[] = { + "sdma_dump failed, unknown cmd type", + "sdma_dump_chn_status error.", + "sdma_dump_dfx_pc error.", + "sdma_dump_dfx_vc error." + }; + + ret = sdma_dump_excute_function_call(g_sdma_dump_cmd.sdma_cmd_type); + if (ret == 0) + printf("%s\n", suc_msg[g_sdma_dump_cmd.sdma_cmd_type]); + else { + snprintf(self->err_str, sizeof(self->err_str), "%s\n", + err_msg[g_sdma_dump_cmd.sdma_cmd_type]); + self->err_no = ret; + } +} + +static void cmd_sdma_dump_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = sdma_dump_execute; + + cmd_option_register("-c", "--chipid", true, sdma_set_chip_id); + cmd_option_register("-d", "--dieid", true, sdma_set_die_id); + cmd_option_register("-n", "--chnid", true, sdma_set_chn_id); + cmd_option_register("-h", "--help", false, sdma_dump_help); + cmd_option_register("-s", "--chnstatus", false, sdma_dump_chn_status); + cmd_option_register("-p", "--pc", false, sdma_dump_chn_pc); + cmd_option_register("-v", "--vc", false, sdma_dump_chn_vc); +} + +HIKP_CMD_DECLARE("sdma_dump", "sdma reg dump", cmd_sdma_dump_init); diff --git a/sdma/user_cmd/sdma_tools_include.h b/sdma/user_cmd/sdma_tools_include.h new file mode 100644 index 0000000..01b24b5 --- /dev/null +++ b/sdma/user_cmd/sdma_tools_include.h @@ -0,0 +1,24 @@ +/* + * 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 SDMA_TOOLS_INCLUDE_H +#define SDMA_TOOLS_INCLUDE_H + +struct tool_sdma_cmd { + uint32_t sdma_cmd_type; + uint32_t chip_id; + uint32_t die_id; + uint32_t chn_id; +}; + +#endif /* SDMA_TOOLS_INCLUDE_H */ -- Gitee From e254f7befcf2712b03c23ae4984822cd5bfddb06 Mon Sep 17 00:00:00 2001 From: zhangyuyang Date: Fri, 28 Feb 2025 14:20:26 +0800 Subject: [PATCH 8/9] Add support collect sdma hikptool dump reg info. 1. support collect sdma info e.g. hiktool info_collect -sdma Signed-off-by: zhangyuyang --- info_collect/hikp_collect.h | 3 + info_collect/hikp_collect_main.c | 19 ++- info_collect/hikp_collect_sdma.c | 261 +++++++++++++++++++++++++++++++ 3 files changed, 282 insertions(+), 1 deletion(-) create mode 100644 info_collect/hikp_collect_sdma.c diff --git a/info_collect/hikp_collect.h b/info_collect/hikp_collect.h index 28aa5a4..26108ac 100644 --- a/info_collect/hikp_collect.h +++ b/info_collect/hikp_collect.h @@ -24,6 +24,7 @@ #define GROUP_IMP "imp" #define GROUP_COMMON "common" #define GROUP_SERDES "serdes" +#define GROUP_SDMA "sdma" enum info_collect_type { COLLECT_ACC, @@ -35,6 +36,7 @@ enum info_collect_type { COLLECT_SATA, COLLECT_SERDES, COLLECT_SOCIP, + COLLECT_SDMA, COLLECT_ALL, COLLECT_UNKNOWN_TYPE, }; @@ -49,5 +51,6 @@ void collect_roce_log(void); void collect_pcie_info(void); void collect_imp_log(void); void collect_serdes_log(void); +void collect_sdma_log(void); #endif /* HIKP_COLLECT_H */ diff --git a/info_collect/hikp_collect_main.c b/info_collect/hikp_collect_main.c index c413346..46120a5 100644 --- a/info_collect/hikp_collect_main.c +++ b/info_collect/hikp_collect_main.c @@ -108,6 +108,15 @@ static int info_collect_socip(struct major_cmd_ctrl *self, const char *argv) return 0; } +static int info_collect_sdma(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SDMA); + return 0; +} + static int info_collect_all(struct major_cmd_ctrl *self, const char *argv) { HIKP_SET_USED(self); @@ -128,12 +137,13 @@ static void collect_all_log(void) collect_sata_log(); collect_serdes_log(); collect_socip_log(); + collect_sdma_log(); } static int info_collect_excute_funs_call(uint32_t collect_type) { const char *type_name[] = {"acc", "imp", "nic", "pcie", "roce", "sas", - "sata", "serdes", "socip", "all"}; + "sata", "serdes", "socip", "sdma", "all"}; int ret; if (collect_type == COLLECT_UNKNOWN_TYPE) @@ -173,6 +183,9 @@ static int info_collect_excute_funs_call(uint32_t collect_type) case COLLECT_SOCIP: collect_socip_log(); break; + case COLLECT_SDMA: + collect_sdma_log(); + break; case COLLECT_ALL: collect_all_log(); break; @@ -199,6 +212,7 @@ static void info_collect_execute(struct major_cmd_ctrl *self) "collect sata info success.", "collect serdes info success.", "collect socip info success.", + "collect sdma info success.", "collect all info success.", }; const char *err_msg[] = { @@ -211,6 +225,7 @@ static void info_collect_execute(struct major_cmd_ctrl *self) "collect sata info error.", "collect serdes info error.", "collect socip info error.", + "collect sdma info error.", "collect all info error.", "collect info failed, unknown type.", }; @@ -245,6 +260,7 @@ static int info_collect_help(struct major_cmd_ctrl *self, const char *argv) printf(" %s, %-25s %s\n", "-sata", "--sata", "collect sata info\n"); printf(" %s, %-25s %s\n", "-serdes", "--serdes", "collect serdes info\n"); printf(" %s, %-25s %s\n", "-socip", "--socip", "collect socip info\n"); + printf(" %s, %-25s %s\n", "-sdma", "--sdma", "collect sdma info\n"); printf(" %s, %-25s %s\n", "-all", "--all", "collect all info\n"); printf("\n"); @@ -268,6 +284,7 @@ static void cmd_info_collect_init(void) cmd_option_register("-sata", "--sata", false, info_collect_sata); cmd_option_register("-serdes", "--serdes", false, info_collect_serdes); cmd_option_register("-socip", "--socip", false, info_collect_socip); + cmd_option_register("-sdma", "--sdma", false, info_collect_sdma); cmd_option_register("-all", "--all", false, info_collect_all); } diff --git a/info_collect/hikp_collect_sdma.c b/info_collect/hikp_collect_sdma.c new file mode 100644 index 0000000..8dc315c --- /dev/null +++ b/info_collect/hikp_collect_sdma.c @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2024 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "sdma_dump_reg.h" +#include "sdma_tools_include.h" + +#define PC_MAX_NUM 32 +#define VC_MAX_NUM 160 +#define SDMA_DIE_MAX 4 +#define SDMA_DIE_CHANGE 2 +#define SDMA_DUMP_DELAY 50000 +#define BUFFER_LENTH 1024 + +typedef int (*reg_info_func_t)(uint32_t, uint32_t); + +enum sdma_dump_type { + SDMA_DUMP_UNKNOWN = 0, + SDMA_DUMP_CHN_STATUS, + SDMA_DUMP_CHN_PC, + SDMA_DUMP_CHN_VC, +}; + +struct reg_op { + char *func_name; + reg_info_func_t func; + uint32_t sdma_die; +}; + +static int sdma_dmesg_exec(void *data) +{ + struct info_collect_cmd *cmd = (struct info_collect_cmd *)data; + char dmesg_cmd[MAX_LOG_NAME_LEN] = {0}; + char buffer[BUFFER_LENTH] = {0}; + int i = 0; + FILE *fp; + + while (cmd->args[i] != 0) { + strcat(dmesg_cmd, cmd->args[i]); + strcat(dmesg_cmd, " "); + i++; + } + + fp = popen(dmesg_cmd, "r"); + if (fp == NULL) { + perror("popen"); + return -errno; + } + + while (fgets(buffer, sizeof(buffer), fp) != NULL) { + printf("%s", buffer); + } + + pclose(fp); + + return 0; +} + +static void collect_sdma_kernel_log(void) +{ + struct info_collect_cmd sdma_kernel_cmds[] = { + { + .log_name = "dmesg", + .args = {"dmesg", "|", "grep", "sdma", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sdma_kernel_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SDMA, sdma_kernel_cmds[i].log_name, + sdma_dmesg_exec, (void *)&sdma_kernel_cmds[i]); + if (ret) { + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sdma_kernel_cmds[i].log_name, ret); + } + } +} + +static void collect_sdma_debugfs_log(void) +{ + struct info_collect_cmd sdma_debugfs_cmds[] = { + { + .log_name = "sdma_channels", + .args = {"cat", "/sys/kernel/debug/sdma/sdma_channels", NULL}, + }, + { + .log_name = "sdma_error", + .args = {"cat", "/sys/kernel/debug/sdma/sdma_error", NULL}, + }, + { + .log_name = "sdma_stats", + .args = {"cat", "/sys/kernel/debug/sdma/sdma_stats", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sdma_debugfs_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SDMA, sdma_debugfs_cmds[i].log_name, + hikp_collect_cat_glob_exec, (void *)&sdma_debugfs_cmds[i]); + if (ret) { + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sdma_debugfs_cmds[i].log_name, ret); + } + } +} + +static int sdma_reg_log(void *data) +{ + struct reg_op *op = (struct reg_op *)data; + uint32_t chip, die; + int ret; + + chip = op->sdma_die / SDMA_DIE_CHANGE; + die = op->sdma_die % SDMA_DIE_CHANGE; + ret = op->func(chip, die); + if (ret) + HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", op->func_name, chip, die, ret); + + return ret; +} + +static int sdma_chn_status_dump_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sdma_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + int ret; + + printf("hikptool sdma_dump -s -c %u -d %u\n", cmd.chip_id, cmd.die_id); + printf(" sdma%u channel status\n", SDMA_DIE_CHANGE * cmd.chip_id + cmd.die_id); + cmd.sdma_cmd_type = SDMA_DUMP_CHN_STATUS; + ret = sdma_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump channel status failed: %d\n", ret); + return ret; + } + + return 0; +} + +static int sdma_pc_dump_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sdma_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + cmd.sdma_cmd_type = SDMA_DUMP_CHN_PC; + for (i = 0; i < PC_MAX_NUM; i++) { + printf("hikptool sdma_dump -p -c %u -d %u -n %u\n", cmd.chip_id, cmd.die_id, i); + printf(" sdma%u pc chn%u\n", SDMA_DIE_CHANGE * cmd.chip_id + cmd.die_id, i); + cmd.chn_id = i; + ret = sdma_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump pc chn%u reg failed: %d\n", i, ret); + return ret; + } + } + + return 0; +} + +static int sdma_vc_dump_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sdma_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + cmd.sdma_cmd_type = SDMA_DUMP_CHN_VC; + for (i = 0; i < VC_MAX_NUM; i++) { + printf("hikptool sdma_dump -v -c %u -d %u -n %u\n", cmd.chip_id, cmd.die_id, i); + printf(" sdma%u vc chn%u\n", SDMA_DIE_CHANGE * cmd.chip_id + cmd.die_id, i); + cmd.chn_id = i; + ret = sdma_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump vc chn%u reg failed: %d\n", i, ret); + return ret; + } + } + + return 0; +} + +static void collect_sdma_reg_log(void) +{ + struct reg_op ch_op = { + .func = sdma_chn_status_dump_info, + .func_name = "sdma_chn_status_dump_info", + }; + struct reg_op pc_op = { + .func = sdma_pc_dump_info, + .func_name = "sdma_pc_dump_info", + }; + struct reg_op vc_op = { + .func = sdma_vc_dump_info, + .func_name = "sdma_vc_dump_info", + }; + char log_name[MAX_LOG_NAME_LEN] = {0}; + uint32_t i; + int ret; + + for (i = 0; i < SDMA_DIE_MAX; i++) { + ch_op.sdma_die = i; + memset(log_name, 0, MAX_LOG_NAME_LEN); + (void)snprintf(log_name, MAX_LOG_NAME_LEN, "sdma%u_channel_status_dump", i); + + ret = hikp_collect_log(GROUP_SDMA, log_name, sdma_reg_log, (void *)&ch_op); + if (ret) + HIKP_ERROR_PRINT("%s failed: %d\n", ch_op.func_name, ret); + usleep(SDMA_DUMP_DELAY); + + pc_op.sdma_die = i; + memset(log_name, 0, MAX_LOG_NAME_LEN); + (void)snprintf(log_name, MAX_LOG_NAME_LEN, "sdma%u_pc_dump", i); + + ret = hikp_collect_log(GROUP_SDMA, log_name, sdma_reg_log, (void *)&pc_op); + if (ret) + HIKP_ERROR_PRINT("%s failed: %d\n", pc_op.func_name, ret); + usleep(SDMA_DUMP_DELAY); + + vc_op.sdma_die = i; + memset(log_name, 0, MAX_LOG_NAME_LEN); + (void)snprintf(log_name, MAX_LOG_NAME_LEN, "sdma%u_vc_dump", i); + + ret = hikp_collect_log(GROUP_SDMA, log_name, sdma_reg_log, (void *)&vc_op); + if (ret) + HIKP_ERROR_PRINT("%s failed: %d\n", vc_op.func_name, ret); + usleep(SDMA_DUMP_DELAY); + } +} + +void collect_sdma_log(void) +{ + collect_sdma_kernel_log(); + collect_sdma_debugfs_log(); + collect_sdma_reg_log(); +} -- Gitee From f514f77d4f8800367f19c15397aaeb10ef413dfe Mon Sep 17 00:00:00 2001 From: veega2022 Date: Fri, 14 Mar 2025 20:41:11 +0800 Subject: [PATCH 9/9] hikptool: Update the tool version number to 1.1.4 Update the tool version number to 1.1.4 Signed-off-by: veega2022 --- tool_lib/tool_lib.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tool_lib/tool_lib.h b/tool_lib/tool_lib.h index 24b1fbb..d4493d7 100644 --- a/tool_lib/tool_lib.h +++ b/tool_lib/tool_lib.h @@ -18,7 +18,7 @@ #define TOOL_NAME "hikptool" -#define TOOL_VER "1.1.3" +#define TOOL_VER "1.1.4" #define HI_GET_BITFIELD(value, start, mask) (((value) >> (start)) & (mask)) #define HI_SET_FIELD(origin, shift, val) ((origin) |= (val) << (shift)) -- Gitee