korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-09-21 20:22:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'devlink-errors-fmsg'

Browse Source 
Przemek Kitszel says:

====================
devlink: retain error in struct devlink_fmsg

Extend devlink fmsg to retain error (patch 1),
so drivers could omit error checks after devlink_fmsg_*() (patches 2-10),
and finally enforce future uses to follow this practice by change to
return void (patch 11)

Note that it was compile tested only.

bloat-o-meter for whole series:
add/remove: 8/18 grow/shrink: 23/40 up/down: 2017/-5833 (-3816)
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2023-10-20 11:34:51 +01:00
commit a10f9bfe93
19 changed files with 816 additions and 2053 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
drivers/net/ethernet/amd/pds_core/devlink.c
View File

@ -154,33 +154,20 @@ int pdsc_fw_reporter_diagnose(struct devlink_health_reporter *reporter,
struct netlink_ext_ack *extack)
{
struct pdsc *pdsc = devlink_health_reporter_priv(reporter);
int err;
mutex_lock(&pdsc->config_lock);
if (test_bit(PDSC_S_FW_DEAD, &pdsc->state))
err = devlink_fmsg_string_pair_put(fmsg, "Status", "dead");
devlink_fmsg_string_pair_put(fmsg, "Status", "dead");
else if (!pdsc_is_fw_good(pdsc))
err = devlink_fmsg_string_pair_put(fmsg, "Status", "unhealthy");
devlink_fmsg_string_pair_put(fmsg, "Status", "unhealthy");
else
err = devlink_fmsg_string_pair_put(fmsg, "Status", "healthy");
devlink_fmsg_string_pair_put(fmsg, "Status", "healthy");
mutex_unlock(&pdsc->config_lock);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "State",
pdsc->fw_status & ~PDS_CORE_FW_STS_F_GENERATION);
devlink_fmsg_u32_pair_put(fmsg, "Generation", pdsc->fw_generation >> 4);
devlink_fmsg_u32_pair_put(fmsg, "Recoveries", pdsc->fw_recoveries);
err = devlink_fmsg_u32_pair_put(fmsg, "State",
pdsc->fw_status &
~PDS_CORE_FW_STS_F_GENERATION);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "Generation",
pdsc->fw_generation >> 4);
if (err)
return err;
return devlink_fmsg_u32_pair_put(fmsg, "Recoveries",
pdsc->fw_recoveries);
return 0;
}

93
drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c
View File

@ -104,20 +104,21 @@ static int bnxt_fw_diagnose(struct devlink_health_reporter *reporter,
struct bnxt *bp = devlink_health_reporter_priv(reporter);
struct bnxt_fw_health *h = bp->fw_health;
u32 fw_status, fw_resets;
int rc;
if (test_bit(BNXT_STATE_IN_FW_RESET, &bp->state))
return devlink_fmsg_string_pair_put(fmsg, "Status", "recovering");
if (test_bit(BNXT_STATE_IN_FW_RESET, &bp->state)) {
devlink_fmsg_string_pair_put(fmsg, "Status", "recovering");
return 0;
}
if (!h->status_reliable)
return devlink_fmsg_string_pair_put(fmsg, "Status", "unknown");
if (!h->status_reliable) {
devlink_fmsg_string_pair_put(fmsg, "Status", "unknown");
return 0;
}
mutex_lock(&h->lock);
fw_status = bnxt_fw_health_readl(bp, BNXT_FW_HEALTH_REG);
if (BNXT_FW_IS_BOOTING(fw_status)) {
rc = devlink_fmsg_string_pair_put(fmsg, "Status", "initializing");
if (rc)
goto unlock;
devlink_fmsg_string_pair_put(fmsg, "Status", "initializing");
} else if (h->severity || fw_status != BNXT_FW_STATUS_HEALTHY) {
if (!h->severity) {
h->severity = SEVERITY_FATAL;
@ -126,58 +127,35 @@ static int bnxt_fw_diagnose(struct devlink_health_reporter *reporter,
devlink_health_report(h->fw_reporter,
"FW error diagnosed", h);
}
rc = devlink_fmsg_string_pair_put(fmsg, "Status", "error");
if (rc)
goto unlock;
rc = devlink_fmsg_u32_pair_put(fmsg, "Syndrome", fw_status);
if (rc)
goto unlock;
devlink_fmsg_string_pair_put(fmsg, "Status", "error");
devlink_fmsg_u32_pair_put(fmsg, "Syndrome", fw_status);
} else {
rc = devlink_fmsg_string_pair_put(fmsg, "Status", "healthy");
if (rc)
goto unlock;
devlink_fmsg_string_pair_put(fmsg, "Status", "healthy");
}
rc = devlink_fmsg_string_pair_put(fmsg, "Severity",
bnxt_health_severity_str(h->severity));
if (rc)
goto unlock;
devlink_fmsg_string_pair_put(fmsg, "Severity",
bnxt_health_severity_str(h->severity));
if (h->severity) {
rc = devlink_fmsg_string_pair_put(fmsg, "Remedy",
bnxt_health_remedy_str(h->remedy));
if (rc)
goto unlock;
if (h->remedy == REMEDY_DEVLINK_RECOVER) {
rc = devlink_fmsg_string_pair_put(fmsg, "Impact",
"traffic+ntuple_cfg");
if (rc)
goto unlock;
}
devlink_fmsg_string_pair_put(fmsg, "Remedy",
bnxt_health_remedy_str(h->remedy));
if (h->remedy == REMEDY_DEVLINK_RECOVER)
devlink_fmsg_string_pair_put(fmsg, "Impact",
"traffic+ntuple_cfg");
}
unlock:
mutex_unlock(&h->lock);
if (rc || !h->resets_reliable)
return rc;
if (!h->resets_reliable)
return 0;
fw_resets = bnxt_fw_health_readl(bp, BNXT_FW_RESET_CNT_REG);
rc = devlink_fmsg_u32_pair_put(fmsg, "Resets", fw_resets);
if (rc)
return rc;
rc = devlink_fmsg_u32_pair_put(fmsg, "Arrests", h->arrests);
if (rc)
return rc;
rc = devlink_fmsg_u32_pair_put(fmsg, "Survivals", h->survivals);
if (rc)
return rc;
rc = devlink_fmsg_u32_pair_put(fmsg, "Discoveries", h->discoveries);
if (rc)
return rc;
rc = devlink_fmsg_u32_pair_put(fmsg, "Fatalities", h->fatalities);
if (rc)
return rc;
return devlink_fmsg_u32_pair_put(fmsg, "Diagnoses", h->diagnoses);
devlink_fmsg_u32_pair_put(fmsg, "Resets", fw_resets);
devlink_fmsg_u32_pair_put(fmsg, "Arrests", h->arrests);
devlink_fmsg_u32_pair_put(fmsg, "Survivals", h->survivals);
devlink_fmsg_u32_pair_put(fmsg, "Discoveries", h->discoveries);
devlink_fmsg_u32_pair_put(fmsg, "Fatalities", h->fatalities);
devlink_fmsg_u32_pair_put(fmsg, "Diagnoses", h->diagnoses);
return 0;
}
static int bnxt_fw_dump(struct devlink_health_reporter *reporter,
@ -203,19 +181,12 @@ static int bnxt_fw_dump(struct devlink_health_reporter *reporter,
rc = bnxt_get_coredump(bp, BNXT_DUMP_LIVE, data, &dump_len);
if (!rc) {
rc = devlink_fmsg_pair_nest_start(fmsg, "core");
if (rc)
goto exit;
rc = devlink_fmsg_binary_pair_put(fmsg, "data", data, dump_len);
if (rc)
goto exit;
rc = devlink_fmsg_u32_pair_put(fmsg, "size", dump_len);
if (rc)
goto exit;
rc = devlink_fmsg_pair_nest_end(fmsg);
devlink_fmsg_pair_nest_start(fmsg, "core");
devlink_fmsg_binary_pair_put(fmsg, "data", data, dump_len);
devlink_fmsg_u32_pair_put(fmsg, "size", dump_len);
devlink_fmsg_pair_nest_end(fmsg);
}
exit:
vfree(data);
return rc;
}

217
drivers/net/ethernet/huawei/hinic/hinic_devlink.c
View File

@ -315,136 +315,76 @@ void hinic_devlink_unregister(struct hinic_devlink_priv *priv)
devlink_unregister(devlink);
}
static int chip_fault_show(struct devlink_fmsg *fmsg,
struct hinic_fault_event *event)
static void chip_fault_show(struct devlink_fmsg *fmsg,
struct hinic_fault_event *event)
{
const char * const level_str[FAULT_LEVEL_MAX + 1] = {
"fatal", "reset", "flr", "general", "suggestion", "Unknown"};
u8 fault_level;
int err;
fault_level = (event->event.chip.err_level < FAULT_LEVEL_MAX) ?
event->event.chip.err_level : FAULT_LEVEL_MAX;
if (fault_level == FAULT_LEVEL_SERIOUS_FLR) {
err = devlink_fmsg_u32_pair_put(fmsg, "Function level err func_id",
(u32)event->event.chip.func_id);
if (err)
return err;
}
err = devlink_fmsg_u8_pair_put(fmsg, "module_id", event->event.chip.node_id);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "err_type", (u32)event->event.chip.err_type);
if (err)
return err;
err = devlink_fmsg_string_pair_put(fmsg, "err_level", level_str[fault_level]);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_addr",
event->event.chip.err_csr_addr);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_value",
event->event.chip.err_csr_value);
if (err)
return err;
return 0;
if (fault_level == FAULT_LEVEL_SERIOUS_FLR)
devlink_fmsg_u32_pair_put(fmsg, "Function level err func_id",
(u32)event->event.chip.func_id);
devlink_fmsg_u8_pair_put(fmsg, "module_id", event->event.chip.node_id);
devlink_fmsg_u32_pair_put(fmsg, "err_type", (u32)event->event.chip.err_type);
devlink_fmsg_string_pair_put(fmsg, "err_level", level_str[fault_level]);
devlink_fmsg_u32_pair_put(fmsg, "err_csr_addr",
event->event.chip.err_csr_addr);
devlink_fmsg_u32_pair_put(fmsg, "err_csr_value",
event->event.chip.err_csr_value);
}
static int fault_report_show(struct devlink_fmsg *fmsg,
struct hinic_fault_event *event)
static void fault_report_show(struct devlink_fmsg *fmsg,
struct hinic_fault_event *event)
{
const char * const type_str[FAULT_TYPE_MAX + 1] = {
"chip", "ucode", "mem rd timeout", "mem wr timeout",
"reg rd timeout", "reg wr timeout", "phy fault", "Unknown"};
u8 fault_type;
int err;
fault_type = (event->type < FAULT_TYPE_MAX) ? event->type : FAULT_TYPE_MAX;
err = devlink_fmsg_string_pair_put(fmsg, "Fault type", type_str[fault_type]);
if (err)
return err;
err = devlink_fmsg_binary_pair_put(fmsg, "Fault raw data",
event->event.val, sizeof(event->event.val));
if (err)
return err;
devlink_fmsg_string_pair_put(fmsg, "Fault type", type_str[fault_type]);
devlink_fmsg_binary_pair_put(fmsg, "Fault raw data", event->event.val,
sizeof(event->event.val));
switch (event->type) {
case FAULT_TYPE_CHIP:
err = chip_fault_show(fmsg, event);
if (err)
return err;
chip_fault_show(fmsg, event);
break;
case FAULT_TYPE_UCODE:
err = devlink_fmsg_u8_pair_put(fmsg, "Cause_id", event->event.ucode.cause_id);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "core_id", event->event.ucode.core_id);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "c_id", event->event.ucode.c_id);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "epc", event->event.ucode.epc);
if (err)
return err;
devlink_fmsg_u8_pair_put(fmsg, "Cause_id", event->event.ucode.cause_id);
devlink_fmsg_u8_pair_put(fmsg, "core_id", event->event.ucode.core_id);
devlink_fmsg_u8_pair_put(fmsg, "c_id", event->event.ucode.c_id);
devlink_fmsg_u8_pair_put(fmsg, "epc", event->event.ucode.epc);
break;
case FAULT_TYPE_MEM_RD_TIMEOUT:
case FAULT_TYPE_MEM_WR_TIMEOUT:
err = devlink_fmsg_u32_pair_put(fmsg, "Err_csr_ctrl",
event->event.mem_timeout.err_csr_ctrl);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_data",
event->event.mem_timeout.err_csr_data);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "ctrl_tab",
event->event.mem_timeout.ctrl_tab);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "mem_index",
event->event.mem_timeout.mem_index);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "Err_csr_ctrl",
event->event.mem_timeout.err_csr_ctrl);
devlink_fmsg_u32_pair_put(fmsg, "err_csr_data",
event->event.mem_timeout.err_csr_data);
devlink_fmsg_u32_pair_put(fmsg, "ctrl_tab",
event->event.mem_timeout.ctrl_tab);
devlink_fmsg_u32_pair_put(fmsg, "mem_index",
event->event.mem_timeout.mem_index);
break;
case FAULT_TYPE_REG_RD_TIMEOUT:
case FAULT_TYPE_REG_WR_TIMEOUT:
err = devlink_fmsg_u32_pair_put(fmsg, "Err_csr", event->event.reg_timeout.err_csr);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "Err_csr", event->event.reg_timeout.err_csr);
break;
case FAULT_TYPE_PHY_FAULT:
err = devlink_fmsg_u8_pair_put(fmsg, "Op_type", event->event.phy_fault.op_type);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "port_id", event->event.phy_fault.port_id);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "dev_ad", event->event.phy_fault.dev_ad);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "csr_addr", event->event.phy_fault.csr_addr);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "op_data", event->event.phy_fault.op_data);
if (err)
return err;
devlink_fmsg_u8_pair_put(fmsg, "Op_type", event->event.phy_fault.op_type);
devlink_fmsg_u8_pair_put(fmsg, "port_id", event->event.phy_fault.port_id);
devlink_fmsg_u8_pair_put(fmsg, "dev_ad", event->event.phy_fault.dev_ad);
devlink_fmsg_u32_pair_put(fmsg, "csr_addr", event->event.phy_fault.csr_addr);
devlink_fmsg_u32_pair_put(fmsg, "op_data", event->event.phy_fault.op_data);
break;
default:
break;
}
return 0;
}
static int hinic_hw_reporter_dump(struct devlink_health_reporter *reporter,
@ -452,75 +392,30 @@ static int hinic_hw_reporter_dump(struct devlink_health_reporter *reporter,
struct netlink_ext_ack *extack)
{
if (priv_ctx)
return fault_report_show(fmsg, priv_ctx);
fault_report_show(fmsg, priv_ctx);
return 0;
}
static int mgmt_watchdog_report_show(struct devlink_fmsg *fmsg,
struct hinic_mgmt_watchdog_info *watchdog_info)
static void mgmt_watchdog_report_show(struct devlink_fmsg *fmsg,
struct hinic_mgmt_watchdog_info *winfo)
{
int err;
err = devlink_fmsg_u32_pair_put(fmsg, "Mgmt deadloop time_h", watchdog_info->curr_time_h);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "time_l", watchdog_info->curr_time_l);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "task_id", watchdog_info->task_id);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "sp", watchdog_info->sp);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "stack_current_used", watchdog_info->curr_used);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "peak_used", watchdog_info->peak_used);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "\n Overflow_flag", watchdog_info->is_overflow);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "stack_top", watchdog_info->stack_top);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "stack_bottom", watchdog_info->stack_bottom);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "mgmt_pc", watchdog_info->pc);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "lr", watchdog_info->lr);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "cpsr", watchdog_info->cpsr);
if (err)
return err;
err = devlink_fmsg_binary_pair_put(fmsg, "Mgmt register info",
watchdog_info->reg, sizeof(watchdog_info->reg));
if (err)
return err;
err = devlink_fmsg_binary_pair_put(fmsg, "Mgmt dump stack(start from sp)",
watchdog_info->data, sizeof(watchdog_info->data));
if (err)
return err;
return 0;
devlink_fmsg_u32_pair_put(fmsg, "Mgmt deadloop time_h", winfo->curr_time_h);
devlink_fmsg_u32_pair_put(fmsg, "time_l", winfo->curr_time_l);
devlink_fmsg_u32_pair_put(fmsg, "task_id", winfo->task_id);
devlink_fmsg_u32_pair_put(fmsg, "sp", winfo->sp);
devlink_fmsg_u32_pair_put(fmsg, "stack_current_used", winfo->curr_used);
devlink_fmsg_u32_pair_put(fmsg, "peak_used", winfo->peak_used);
devlink_fmsg_u32_pair_put(fmsg, "\n Overflow_flag", winfo->is_overflow);
devlink_fmsg_u32_pair_put(fmsg, "stack_top", winfo->stack_top);
devlink_fmsg_u32_pair_put(fmsg, "stack_bottom", winfo->stack_bottom);
devlink_fmsg_u32_pair_put(fmsg, "mgmt_pc", winfo->pc);
devlink_fmsg_u32_pair_put(fmsg, "lr", winfo->lr);
devlink_fmsg_u32_pair_put(fmsg, "cpsr", winfo->cpsr);
devlink_fmsg_binary_pair_put(fmsg, "Mgmt register info", winfo->reg,
sizeof(winfo->reg));
devlink_fmsg_binary_pair_put(fmsg, "Mgmt dump stack(start from sp)",
winfo->data, sizeof(winfo->data));
}
static int hinic_fw_reporter_dump(struct devlink_health_reporter *reporter,
@ -528,7 +423,7 @@ static int hinic_fw_reporter_dump(struct devlink_health_reporter *reporter,
struct netlink_ext_ack *extack)
{
if (priv_ctx)
return mgmt_watchdog_report_show(fmsg, priv_ctx);
mgmt_watchdog_report_show(fmsg, priv_ctx);
return 0;
}

464
drivers/net/ethernet/marvell/octeontx2/af/rvu_devlink.c
View File

@ -14,26 +14,16 @@
#define DRV_NAME "octeontx2-af"
static int rvu_report_pair_start(struct devlink_fmsg *fmsg, const char *name)
static void rvu_report_pair_start(struct devlink_fmsg *fmsg, const char *name)
{
int err;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
return devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_obj_nest_start(fmsg);
}
static int rvu_report_pair_end(struct devlink_fmsg *fmsg)
static void rvu_report_pair_end(struct devlink_fmsg *fmsg)
{
int err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
return devlink_fmsg_pair_nest_end(fmsg);
devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_pair_nest_end(fmsg);
}
static bool rvu_common_request_irq(struct rvu *rvu, int offset,
@ -284,175 +274,81 @@ static int rvu_nix_report_show(struct devlink_fmsg *fmsg, void *ctx,
{
struct rvu_nix_event_ctx *nix_event_context;
u64 intr_val;
int err;
nix_event_context = ctx;
switch (health_reporter) {
case NIX_AF_RVU_INTR:
intr_val = nix_event_context->nix_af_rvu_int;
err = rvu_report_pair_start(fmsg, "NIX_AF_RVU");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX RVU Interrupt Reg ",
nix_event_context->nix_af_rvu_int);
if (err)
return err;
if (intr_val & BIT_ULL(0)) {
err = devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
if (err)
return err;
}
err = rvu_report_pair_end(fmsg);
if (err)
return err;
rvu_report_pair_start(fmsg, "NIX_AF_RVU");
devlink_fmsg_u64_pair_put(fmsg, "\tNIX RVU Interrupt Reg ",
nix_event_context->nix_af_rvu_int);
if (intr_val & BIT_ULL(0))
devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
rvu_report_pair_end(fmsg);
break;
case NIX_AF_RVU_GEN:
intr_val = nix_event_context->nix_af_rvu_gen;
err = rvu_report_pair_start(fmsg, "NIX_AF_GENERAL");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX General Interrupt Reg ",
nix_event_context->nix_af_rvu_gen);
if (err)
return err;
if (intr_val & BIT_ULL(0)) {
err = devlink_fmsg_string_put(fmsg, "\n\tRx multicast pkt drop");
if (err)
return err;
}
if (intr_val & BIT_ULL(1)) {
err = devlink_fmsg_string_put(fmsg, "\n\tRx mirror pkt drop");
if (err)
return err;
}
if (intr_val & BIT_ULL(4)) {
err = devlink_fmsg_string_put(fmsg, "\n\tSMQ flush done");
if (err)
return err;
}
err = rvu_report_pair_end(fmsg);
if (err)
return err;
rvu_report_pair_start(fmsg, "NIX_AF_GENERAL");
devlink_fmsg_u64_pair_put(fmsg, "\tNIX General Interrupt Reg ",
nix_event_context->nix_af_rvu_gen);
if (intr_val & BIT_ULL(0))
devlink_fmsg_string_put(fmsg, "\n\tRx multicast pkt drop");
if (intr_val & BIT_ULL(1))
devlink_fmsg_string_put(fmsg, "\n\tRx mirror pkt drop");
if (intr_val & BIT_ULL(4))
devlink_fmsg_string_put(fmsg, "\n\tSMQ flush done");
rvu_report_pair_end(fmsg);
break;
case NIX_AF_RVU_ERR:
intr_val = nix_event_context->nix_af_rvu_err;
err = rvu_report_pair_start(fmsg, "NIX_AF_ERR");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX Error Interrupt Reg ",
nix_event_context->nix_af_rvu_err);
if (err)
return err;
if (intr_val & BIT_ULL(14)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_INST_S read");
if (err)
return err;
}
if (intr_val & BIT_ULL(13)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_RES_S write");
if (err)
return err;
}
if (intr_val & BIT_ULL(12)) {
err = devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
if (err)
return err;
}
if (intr_val & BIT_ULL(6)) {
err = devlink_fmsg_string_put(fmsg, "\n\tRx on unmapped PF_FUNC");
if (err)
return err;
}
if (intr_val & BIT_ULL(5)) {
err = devlink_fmsg_string_put(fmsg, "\n\tRx multicast replication error");
if (err)
return err;
}
if (intr_val & BIT_ULL(4)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_RX_MCE_S read");
if (err)
return err;
}
if (intr_val & BIT_ULL(3)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on multicast WQE read");
if (err)
return err;
}
if (intr_val & BIT_ULL(2)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on mirror WQE read");
if (err)
return err;
}
if (intr_val & BIT_ULL(1)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on mirror pkt write");
if (err)
return err;
}
if (intr_val & BIT_ULL(0)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on multicast pkt write");
if (err)
return err;
}
err = rvu_report_pair_end(fmsg);
if (err)
return err;
rvu_report_pair_start(fmsg, "NIX_AF_ERR");
devlink_fmsg_u64_pair_put(fmsg, "\tNIX Error Interrupt Reg ",
nix_event_context->nix_af_rvu_err);
if (intr_val & BIT_ULL(14))
devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_INST_S read");
if (intr_val & BIT_ULL(13))
devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_AQ_RES_S write");
if (intr_val & BIT_ULL(12))
devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
if (intr_val & BIT_ULL(6))
devlink_fmsg_string_put(fmsg, "\n\tRx on unmapped PF_FUNC");
if (intr_val & BIT_ULL(5))
devlink_fmsg_string_put(fmsg, "\n\tRx multicast replication error");
if (intr_val & BIT_ULL(4))
devlink_fmsg_string_put(fmsg, "\n\tFault on NIX_RX_MCE_S read");
if (intr_val & BIT_ULL(3))
devlink_fmsg_string_put(fmsg, "\n\tFault on multicast WQE read");
if (intr_val & BIT_ULL(2))
devlink_fmsg_string_put(fmsg, "\n\tFault on mirror WQE read");
if (intr_val & BIT_ULL(1))
devlink_fmsg_string_put(fmsg, "\n\tFault on mirror pkt write");
if (intr_val & BIT_ULL(0))
devlink_fmsg_string_put(fmsg, "\n\tFault on multicast pkt write");
rvu_report_pair_end(fmsg);
break;
case NIX_AF_RVU_RAS:
intr_val = nix_event_context->nix_af_rvu_err;
err = rvu_report_pair_start(fmsg, "NIX_AF_RAS");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNIX RAS Interrupt Reg ",
nix_event_context->nix_af_rvu_err);
if (err)
return err;
err = devlink_fmsg_string_put(fmsg, "\n\tPoison Data on:");
if (err)
return err;
if (intr_val & BIT_ULL(34)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_INST_S");
if (err)
return err;
}
if (intr_val & BIT_ULL(33)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_RES_S");
if (err)
return err;
}
if (intr_val & BIT_ULL(32)) {
err = devlink_fmsg_string_put(fmsg, "\n\tHW ctx");
if (err)
return err;
}
if (intr_val & BIT_ULL(4)) {
err = devlink_fmsg_string_put(fmsg, "\n\tPacket from mirror buffer");
if (err)
return err;
}
if (intr_val & BIT_ULL(3)) {
err = devlink_fmsg_string_put(fmsg, "\n\tPacket from multicast buffer");
if (err)
return err;
}
if (intr_val & BIT_ULL(2)) {
err = devlink_fmsg_string_put(fmsg, "\n\tWQE read from mirror buffer");
if (err)
return err;
}
if (intr_val & BIT_ULL(1)) {
err = devlink_fmsg_string_put(fmsg, "\n\tWQE read from multicast buffer");
if (err)
return err;
}
if (intr_val & BIT_ULL(0)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX_RX_MCE_S read");
if (err)
return err;
}
err = rvu_report_pair_end(fmsg);
if (err)
return err;
rvu_report_pair_start(fmsg, "NIX_AF_RAS");
devlink_fmsg_u64_pair_put(fmsg, "\tNIX RAS Interrupt Reg ",
nix_event_context->nix_af_rvu_err);
devlink_fmsg_string_put(fmsg, "\n\tPoison Data on:");
if (intr_val & BIT_ULL(34))
devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_INST_S");
if (intr_val & BIT_ULL(33))
devlink_fmsg_string_put(fmsg, "\n\tNIX_AQ_RES_S");
if (intr_val & BIT_ULL(32))
devlink_fmsg_string_put(fmsg, "\n\tHW ctx");
if (intr_val & BIT_ULL(4))
devlink_fmsg_string_put(fmsg, "\n\tPacket from mirror buffer");
if (intr_val & BIT_ULL(3))
devlink_fmsg_string_put(fmsg, "\n\tPacket from multicast buffer");
if (intr_val & BIT_ULL(2))
devlink_fmsg_string_put(fmsg, "\n\tWQE read from mirror buffer");
if (intr_val & BIT_ULL(1))
devlink_fmsg_string_put(fmsg, "\n\tWQE read from multicast buffer");
if (intr_val & BIT_ULL(0))
devlink_fmsg_string_put(fmsg, "\n\tNIX_RX_MCE_S read");
rvu_report_pair_end(fmsg);
break;
default:
return -EINVAL;
@ -922,181 +818,87 @@ static int rvu_npa_report_show(struct devlink_fmsg *fmsg, void *ctx,
struct rvu_npa_event_ctx *npa_event_context;
unsigned int alloc_dis, free_dis;
u64 intr_val;
int err;
npa_event_context = ctx;
switch (health_reporter) {
case NPA_AF_RVU_GEN:
intr_val = npa_event_context->npa_af_rvu_gen;
err = rvu_report_pair_start(fmsg, "NPA_AF_GENERAL");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA General Interrupt Reg ",
npa_event_context->npa_af_rvu_gen);
if (err)
return err;
if (intr_val & BIT_ULL(32)) {
err = devlink_fmsg_string_put(fmsg, "\n\tUnmap PF Error");
if (err)
return err;
}
rvu_report_pair_start(fmsg, "NPA_AF_GENERAL");
devlink_fmsg_u64_pair_put(fmsg, "\tNPA General Interrupt Reg ",
npa_event_context->npa_af_rvu_gen);
if (intr_val & BIT_ULL(32))
devlink_fmsg_string_put(fmsg, "\n\tUnmap PF Error");
free_dis = FIELD_GET(GENMASK(15, 0), intr_val);
if (free_dis & BIT(NPA_INPQ_NIX0_RX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX0: free disabled RX");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_NIX0_TX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX0:free disabled TX");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_NIX1_RX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX1: free disabled RX");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_NIX1_TX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX1:free disabled TX");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_SSO)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for SSO");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_TIM)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for TIM");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_DPI)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for DPI");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_AURA_OP)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for AURA");
if (err)
return err;
}
if (free_dis & BIT(NPA_INPQ_NIX0_RX))
devlink_fmsg_string_put(fmsg, "\n\tNIX0: free disabled RX");
if (free_dis & BIT(NPA_INPQ_NIX0_TX))
devlink_fmsg_string_put(fmsg, "\n\tNIX0:free disabled TX");
if (free_dis & BIT(NPA_INPQ_NIX1_RX))
devlink_fmsg_string_put(fmsg, "\n\tNIX1: free disabled RX");
if (free_dis & BIT(NPA_INPQ_NIX1_TX))
devlink_fmsg_string_put(fmsg, "\n\tNIX1:free disabled TX");
if (free_dis & BIT(NPA_INPQ_SSO))
devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for SSO");
if (free_dis & BIT(NPA_INPQ_TIM))
devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for TIM");
if (free_dis & BIT(NPA_INPQ_DPI))
devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for DPI");
if (free_dis & BIT(NPA_INPQ_AURA_OP))
devlink_fmsg_string_put(fmsg, "\n\tFree Disabled for AURA");
alloc_dis = FIELD_GET(GENMASK(31, 16), intr_val);
if (alloc_dis & BIT(NPA_INPQ_NIX0_RX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX0: alloc disabled RX");
if (err)
return err;
}
if (alloc_dis & BIT(NPA_INPQ_NIX0_TX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX0:alloc disabled TX");
if (err)
return err;
}
if (alloc_dis & BIT(NPA_INPQ_NIX1_RX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX1: alloc disabled RX");
if (err)
return err;
}
if (alloc_dis & BIT(NPA_INPQ_NIX1_TX)) {
err = devlink_fmsg_string_put(fmsg, "\n\tNIX1:alloc disabled TX");
if (err)
return err;
}
if (alloc_dis & BIT(NPA_INPQ_SSO)) {
err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for SSO");
if (err)
return err;
}
if (alloc_dis & BIT(NPA_INPQ_TIM)) {
err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for TIM");
if (err)
return err;
}
if (alloc_dis & BIT(NPA_INPQ_DPI)) {
err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for DPI");
if (err)
return err;
}
if (alloc_dis & BIT(NPA_INPQ_AURA_OP)) {
err = devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for AURA");
if (err)
return err;
}
err = rvu_report_pair_end(fmsg);
if (err)
return err;
if (alloc_dis & BIT(NPA_INPQ_NIX0_RX))
devlink_fmsg_string_put(fmsg, "\n\tNIX0: alloc disabled RX");
if (alloc_dis & BIT(NPA_INPQ_NIX0_TX))
devlink_fmsg_string_put(fmsg, "\n\tNIX0:alloc disabled TX");
if (alloc_dis & BIT(NPA_INPQ_NIX1_RX))
devlink_fmsg_string_put(fmsg, "\n\tNIX1: alloc disabled RX");
if (alloc_dis & BIT(NPA_INPQ_NIX1_TX))
devlink_fmsg_string_put(fmsg, "\n\tNIX1:alloc disabled TX");
if (alloc_dis & BIT(NPA_INPQ_SSO))
devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for SSO");
if (alloc_dis & BIT(NPA_INPQ_TIM))
devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for TIM");
if (alloc_dis & BIT(NPA_INPQ_DPI))
devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for DPI");
if (alloc_dis & BIT(NPA_INPQ_AURA_OP))
devlink_fmsg_string_put(fmsg, "\n\tAlloc Disabled for AURA");
rvu_report_pair_end(fmsg);
break;
case NPA_AF_RVU_ERR:
err = rvu_report_pair_start(fmsg, "NPA_AF_ERR");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA Error Interrupt Reg ",
npa_event_context->npa_af_rvu_err);
if (err)
return err;
if (npa_event_context->npa_af_rvu_err & BIT_ULL(14)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_INST_S read");
if (err)
return err;
}
if (npa_event_context->npa_af_rvu_err & BIT_ULL(13)) {
err = devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_RES_S write");
if (err)
return err;
}
if (npa_event_context->npa_af_rvu_err & BIT_ULL(12)) {
err = devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
if (err)
return err;
}
err = rvu_report_pair_end(fmsg);
if (err)
return err;
rvu_report_pair_start(fmsg, "NPA_AF_ERR");
devlink_fmsg_u64_pair_put(fmsg, "\tNPA Error Interrupt Reg ",
npa_event_context->npa_af_rvu_err);
if (npa_event_context->npa_af_rvu_err & BIT_ULL(14))
devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_INST_S read");
if (npa_event_context->npa_af_rvu_err & BIT_ULL(13))
devlink_fmsg_string_put(fmsg, "\n\tFault on NPA_AQ_RES_S write");
if (npa_event_context->npa_af_rvu_err & BIT_ULL(12))
devlink_fmsg_string_put(fmsg, "\n\tAQ Doorbell Error");
rvu_report_pair_end(fmsg);
break;
case NPA_AF_RVU_RAS:
err = rvu_report_pair_start(fmsg, "NPA_AF_RVU_RAS");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA RAS Interrupt Reg ",
npa_event_context->npa_af_rvu_ras);
if (err)
return err;
if (npa_event_context->npa_af_rvu_ras & BIT_ULL(34)) {
err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_INST_S");
if (err)
return err;
}
if (npa_event_context->npa_af_rvu_ras & BIT_ULL(33)) {
err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_RES_S");
if (err)
return err;
}
if (npa_event_context->npa_af_rvu_ras & BIT_ULL(32)) {
err = devlink_fmsg_string_put(fmsg, "\n\tPoison data on HW context");
if (err)
return err;
}
err = rvu_report_pair_end(fmsg);
if (err)
return err;
rvu_report_pair_start(fmsg, "NPA_AF_RVU_RAS");
devlink_fmsg_u64_pair_put(fmsg, "\tNPA RAS Interrupt Reg ",
npa_event_context->npa_af_rvu_ras);
if (npa_event_context->npa_af_rvu_ras & BIT_ULL(34))
devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_INST_S");
if (npa_event_context->npa_af_rvu_ras & BIT_ULL(33))
devlink_fmsg_string_put(fmsg, "\n\tPoison data on NPA_AQ_RES_S");
if (npa_event_context->npa_af_rvu_ras & BIT_ULL(32))
devlink_fmsg_string_put(fmsg, "\n\tPoison data on HW context");
rvu_report_pair_end(fmsg);
break;
case NPA_AF_RVU_INTR:
err = rvu_report_pair_start(fmsg, "NPA_AF_RVU");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "\tNPA RVU Interrupt Reg ",
npa_event_context->npa_af_rvu_int);
if (err)
return err;
if (npa_event_context->npa_af_rvu_int & BIT_ULL(0)) {
err = devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
if (err)
return err;
}
return rvu_report_pair_end(fmsg);
rvu_report_pair_start(fmsg, "NPA_AF_RVU");
devlink_fmsg_u64_pair_put(fmsg, "\tNPA RVU Interrupt Reg ",
npa_event_context->npa_af_rvu_int);
if (npa_event_context->npa_af_rvu_int & BIT_ULL(0))
devlink_fmsg_string_put(fmsg, "\n\tUnmap Slot Error");
rvu_report_pair_end(fmsg);
break;
default:
return -EINVAL;
}

49
drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c
View File

@ -889,36 +889,16 @@ int mlx5_fw_tracer_trigger_core_dump_general(struct mlx5_core_dev *dev)
return 0;
}
static int
static void
mlx5_devlink_fmsg_fill_trace(struct devlink_fmsg *fmsg,
struct mlx5_fw_trace_data *trace_data)
{
int err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "timestamp", trace_data->timestamp);
if (err)
return err;
err = devlink_fmsg_bool_pair_put(fmsg, "lost", trace_data->lost);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "event_id", trace_data->event_id);
if (err)
return err;
err = devlink_fmsg_string_pair_put(fmsg, "msg", trace_data->msg);
if (err)
return err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_u64_pair_put(fmsg, "timestamp", trace_data->timestamp);
devlink_fmsg_bool_pair_put(fmsg, "lost", trace_data->lost);
devlink_fmsg_u8_pair_put(fmsg, "event_id", trace_data->event_id);
devlink_fmsg_string_pair_put(fmsg, "msg", trace_data->msg);
devlink_fmsg_obj_nest_end(fmsg);
}
int mlx5_fw_tracer_get_saved_traces_objects(struct mlx5_fw_tracer *tracer,
@ -927,7 +907,6 @@ int mlx5_fw_tracer_get_saved_traces_objects(struct mlx5_fw_tracer *tracer,
struct mlx5_fw_trace_data *straces = tracer->st_arr.straces;
u32 index, start_index, end_index;
u32 saved_traces_index;
int err;
if (!straces[0].timestamp)
return -ENOMSG;
@ -940,22 +919,18 @@ int mlx5_fw_tracer_get_saved_traces_objects(struct mlx5_fw_tracer *tracer,
start_index = 0;
end_index = (saved_traces_index - 1) & (SAVED_TRACES_NUM - 1);
err = devlink_fmsg_arr_pair_nest_start(fmsg, "dump fw traces");
if (err)
goto unlock;
devlink_fmsg_arr_pair_nest_start(fmsg, "dump fw traces");
index = start_index;
while (index != end_index) {
err = mlx5_devlink_fmsg_fill_trace(fmsg, &straces[index]);
if (err)
goto unlock;
mlx5_devlink_fmsg_fill_trace(fmsg, &straces[index]);
index = (index + 1) & (SAVED_TRACES_NUM - 1);
}
err = devlink_fmsg_arr_pair_nest_end(fmsg);
unlock:
devlink_fmsg_arr_pair_nest_end(fmsg);
mutex_unlock(&tracer->st_arr.lock);
return err;
return 0;
}
static void mlx5_fw_tracer_update_db(struct work_struct *work)

118
drivers/net/ethernet/mellanox/mlx5/core/diag/reporter_vnic.c
View File

@ -13,106 +13,55 @@ struct mlx5_vnic_diag_stats {
__be64 query_vnic_env_out[MLX5_ST_SZ_QW(query_vnic_env_out)];
};
int mlx5_reporter_vnic_diagnose_counters(struct mlx5_core_dev *dev,
struct devlink_fmsg *fmsg,
u16 vport_num, bool other_vport)
void mlx5_reporter_vnic_diagnose_counters(struct mlx5_core_dev *dev,
struct devlink_fmsg *fmsg,
u16 vport_num, bool other_vport)
{
u32 in[MLX5_ST_SZ_DW(query_vnic_env_in)] = {};
struct mlx5_vnic_diag_stats vnic;
int err;
MLX5_SET(query_vnic_env_in, in, opcode, MLX5_CMD_OP_QUERY_VNIC_ENV);
MLX5_SET(query_vnic_env_in, in, vport_number, vport_num);
MLX5_SET(query_vnic_env_in, in, other_vport, !!other_vport);
err = mlx5_cmd_exec_inout(dev, query_vnic_env, in, &vnic.query_vnic_env_out);
if (err)
return err;
mlx5_cmd_exec_inout(dev, query_vnic_env, in, &vnic.query_vnic_env_out);
err = devlink_fmsg_pair_nest_start(fmsg, "vNIC env counters");
if (err)
return err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
devlink_fmsg_pair_nest_start(fmsg, "vNIC env counters");
devlink_fmsg_obj_nest_start(fmsg);
if (MLX5_CAP_GEN(dev, vnic_env_queue_counters)) {
err = devlink_fmsg_u32_pair_put(fmsg, "total_error_queues",
VNIC_ENV_GET(&vnic, total_error_queues));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "send_queue_priority_update_flow",
VNIC_ENV_GET(&vnic,
send_queue_priority_update_flow));
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "total_error_queues",
VNIC_ENV_GET(&vnic, total_error_queues));
devlink_fmsg_u32_pair_put(fmsg, "send_queue_priority_update_flow",
VNIC_ENV_GET(&vnic, send_queue_priority_update_flow));
}
if (MLX5_CAP_GEN(dev, eq_overrun_count)) {
err = devlink_fmsg_u32_pair_put(fmsg, "comp_eq_overrun",
VNIC_ENV_GET(&vnic, comp_eq_overrun));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "async_eq_overrun",
VNIC_ENV_GET(&vnic, async_eq_overrun));
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "comp_eq_overrun",
VNIC_ENV_GET(&vnic, comp_eq_overrun));
devlink_fmsg_u32_pair_put(fmsg, "async_eq_overrun",
VNIC_ENV_GET(&vnic, async_eq_overrun));
}
if (MLX5_CAP_GEN(dev, vnic_env_cq_overrun)) {
err = devlink_fmsg_u32_pair_put(fmsg, "cq_overrun",
VNIC_ENV_GET(&vnic, cq_overrun));
if (err)
return err;
}
if (MLX5_CAP_GEN(dev, invalid_command_count)) {
err = devlink_fmsg_u32_pair_put(fmsg, "invalid_command",
VNIC_ENV_GET(&vnic, invalid_command));
if (err)
return err;
}
if (MLX5_CAP_GEN(dev, quota_exceeded_count)) {
err = devlink_fmsg_u32_pair_put(fmsg, "quota_exceeded_command",
VNIC_ENV_GET(&vnic, quota_exceeded_command));
if (err)
return err;
}
if (MLX5_CAP_GEN(dev, nic_receive_steering_discard)) {
err = devlink_fmsg_u64_pair_put(fmsg, "nic_receive_steering_discard",
VNIC_ENV_GET64(&vnic,
nic_receive_steering_discard));
if (err)
return err;
}
if (MLX5_CAP_GEN(dev, vnic_env_cq_overrun))
devlink_fmsg_u32_pair_put(fmsg, "cq_overrun",
VNIC_ENV_GET(&vnic, cq_overrun));
if (MLX5_CAP_GEN(dev, invalid_command_count))
devlink_fmsg_u32_pair_put(fmsg, "invalid_command",
VNIC_ENV_GET(&vnic, invalid_command));
if (MLX5_CAP_GEN(dev, quota_exceeded_count))
devlink_fmsg_u32_pair_put(fmsg, "quota_exceeded_command",
VNIC_ENV_GET(&vnic, quota_exceeded_command));
if (MLX5_CAP_GEN(dev, nic_receive_steering_discard))
devlink_fmsg_u64_pair_put(fmsg, "nic_receive_steering_discard",
VNIC_ENV_GET64(&vnic, nic_receive_steering_discard));
if (MLX5_CAP_GEN(dev, vnic_env_cnt_steering_fail)) {
err = devlink_fmsg_u64_pair_put(fmsg, "generated_pkt_steering_fail",
VNIC_ENV_GET64(&vnic,
generated_pkt_steering_fail));
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "handled_pkt_steering_fail",
VNIC_ENV_GET64(&vnic, handled_pkt_steering_fail));
if (err)
return err;
devlink_fmsg_u64_pair_put(fmsg, "generated_pkt_steering_fail",
VNIC_ENV_GET64(&vnic, generated_pkt_steering_fail));
devlink_fmsg_u64_pair_put(fmsg, "handled_pkt_steering_fail",
VNIC_ENV_GET64(&vnic, handled_pkt_steering_fail));
}
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_pair_nest_end(fmsg);
}
static int mlx5_reporter_vnic_diagnose(struct devlink_health_reporter *reporter,
@ -121,7 +70,8 @@ static int mlx5_reporter_vnic_diagnose(struct devlink_health_reporter *reporter,
{
struct mlx5_core_dev *dev = devlink_health_reporter_priv(reporter);
return mlx5_reporter_vnic_diagnose_counters(dev, fmsg, 0, false);
mlx5_reporter_vnic_diagnose_counters(dev, fmsg, 0, false);
return 0;
}
static const struct devlink_health_reporter_ops mlx5_reporter_vnic_ops = {

6
drivers/net/ethernet/mellanox/mlx5/core/diag/reporter_vnic.h
View File

@ -9,8 +9,8 @@
void mlx5_reporter_vnic_create(struct mlx5_core_dev *dev);
void mlx5_reporter_vnic_destroy(struct mlx5_core_dev *dev);
int mlx5_reporter_vnic_diagnose_counters(struct mlx5_core_dev *dev,
struct devlink_fmsg *fmsg,
u16 vport_num, bool other_vport);
void mlx5_reporter_vnic_diagnose_counters(struct mlx5_core_dev *dev,
struct devlink_fmsg *fmsg,
u16 vport_num, bool other_vport);
#endif /* __MLX5_REPORTER_VNIC_H */

187
drivers/net/ethernet/mellanox/mlx5/core/en/health.c
View File

@ -5,134 +5,59 @@
#include "lib/eq.h"
#include "lib/mlx5.h"
int mlx5e_health_fmsg_named_obj_nest_start(struct devlink_fmsg *fmsg, char *name)
void mlx5e_health_fmsg_named_obj_nest_start(struct devlink_fmsg *fmsg, char *name)
{
int err;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_obj_nest_start(fmsg);
}
int mlx5e_health_fmsg_named_obj_nest_end(struct devlink_fmsg *fmsg)
void mlx5e_health_fmsg_named_obj_nest_end(struct devlink_fmsg *fmsg)
{
int err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_pair_nest_end(fmsg);
}
int mlx5e_health_cq_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg)
void mlx5e_health_cq_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg)
{
u32 out[MLX5_ST_SZ_DW(query_cq_out)] = {};
u8 hw_status;
void *cqc;
int err;
err = mlx5_core_query_cq(cq->mdev, &cq->mcq, out);
if (err)
return err;
mlx5_core_query_cq(cq->mdev, &cq->mcq, out);
cqc = MLX5_ADDR_OF(query_cq_out, out, cq_context);
hw_status = MLX5_GET(cqc, cqc, status);
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ");
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "cqn", cq->mcq.cqn);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "HW status", hw_status);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "ci", mlx5_cqwq_get_ci(&cq->wq));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "size", mlx5_cqwq_get_size(&cq->wq));
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
return 0;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ");
devlink_fmsg_u32_pair_put(fmsg, "cqn", cq->mcq.cqn);
devlink_fmsg_u8_pair_put(fmsg, "HW status", hw_status);
devlink_fmsg_u32_pair_put(fmsg, "ci", mlx5_cqwq_get_ci(&cq->wq));
devlink_fmsg_u32_pair_put(fmsg, "size", mlx5_cqwq_get_size(&cq->wq));
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
int mlx5e_health_cq_common_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg)
void mlx5e_health_cq_common_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg)
{
u8 cq_log_stride;
u32 cq_sz;
int err;
cq_sz = mlx5_cqwq_get_size(&cq->wq);
cq_log_stride = mlx5_cqwq_get_log_stride_size(&cq->wq);
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ");
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "stride size", BIT(cq_log_stride));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "size", cq_sz);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
return 0;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ");
devlink_fmsg_u64_pair_put(fmsg, "stride size", BIT(cq_log_stride));
devlink_fmsg_u32_pair_put(fmsg, "size", cq_sz);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
int mlx5e_health_eq_diag_fmsg(struct mlx5_eq_comp *eq, struct devlink_fmsg *fmsg)
void mlx5e_health_eq_diag_fmsg(struct mlx5_eq_comp *eq, struct devlink_fmsg *fmsg)
{
int err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "EQ");
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "eqn", eq->core.eqn);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "irqn", eq->core.irqn);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "vecidx", eq->core.vecidx);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "ci", eq->core.cons_index);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "size", eq_get_size(&eq->core));
if (err)
return err;
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "EQ");
devlink_fmsg_u8_pair_put(fmsg, "eqn", eq->core.eqn);
devlink_fmsg_u32_pair_put(fmsg, "irqn", eq->core.irqn);
devlink_fmsg_u32_pair_put(fmsg, "vecidx", eq->core.vecidx);
devlink_fmsg_u32_pair_put(fmsg, "ci", eq->core.cons_index);
devlink_fmsg_u32_pair_put(fmsg, "size", eq_get_size(&eq->core));
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
void mlx5e_health_create_reporters(struct mlx5e_priv *priv)
@ -235,23 +160,19 @@ int mlx5e_health_report(struct mlx5e_priv *priv,
}
#define MLX5_HEALTH_DEVLINK_MAX_SIZE 1024
static int mlx5e_health_rsc_fmsg_binary(struct devlink_fmsg *fmsg,
const void *value, u32 value_len)
static void mlx5e_health_rsc_fmsg_binary(struct devlink_fmsg *fmsg,
const void *value, u32 value_len)
{
u32 data_size;
int err = 0;
u32 offset;
for (offset = 0; offset < value_len; offset += data_size) {
data_size = value_len - offset;
if (data_size > MLX5_HEALTH_DEVLINK_MAX_SIZE)
data_size = MLX5_HEALTH_DEVLINK_MAX_SIZE;
err = devlink_fmsg_binary_put(fmsg, value + offset, data_size);
if (err)
break;
devlink_fmsg_binary_put(fmsg, value + offset, data_size);
}
return err;
}
int mlx5e_health_rsc_fmsg_dump(struct mlx5e_priv *priv, struct mlx5_rsc_key *key,
@ -259,9 +180,8 @@ int mlx5e_health_rsc_fmsg_dump(struct mlx5e_priv *priv, struct mlx5_rsc_key *key
{
struct mlx5_core_dev *mdev = priv->mdev;
struct mlx5_rsc_dump_cmd *cmd;
int cmd_err, err = 0;
struct page *page;
int cmd_err, err;
int end_err;
int size;
if (IS_ERR_OR_NULL(mdev->rsc_dump))
@ -271,9 +191,7 @@ int mlx5e_health_rsc_fmsg_dump(struct mlx5e_priv *priv, struct mlx5_rsc_key *key
if (!page)
return -ENOMEM;
err = devlink_fmsg_binary_pair_nest_start(fmsg, "data");
if (err)
goto free_page;
devlink_fmsg_binary_pair_nest_start(fmsg, "data");
cmd = mlx5_rsc_dump_cmd_create(mdev, key);
if (IS_ERR(cmd)) {
@ -288,52 +206,31 @@ int mlx5e_health_rsc_fmsg_dump(struct mlx5e_priv *priv, struct mlx5_rsc_key *key
goto destroy_cmd;
}
err = mlx5e_health_rsc_fmsg_binary(fmsg, page_address(page), size);
if (err)
goto destroy_cmd;
mlx5e_health_rsc_fmsg_binary(fmsg, page_address(page), size);
} while (cmd_err > 0);
destroy_cmd:
mlx5_rsc_dump_cmd_destroy(cmd);
end_err = devlink_fmsg_binary_pair_nest_end(fmsg);
if (end_err)
err = end_err;
devlink_fmsg_binary_pair_nest_end(fmsg);
free_page:
__free_page(page);
return err;
}
int mlx5e_health_queue_dump(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
int queue_idx, char *lbl)
void mlx5e_health_queue_dump(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
int queue_idx, char *lbl)
{
struct mlx5_rsc_key key = {};
int err;
key.rsc = MLX5_SGMT_TYPE_FULL_QPC;
key.index1 = queue_idx;
key.size = PAGE_SIZE;
key.num_of_obj1 = 1;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, lbl);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "index", queue_idx);
if (err)
return err;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
return devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_obj_nest_start(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, lbl);
devlink_fmsg_u32_pair_put(fmsg, "index", queue_idx);
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
devlink_fmsg_obj_nest_end(fmsg);
}

14
drivers/net/ethernet/mellanox/mlx5/core/en/health.h
View File

@ -20,11 +20,11 @@ void mlx5e_reporter_tx_err_cqe(struct mlx5e_txqsq *sq);
int mlx5e_reporter_tx_timeout(struct mlx5e_txqsq *sq);
void mlx5e_reporter_tx_ptpsq_unhealthy(struct mlx5e_ptpsq *ptpsq);
int mlx5e_health_cq_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg);
int mlx5e_health_cq_common_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg);
int mlx5e_health_eq_diag_fmsg(struct mlx5_eq_comp *eq, struct devlink_fmsg *fmsg);
int mlx5e_health_fmsg_named_obj_nest_start(struct devlink_fmsg *fmsg, char *name);
int mlx5e_health_fmsg_named_obj_nest_end(struct devlink_fmsg *fmsg);
void mlx5e_health_cq_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg);
void mlx5e_health_cq_common_diag_fmsg(struct mlx5e_cq *cq, struct devlink_fmsg *fmsg);
void mlx5e_health_eq_diag_fmsg(struct mlx5_eq_comp *eq, struct devlink_fmsg *fmsg);
void mlx5e_health_fmsg_named_obj_nest_start(struct devlink_fmsg *fmsg, char *name);
void mlx5e_health_fmsg_named_obj_nest_end(struct devlink_fmsg *fmsg);
void mlx5e_reporter_rx_create(struct mlx5e_priv *priv);
void mlx5e_reporter_rx_destroy(struct mlx5e_priv *priv);
@ -54,6 +54,6 @@ void mlx5e_health_destroy_reporters(struct mlx5e_priv *priv);
void mlx5e_health_channels_update(struct mlx5e_priv *priv);
int mlx5e_health_rsc_fmsg_dump(struct mlx5e_priv *priv, struct mlx5_rsc_key *key,
struct devlink_fmsg *fmsg);
int mlx5e_health_queue_dump(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
int queue_idx, char *lbl);
void mlx5e_health_queue_dump(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
int queue_idx, char *lbl);
#endif

422
drivers/net/ethernet/mellanox/mlx5/core/en/reporter_rx.c
View File

@ -199,78 +199,38 @@ static int mlx5e_rx_reporter_recover(struct devlink_health_reporter *reporter,
mlx5e_health_recover_channels(priv);
}
static int mlx5e_reporter_icosq_diagnose(struct mlx5e_icosq *icosq, u8 hw_state,
struct devlink_fmsg *fmsg)
static void mlx5e_reporter_icosq_diagnose(struct mlx5e_icosq *icosq, u8 hw_state,
struct devlink_fmsg *fmsg)
{
int err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ");
devlink_fmsg_u32_pair_put(fmsg, "sqn", icosq->sqn);
devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state);
devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cc);
devlink_fmsg_u32_pair_put(fmsg, "pc", icosq->pc);
devlink_fmsg_u32_pair_put(fmsg, "WQE size", mlx5_wq_cyc_get_size(&icosq->wq));
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ");
devlink_fmsg_u32_pair_put(fmsg, "cqn", icosq->cq.mcq.cqn);
devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cq.wq.cc);
devlink_fmsg_u32_pair_put(fmsg, "size", mlx5_cqwq_get_size(&icosq->cq.wq));
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = devlink_fmsg_u32_pair_put(fmsg, "sqn", icosq->sqn);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cc);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "pc", icosq->pc);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "WQE size",
mlx5_wq_cyc_get_size(&icosq->wq));
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ");
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "cqn", icosq->cq.mcq.cqn);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cq.wq.cc);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "size", mlx5_cqwq_get_size(&icosq->cq.wq));
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int mlx5e_health_rq_put_sw_state(struct devlink_fmsg *fmsg, struct mlx5e_rq *rq)
static void mlx5e_health_rq_put_sw_state(struct devlink_fmsg *fmsg, struct mlx5e_rq *rq)
{
int err;
int i;
BUILD_BUG_ON_MSG(ARRAY_SIZE(rq_sw_state_type_name) != MLX5E_NUM_RQ_STATES,
"rq_sw_state_type_name string array must be consistent with MLX5E_RQ_STATE_* enum in en.h");
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SW State");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SW State");
for (i = 0; i < ARRAY_SIZE(rq_sw_state_type_name); ++i) {
err = devlink_fmsg_u32_pair_put(fmsg, rq_sw_state_type_name[i],
test_bit(i, &rq->state));
if (err)
return err;
}
for (i = 0; i < ARRAY_SIZE(rq_sw_state_type_name); ++i)
devlink_fmsg_u32_pair_put(fmsg, rq_sw_state_type_name[i],
test_bit(i, &rq->state));
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int
@ -291,184 +251,89 @@ mlx5e_rx_reporter_build_diagnose_output_rq_common(struct mlx5e_rq *rq,
wq_head = mlx5e_rqwq_get_head(rq);
wqe_counter = mlx5e_rqwq_get_wqe_counter(rq);
err = devlink_fmsg_u32_pair_put(fmsg, "rqn", rq->rqn);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "WQE counter", wqe_counter);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "posted WQEs", wqes_sz);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "cc", wq_head);
if (err)
return err;
err = mlx5e_health_rq_put_sw_state(fmsg, rq);
if (err)
return err;
err = mlx5e_health_cq_diag_fmsg(&rq->cq, fmsg);
if (err)
return err;
err = mlx5e_health_eq_diag_fmsg(rq->cq.mcq.eq, fmsg);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "rqn", rq->rqn);
devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state);
devlink_fmsg_u32_pair_put(fmsg, "WQE counter", wqe_counter);
devlink_fmsg_u32_pair_put(fmsg, "posted WQEs", wqes_sz);
devlink_fmsg_u32_pair_put(fmsg, "cc", wq_head);
mlx5e_health_rq_put_sw_state(fmsg, rq);
mlx5e_health_cq_diag_fmsg(&rq->cq, fmsg);
mlx5e_health_eq_diag_fmsg(rq->cq.mcq.eq, fmsg);
if (rq->icosq) {
struct mlx5e_icosq *icosq = rq->icosq;
u8 icosq_hw_state;
err = mlx5_core_query_sq_state(rq->mdev, icosq->sqn, &icosq_hw_state);
if (err)
return err;
err = mlx5e_reporter_icosq_diagnose(icosq, icosq_hw_state, fmsg);
if (err)
return err;
mlx5_core_query_sq_state(rq->mdev, icosq->sqn, &icosq_hw_state);
mlx5e_reporter_icosq_diagnose(icosq, icosq_hw_state, fmsg);
}
return 0;
}
static int mlx5e_rx_reporter_build_diagnose_output(struct mlx5e_rq *rq,
struct devlink_fmsg *fmsg)
static void mlx5e_rx_reporter_build_diagnose_output(struct mlx5e_rq *rq,
struct devlink_fmsg *fmsg)
{
int err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "channel ix", rq->ix);
if (err)
return err;
err = mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg);
if (err)
return err;
return devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_u32_pair_put(fmsg, "channel ix", rq->ix);
mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg);
devlink_fmsg_obj_nest_end(fmsg);
}
static int mlx5e_rx_reporter_diagnose_generic_rq(struct mlx5e_rq *rq,
struct devlink_fmsg *fmsg)
static void mlx5e_rx_reporter_diagnose_generic_rq(struct mlx5e_rq *rq,
struct devlink_fmsg *fmsg)
{
struct mlx5e_priv *priv = rq->priv;
struct mlx5e_params *params;
u32 rq_stride, rq_sz;
bool real_time;
int err;
params = &priv->channels.params;
rq_sz = mlx5e_rqwq_get_size(rq);
real_time = mlx5_is_real_time_rq(priv->mdev);
rq_stride = BIT(mlx5e_mpwqe_get_log_stride_size(priv->mdev, params, NULL));
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ");
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "type", params->rq_wq_type);
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "stride size", rq_stride);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "size", rq_sz);
if (err)
return err;
err = devlink_fmsg_string_pair_put(fmsg, "ts_format", real_time ? "RT" : "FRC");
if (err)
return err;
err = mlx5e_health_cq_common_diag_fmsg(&rq->cq, fmsg);
if (err)
return err;
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ");
devlink_fmsg_u8_pair_put(fmsg, "type", params->rq_wq_type);
devlink_fmsg_u64_pair_put(fmsg, "stride size", rq_stride);
devlink_fmsg_u32_pair_put(fmsg, "size", rq_sz);
devlink_fmsg_string_pair_put(fmsg, "ts_format", real_time ? "RT" : "FRC");
mlx5e_health_cq_common_diag_fmsg(&rq->cq, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int
static void
mlx5e_rx_reporter_diagnose_common_ptp_config(struct mlx5e_priv *priv, struct mlx5e_ptp *ptp_ch,
struct devlink_fmsg *fmsg)
{
int err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "PTP");
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "filter_type", priv->tstamp.rx_filter);
if (err)
return err;
err = mlx5e_rx_reporter_diagnose_generic_rq(&ptp_ch->rq, fmsg);
if (err)
return err;
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "PTP");
devlink_fmsg_u32_pair_put(fmsg, "filter_type", priv->tstamp.rx_filter);
mlx5e_rx_reporter_diagnose_generic_rq(&ptp_ch->rq, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int
static void
mlx5e_rx_reporter_diagnose_common_config(struct devlink_health_reporter *reporter,
struct devlink_fmsg *fmsg)
{
struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
struct mlx5e_rq *generic_rq = &priv->channels.c[0]->rq;
struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
int err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Common config");
if (err)
return err;
err = mlx5e_rx_reporter_diagnose_generic_rq(generic_rq, fmsg);
if (err)
return err;
if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) {
err = mlx5e_rx_reporter_diagnose_common_ptp_config(priv, ptp_ch, fmsg);
if (err)
return err;
}
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Common config");
mlx5e_rx_reporter_diagnose_generic_rq(generic_rq, fmsg);
if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state))
mlx5e_rx_reporter_diagnose_common_ptp_config(priv, ptp_ch, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int mlx5e_rx_reporter_build_diagnose_output_ptp_rq(struct mlx5e_rq *rq,
struct devlink_fmsg *fmsg)
static void mlx5e_rx_reporter_build_diagnose_output_ptp_rq(struct mlx5e_rq *rq,
struct devlink_fmsg *fmsg)
{
int err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_string_pair_put(fmsg, "channel", "ptp");
if (err)
return err;
err = mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg);
if (err)
return err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_string_pair_put(fmsg, "channel", "ptp");
mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg);
devlink_fmsg_obj_nest_end(fmsg);
}
static int mlx5e_rx_reporter_diagnose(struct devlink_health_reporter *reporter,
@ -477,20 +342,15 @@ static int mlx5e_rx_reporter_diagnose(struct devlink_health_reporter *reporter,
{
struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
int i, err = 0;
int i;
mutex_lock(&priv->state_lock);
if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
goto unlock;
err = mlx5e_rx_reporter_diagnose_common_config(reporter, fmsg);
if (err)
goto unlock;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "RQs");
if (err)
goto unlock;
mlx5e_rx_reporter_diagnose_common_config(reporter, fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "RQs");
for (i = 0; i < priv->channels.num; i++) {
struct mlx5e_channel *c = priv->channels.c[i];
@ -499,19 +359,14 @@ static int mlx5e_rx_reporter_diagnose(struct devlink_health_reporter *reporter,
rq = test_bit(MLX5E_CHANNEL_STATE_XSK, c->state) ?
&c->xskrq : &c->rq;
err = mlx5e_rx_reporter_build_diagnose_output(rq, fmsg);
if (err)
goto unlock;
mlx5e_rx_reporter_build_diagnose_output(rq, fmsg);
}
if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) {
err = mlx5e_rx_reporter_build_diagnose_output_ptp_rq(&ptp_ch->rq, fmsg);
if (err)
goto unlock;
}
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state))
mlx5e_rx_reporter_build_diagnose_output_ptp_rq(&ptp_ch->rq, fmsg);
devlink_fmsg_arr_pair_nest_end(fmsg);
unlock:
mutex_unlock(&priv->state_lock);
return err;
return 0;
}
static int mlx5e_rx_reporter_dump_icosq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
@ -519,61 +374,34 @@ static int mlx5e_rx_reporter_dump_icosq(struct mlx5e_priv *priv, struct devlink_
{
struct mlx5e_txqsq *icosq = ctx;
struct mlx5_rsc_key key = {};
int err;
if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
return 0;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
key.size = PAGE_SIZE;
key.rsc = MLX5_SGMT_TYPE_SX_SLICE_ALL;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ");
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ");
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
key.rsc = MLX5_SGMT_TYPE_FULL_QPC;
key.index1 = icosq->sqn;
key.num_of_obj1 = 1;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "send_buff");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "send_buff");
key.rsc = MLX5_SGMT_TYPE_SND_BUFF;
key.num_of_obj2 = MLX5_RSC_DUMP_ALL;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
return 0;
}
static int mlx5e_rx_reporter_dump_rq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
@ -581,60 +409,34 @@ static int mlx5e_rx_reporter_dump_rq(struct mlx5e_priv *priv, struct devlink_fms
{
struct mlx5_rsc_key key = {};
struct mlx5e_rq *rq = ctx;
int err;
if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
return 0;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice");
key.size = PAGE_SIZE;
key.rsc = MLX5_SGMT_TYPE_RX_SLICE_ALL;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ");
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ");
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
key.rsc = MLX5_SGMT_TYPE_FULL_QPC;
key.index1 = rq->rqn;
key.num_of_obj1 = 1;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "receive_buff");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "receive_buff");
key.rsc = MLX5_SGMT_TYPE_RCV_BUFF;
key.num_of_obj2 = MLX5_RSC_DUMP_ALL;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
return 0;
}
static int mlx5e_rx_reporter_dump_all_rqs(struct mlx5e_priv *priv,
@ -642,44 +444,28 @@ static int mlx5e_rx_reporter_dump_all_rqs(struct mlx5e_priv *priv,
{
struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
struct mlx5_rsc_key key = {};
int i, err;
if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
return 0;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice");
key.size = PAGE_SIZE;
key.rsc = MLX5_SGMT_TYPE_RX_SLICE_ALL;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "RQs");
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "RQs");
if (err)
return err;
for (i = 0; i < priv->channels.num; i++) {
for (int i = 0; i < priv->channels.num; i++) {
struct mlx5e_rq *rq = &priv->channels.c[i]->rq;
err = mlx5e_health_queue_dump(priv, fmsg, rq->rqn, "RQ");
if (err)
return err;
mlx5e_health_queue_dump(priv, fmsg, rq->rqn, "RQ");
}
if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) {
err = mlx5e_health_queue_dump(priv, fmsg, ptp_ch->rq.rqn, "PTP RQ");
if (err)
return err;
}
if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state))
mlx5e_health_queue_dump(priv, fmsg, ptp_ch->rq.rqn, "PTP RQ");
return devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_end(fmsg);
return 0;
}
static int mlx5e_rx_reporter_dump_from_ctx(struct mlx5e_priv *priv,

344
drivers/net/ethernet/mellanox/mlx5/core/en/reporter_tx.c
View File

@ -50,25 +50,19 @@ static void mlx5e_reset_txqsq_cc_pc(struct mlx5e_txqsq *sq)
sq->pc = 0;
}
static int mlx5e_health_sq_put_sw_state(struct devlink_fmsg *fmsg, struct mlx5e_txqsq *sq)
static void mlx5e_health_sq_put_sw_state(struct devlink_fmsg *fmsg, struct mlx5e_txqsq *sq)
{
int err;
int i;
BUILD_BUG_ON_MSG(ARRAY_SIZE(sq_sw_state_type_name) != MLX5E_NUM_SQ_STATES,
"sq_sw_state_type_name string array must be consistent with MLX5E_SQ_STATE_* enum in en.h");
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SW State");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SW State");
for (i = 0; i < ARRAY_SIZE(sq_sw_state_type_name); ++i) {
err = devlink_fmsg_u32_pair_put(fmsg, sq_sw_state_type_name[i],
test_bit(i, &sq->state));
if (err)
return err;
}
for (i = 0; i < ARRAY_SIZE(sq_sw_state_type_name); ++i)
devlink_fmsg_u32_pair_put(fmsg, sq_sw_state_type_name[i],
test_bit(i, &sq->state));
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int mlx5e_tx_reporter_err_cqe_recover(void *ctx)
@ -220,173 +214,76 @@ static int mlx5e_tx_reporter_recover(struct devlink_health_reporter *reporter,
mlx5e_health_recover_channels(priv);
}
static int
static void
mlx5e_tx_reporter_build_diagnose_output_sq_common(struct devlink_fmsg *fmsg,
struct mlx5e_txqsq *sq, int tc)
{
bool stopped = netif_xmit_stopped(sq->txq);
struct mlx5e_priv *priv = sq->priv;
u8 state;
int err;
err = mlx5_core_query_sq_state(priv->mdev, sq->sqn, &state);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "tc", tc);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "txq ix", sq->txq_ix);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "sqn", sq->sqn);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "HW state", state);
if (err)
return err;
err = devlink_fmsg_bool_pair_put(fmsg, "stopped", stopped);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "cc", sq->cc);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "pc", sq->pc);
if (err)
return err;
err = mlx5e_health_sq_put_sw_state(fmsg, sq);
if (err)
return err;
err = mlx5e_health_cq_diag_fmsg(&sq->cq, fmsg);
if (err)
return err;
return mlx5e_health_eq_diag_fmsg(sq->cq.mcq.eq, fmsg);
mlx5_core_query_sq_state(priv->mdev, sq->sqn, &state);
devlink_fmsg_u32_pair_put(fmsg, "tc", tc);
devlink_fmsg_u32_pair_put(fmsg, "txq ix", sq->txq_ix);
devlink_fmsg_u32_pair_put(fmsg, "sqn", sq->sqn);
devlink_fmsg_u8_pair_put(fmsg, "HW state", state);
devlink_fmsg_bool_pair_put(fmsg, "stopped", stopped);
devlink_fmsg_u32_pair_put(fmsg, "cc", sq->cc);
devlink_fmsg_u32_pair_put(fmsg, "pc", sq->pc);
mlx5e_health_sq_put_sw_state(fmsg, sq);
mlx5e_health_cq_diag_fmsg(&sq->cq, fmsg);
mlx5e_health_eq_diag_fmsg(sq->cq.mcq.eq, fmsg);
}
static int
static void
mlx5e_tx_reporter_build_diagnose_output(struct devlink_fmsg *fmsg,
struct mlx5e_txqsq *sq, int tc)
{
int err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "channel ix", sq->ch_ix);
if (err)
return err;
err = mlx5e_tx_reporter_build_diagnose_output_sq_common(fmsg, sq, tc);
if (err)
return err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_u32_pair_put(fmsg, "channel ix", sq->ch_ix);
mlx5e_tx_reporter_build_diagnose_output_sq_common(fmsg, sq, tc);
devlink_fmsg_obj_nest_end(fmsg);
}
static int
static void
mlx5e_tx_reporter_build_diagnose_output_ptpsq(struct devlink_fmsg *fmsg,
struct mlx5e_ptpsq *ptpsq, int tc)
{
int err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_string_pair_put(fmsg, "channel", "ptp");
if (err)
return err;
err = mlx5e_tx_reporter_build_diagnose_output_sq_common(fmsg, &ptpsq->txqsq, tc);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Port TS");
if (err)
return err;
err = mlx5e_health_cq_diag_fmsg(&ptpsq->ts_cq, fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_string_pair_put(fmsg, "channel", "ptp");
mlx5e_tx_reporter_build_diagnose_output_sq_common(fmsg, &ptpsq->txqsq, tc);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Port TS");
mlx5e_health_cq_diag_fmsg(&ptpsq->ts_cq, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
devlink_fmsg_obj_nest_end(fmsg);
}
static int
static void
mlx5e_tx_reporter_diagnose_generic_txqsq(struct devlink_fmsg *fmsg,
struct mlx5e_txqsq *txqsq)
{
u32 sq_stride, sq_sz;
bool real_time;
int err;
bool real_time = mlx5_is_real_time_sq(txqsq->mdev);
u32 sq_sz = mlx5_wq_cyc_get_size(&txqsq->wq);
u32 sq_stride = MLX5_SEND_WQE_BB;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SQ");
if (err)
return err;
real_time = mlx5_is_real_time_sq(txqsq->mdev);
sq_sz = mlx5_wq_cyc_get_size(&txqsq->wq);
sq_stride = MLX5_SEND_WQE_BB;
err = devlink_fmsg_u64_pair_put(fmsg, "stride size", sq_stride);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "size", sq_sz);
if (err)
return err;
err = devlink_fmsg_string_pair_put(fmsg, "ts_format", real_time ? "RT" : "FRC");
if (err)
return err;
err = mlx5e_health_cq_common_diag_fmsg(&txqsq->cq, fmsg);
if (err)
return err;
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SQ");
devlink_fmsg_u64_pair_put(fmsg, "stride size", sq_stride);
devlink_fmsg_u32_pair_put(fmsg, "size", sq_sz);
devlink_fmsg_string_pair_put(fmsg, "ts_format", real_time ? "RT" : "FRC");
mlx5e_health_cq_common_diag_fmsg(&txqsq->cq, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int
static void
mlx5e_tx_reporter_diagnose_generic_tx_port_ts(struct devlink_fmsg *fmsg,
struct mlx5e_ptpsq *ptpsq)
{
int err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Port TS");
if (err)
return err;
err = mlx5e_health_cq_common_diag_fmsg(&ptpsq->ts_cq, fmsg);
if (err)
return err;
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Port TS");
mlx5e_health_cq_common_diag_fmsg(&ptpsq->ts_cq, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int
static void
mlx5e_tx_reporter_diagnose_common_config(struct devlink_health_reporter *reporter,
struct devlink_fmsg *fmsg)
{
@ -394,39 +291,20 @@ mlx5e_tx_reporter_diagnose_common_config(struct devlink_health_reporter *reporte
struct mlx5e_txqsq *generic_sq = priv->txq2sq[0];
struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
struct mlx5e_ptpsq *generic_ptpsq;
int err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Common Config");
if (err)
return err;
err = mlx5e_tx_reporter_diagnose_generic_txqsq(fmsg, generic_sq);
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Common Config");
mlx5e_tx_reporter_diagnose_generic_txqsq(fmsg, generic_sq);
if (!ptp_ch || !test_bit(MLX5E_PTP_STATE_TX, ptp_ch->state))
goto out;
generic_ptpsq = &ptp_ch->ptpsq[0];
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "PTP");
if (err)
return err;
err = mlx5e_tx_reporter_diagnose_generic_txqsq(fmsg, &generic_ptpsq->txqsq);
if (err)
return err;
err = mlx5e_tx_reporter_diagnose_generic_tx_port_ts(fmsg, generic_ptpsq);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "PTP");
mlx5e_tx_reporter_diagnose_generic_txqsq(fmsg, &generic_ptpsq->txqsq);
mlx5e_tx_reporter_diagnose_generic_tx_port_ts(fmsg, generic_ptpsq);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
out:
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
}
static int mlx5e_tx_reporter_diagnose(struct devlink_health_reporter *reporter,
@ -436,20 +314,15 @@ static int mlx5e_tx_reporter_diagnose(struct devlink_health_reporter *reporter,
struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
int i, tc, err = 0;
int i, tc;
mutex_lock(&priv->state_lock);
if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
goto unlock;
err = mlx5e_tx_reporter_diagnose_common_config(reporter, fmsg);
if (err)
goto unlock;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "SQs");
if (err)
goto unlock;
mlx5e_tx_reporter_diagnose_common_config(reporter, fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "SQs");
for (i = 0; i < priv->channels.num; i++) {
struct mlx5e_channel *c = priv->channels.c[i];
@ -457,31 +330,23 @@ static int mlx5e_tx_reporter_diagnose(struct devlink_health_reporter *reporter,
for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++) {
struct mlx5e_txqsq *sq = &c->sq[tc];
err = mlx5e_tx_reporter_build_diagnose_output(fmsg, sq, tc);
if (err)
goto unlock;
mlx5e_tx_reporter_build_diagnose_output(fmsg, sq, tc);
}
}
if (!ptp_ch || !test_bit(MLX5E_PTP_STATE_TX, ptp_ch->state))
goto close_sqs_nest;
for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++) {
err = mlx5e_tx_reporter_build_diagnose_output_ptpsq(fmsg,
&ptp_ch->ptpsq[tc],
tc);
if (err)
goto unlock;
}
for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++)
mlx5e_tx_reporter_build_diagnose_output_ptpsq(fmsg,
&ptp_ch->ptpsq[tc],
tc);
close_sqs_nest:
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (err)
goto unlock;
devlink_fmsg_arr_pair_nest_end(fmsg);
unlock:
mutex_unlock(&priv->state_lock);
return err;
return 0;
}
static int mlx5e_tx_reporter_dump_sq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
@ -489,60 +354,33 @@ static int mlx5e_tx_reporter_dump_sq(struct mlx5e_priv *priv, struct devlink_fms
{
struct mlx5_rsc_key key = {};
struct mlx5e_txqsq *sq = ctx;
int err;
if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
return 0;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
key.size = PAGE_SIZE;
key.rsc = MLX5_SGMT_TYPE_SX_SLICE_ALL;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SQ");
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
if (err)
return err;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SQ");
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
key.rsc = MLX5_SGMT_TYPE_FULL_QPC;
key.index1 = sq->sqn;
key.num_of_obj1 = 1;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "send_buff");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "send_buff");
key.rsc = MLX5_SGMT_TYPE_SND_BUFF;
key.num_of_obj2 = MLX5_RSC_DUMP_ALL;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
return 0;
}
static int mlx5e_tx_reporter_timeout_dump(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
@ -567,28 +405,17 @@ static int mlx5e_tx_reporter_dump_all_sqs(struct mlx5e_priv *priv,
{
struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
struct mlx5_rsc_key key = {};
int i, tc, err;
int i, tc;
if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
return 0;
err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
if (err)
return err;
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
key.size = PAGE_SIZE;
key.rsc = MLX5_SGMT_TYPE_SX_SLICE_ALL;
err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
if (err)
return err;
err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "SQs");
if (err)
return err;
mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
mlx5e_health_fmsg_named_obj_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "SQs");
for (i = 0; i < priv->channels.num; i++) {
struct mlx5e_channel *c = priv->channels.c[i];
@ -596,9 +423,7 @@ static int mlx5e_tx_reporter_dump_all_sqs(struct mlx5e_priv *priv,
for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++) {
struct mlx5e_txqsq *sq = &c->sq[tc];
err = mlx5e_health_queue_dump(priv, fmsg, sq->sqn, "SQ");
if (err)
return err;
mlx5e_health_queue_dump(priv, fmsg, sq->sqn, "SQ");
}
}
@ -606,13 +431,12 @@ static int mlx5e_tx_reporter_dump_all_sqs(struct mlx5e_priv *priv,
for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++) {
struct mlx5e_txqsq *sq = &ptp_ch->ptpsq[tc].txqsq;
err = mlx5e_health_queue_dump(priv, fmsg, sq->sqn, "PTP SQ");
if (err)
return err;
mlx5e_health_queue_dump(priv, fmsg, sq->sqn, "PTP SQ");
}
}
return devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_end(fmsg);
return 0;
}
static int mlx5e_tx_reporter_dump_from_ctx(struct mlx5e_priv *priv,

5
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
View File

@ -1356,8 +1356,9 @@ mlx5e_rep_vnic_reporter_diagnose(struct devlink_health_reporter *reporter,
struct mlx5e_rep_priv *rpriv = devlink_health_reporter_priv(reporter);
struct mlx5_eswitch_rep *rep = rpriv->rep;
return mlx5_reporter_vnic_diagnose_counters(rep->esw->dev, fmsg,
rep->vport, true);
mlx5_reporter_vnic_diagnose_counters(rep->esw->dev, fmsg, rep->vport,
true);
return 0;
}
static const struct devlink_health_reporter_ops mlx5_rep_vnic_reporter_ops = {

127
drivers/net/ethernet/mellanox/mlx5/core/health.c
View File

@ -450,14 +450,15 @@ mlx5_fw_reporter_diagnose(struct devlink_health_reporter *reporter,
struct mlx5_core_dev *dev = devlink_health_reporter_priv(reporter);
struct mlx5_core_health *health = &dev->priv.health;
struct health_buffer __iomem *h = health->health;
u8 synd;
int err;
u8 synd = ioread8(&h->synd);
synd = ioread8(&h->synd);
err = devlink_fmsg_u8_pair_put(fmsg, "Syndrome", synd);
if (err || !synd)
return err;
return devlink_fmsg_string_pair_put(fmsg, "Description", hsynd_str(synd));
if (!synd)
return 0;
devlink_fmsg_u8_pair_put(fmsg, "Syndrome", synd);
devlink_fmsg_string_pair_put(fmsg, "Description", hsynd_str(synd));
return 0;
}
struct mlx5_fw_reporter_ctx {
@ -465,94 +466,47 @@ struct mlx5_fw_reporter_ctx {
int miss_counter;
};
static int
static void
mlx5_fw_reporter_ctx_pairs_put(struct devlink_fmsg *fmsg,
struct mlx5_fw_reporter_ctx *fw_reporter_ctx)
{
int err;
err = devlink_fmsg_u8_pair_put(fmsg, "syndrome",
fw_reporter_ctx->err_synd);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "fw_miss_counter",
fw_reporter_ctx->miss_counter);
if (err)
return err;
return 0;
devlink_fmsg_u8_pair_put(fmsg, "syndrome", fw_reporter_ctx->err_synd);
devlink_fmsg_u32_pair_put(fmsg, "fw_miss_counter", fw_reporter_ctx->miss_counter);
}
static int
static void
mlx5_fw_reporter_heath_buffer_data_put(struct mlx5_core_dev *dev,
struct devlink_fmsg *fmsg)
{
struct mlx5_core_health *health = &dev->priv.health;
struct health_buffer __iomem *h = health->health;
u8 rfr_severity;
int err;
int i;
if (!ioread8(&h->synd))
return 0;
return;
err = devlink_fmsg_pair_nest_start(fmsg, "health buffer");
if (err)
return err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "assert_var");
if (err)
return err;
for (i = 0; i < ARRAY_SIZE(h->assert_var); i++) {
err = devlink_fmsg_u32_put(fmsg, ioread32be(h->assert_var + i));
if (err)
return err;
}
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "assert_exit_ptr",
ioread32be(&h->assert_exit_ptr));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "assert_callra",
ioread32be(&h->assert_callra));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "time", ioread32be(&h->time));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "hw_id", ioread32be(&h->hw_id));
if (err)
return err;
devlink_fmsg_pair_nest_start(fmsg, "health buffer");
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "assert_var");
for (i = 0; i < ARRAY_SIZE(h->assert_var); i++)
devlink_fmsg_u32_put(fmsg, ioread32be(h->assert_var + i));
devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_u32_pair_put(fmsg, "assert_exit_ptr",
ioread32be(&h->assert_exit_ptr));
devlink_fmsg_u32_pair_put(fmsg, "assert_callra",
ioread32be(&h->assert_callra));
devlink_fmsg_u32_pair_put(fmsg, "time", ioread32be(&h->time));
devlink_fmsg_u32_pair_put(fmsg, "hw_id", ioread32be(&h->hw_id));
rfr_severity = ioread8(&h->rfr_severity);
err = devlink_fmsg_u8_pair_put(fmsg, "rfr", mlx5_health_get_rfr(rfr_severity));
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "severity", mlx5_health_get_severity(rfr_severity));
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "irisc_index",
ioread8(&h->irisc_index));
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "synd", ioread8(&h->synd));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "ext_synd",
ioread16be(&h->ext_synd));
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "raw_fw_ver",
ioread32be(&h->fw_ver));
if (err)
return err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
return devlink_fmsg_pair_nest_end(fmsg);
devlink_fmsg_u8_pair_put(fmsg, "rfr", mlx5_health_get_rfr(rfr_severity));
devlink_fmsg_u8_pair_put(fmsg, "severity", mlx5_health_get_severity(rfr_severity));
devlink_fmsg_u8_pair_put(fmsg, "irisc_index", ioread8(&h->irisc_index));
devlink_fmsg_u8_pair_put(fmsg, "synd", ioread8(&h->synd));
devlink_fmsg_u32_pair_put(fmsg, "ext_synd", ioread16be(&h->ext_synd));
devlink_fmsg_u32_pair_put(fmsg, "raw_fw_ver", ioread32be(&h->fw_ver));
devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_pair_nest_end(fmsg);
}
static int
@ -570,14 +524,11 @@ mlx5_fw_reporter_dump(struct devlink_health_reporter *reporter,
if (priv_ctx) {
struct mlx5_fw_reporter_ctx *fw_reporter_ctx = priv_ctx;
err = mlx5_fw_reporter_ctx_pairs_put(fmsg, fw_reporter_ctx);
if (err)
return err;
mlx5_fw_reporter_ctx_pairs_put(fmsg, fw_reporter_ctx);
}
err = mlx5_fw_reporter_heath_buffer_data_put(dev, fmsg);
if (err)
return err;
mlx5_fw_reporter_heath_buffer_data_put(dev, fmsg);
return mlx5_fw_tracer_get_saved_traces_objects(dev->tracer, fmsg);
}
@ -643,12 +594,10 @@ mlx5_fw_fatal_reporter_dump(struct devlink_health_reporter *reporter,
if (priv_ctx) {
struct mlx5_fw_reporter_ctx *fw_reporter_ctx = priv_ctx;
err = mlx5_fw_reporter_ctx_pairs_put(fmsg, fw_reporter_ctx);
if (err)
goto free_data;
mlx5_fw_reporter_ctx_pairs_put(fmsg, fw_reporter_ctx);
}
err = devlink_fmsg_binary_pair_put(fmsg, "crdump_data", cr_data, crdump_size);
devlink_fmsg_binary_pair_put(fmsg, "crdump_data", cr_data, crdump_size);
free_data:
kvfree(cr_data);

171
drivers/net/ethernet/mellanox/mlxsw/core.c
View File

@ -1792,122 +1792,78 @@ static void mlxsw_core_health_listener_func(const struct mlxsw_reg_info *reg,
static const struct mlxsw_listener mlxsw_core_health_listener =
MLXSW_CORE_EVENTL(mlxsw_core_health_listener_func, MFDE);
static int
static void
mlxsw_core_health_fw_fatal_dump_fatal_cause(const char *mfde_pl,
struct devlink_fmsg *fmsg)
{
u32 val, tile_v;
int err;
val = mlxsw_reg_mfde_fatal_cause_id_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "cause_id", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "cause_id", val);
tile_v = mlxsw_reg_mfde_fatal_cause_tile_v_get(mfde_pl);
if (tile_v) {
val = mlxsw_reg_mfde_fatal_cause_tile_index_get(mfde_pl);
err = devlink_fmsg_u8_pair_put(fmsg, "tile_index", val);
if (err)
return err;
devlink_fmsg_u8_pair_put(fmsg, "tile_index", val);
}
return 0;
}
static int
static void
mlxsw_core_health_fw_fatal_dump_fw_assert(const char *mfde_pl,
struct devlink_fmsg *fmsg)
{
u32 val, tile_v;
int err;
val = mlxsw_reg_mfde_fw_assert_var0_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "var0", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "var0", val);
val = mlxsw_reg_mfde_fw_assert_var1_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "var1", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "var1", val);
val = mlxsw_reg_mfde_fw_assert_var2_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "var2", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "var2", val);
val = mlxsw_reg_mfde_fw_assert_var3_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "var3", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "var3", val);
val = mlxsw_reg_mfde_fw_assert_var4_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "var4", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "var4", val);
val = mlxsw_reg_mfde_fw_assert_existptr_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "existptr", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "existptr", val);
val = mlxsw_reg_mfde_fw_assert_callra_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "callra", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "callra", val);
val = mlxsw_reg_mfde_fw_assert_oe_get(mfde_pl);
err = devlink_fmsg_bool_pair_put(fmsg, "old_event", val);
if (err)
return err;
devlink_fmsg_bool_pair_put(fmsg, "old_event", val);
tile_v = mlxsw_reg_mfde_fw_assert_tile_v_get(mfde_pl);
if (tile_v) {
val = mlxsw_reg_mfde_fw_assert_tile_index_get(mfde_pl);
err = devlink_fmsg_u8_pair_put(fmsg, "tile_index", val);
if (err)
return err;
devlink_fmsg_u8_pair_put(fmsg, "tile_index", val);
}
val = mlxsw_reg_mfde_fw_assert_ext_synd_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "ext_synd", val);
if (err)
return err;
return 0;
devlink_fmsg_u32_pair_put(fmsg, "ext_synd", val);
}
static int
static void
mlxsw_core_health_fw_fatal_dump_kvd_im_stop(const char *mfde_pl,
struct devlink_fmsg *fmsg)
{
u32 val;
int err;
val = mlxsw_reg_mfde_kvd_im_stop_oe_get(mfde_pl);
err = devlink_fmsg_bool_pair_put(fmsg, "old_event", val);
if (err)
return err;
devlink_fmsg_bool_pair_put(fmsg, "old_event", val);
val = mlxsw_reg_mfde_kvd_im_stop_pipes_mask_get(mfde_pl);
return devlink_fmsg_u32_pair_put(fmsg, "pipes_mask", val);
devlink_fmsg_u32_pair_put(fmsg, "pipes_mask", val);
}
static int
static void
mlxsw_core_health_fw_fatal_dump_crspace_to(const char *mfde_pl,
struct devlink_fmsg *fmsg)
{
u32 val;
int err;
val = mlxsw_reg_mfde_crspace_to_log_address_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "log_address", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "log_address", val);
val = mlxsw_reg_mfde_crspace_to_oe_get(mfde_pl);
err = devlink_fmsg_bool_pair_put(fmsg, "old_event", val);
if (err)
return err;
devlink_fmsg_bool_pair_put(fmsg, "old_event", val);
val = mlxsw_reg_mfde_crspace_to_log_id_get(mfde_pl);
err = devlink_fmsg_u8_pair_put(fmsg, "log_irisc_id", val);
if (err)
return err;
devlink_fmsg_u8_pair_put(fmsg, "log_irisc_id", val);
val = mlxsw_reg_mfde_crspace_to_log_ip_get(mfde_pl);
err = devlink_fmsg_u64_pair_put(fmsg, "log_ip", val);
if (err)
return err;
return 0;
devlink_fmsg_u64_pair_put(fmsg, "log_ip", val);
}
static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *reporter,
@ -1918,24 +1874,17 @@ static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *repor
char *val_str;
u8 event_id;
u32 val;
int err;
if (!priv_ctx)
/* User-triggered dumps are not possible */
return -EOPNOTSUPP;
val = mlxsw_reg_mfde_irisc_id_get(mfde_pl);
err = devlink_fmsg_u8_pair_put(fmsg, "irisc_id", val);
if (err)
return err;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "event");
if (err)
return err;
devlink_fmsg_u8_pair_put(fmsg, "irisc_id", val);
devlink_fmsg_arr_pair_nest_start(fmsg, "event");
event_id = mlxsw_reg_mfde_event_id_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "id", event_id);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "id", event_id);
switch (event_id) {
case MLXSW_REG_MFDE_EVENT_ID_CRSPACE_TO:
val_str = "CR space timeout";
@ -1955,24 +1904,13 @@ static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *repor
default:
val_str = NULL;
}
if (val_str) {
err = devlink_fmsg_string_pair_put(fmsg, "desc", val_str);
if (err)
return err;
}
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "severity");
if (err)
return err;
if (val_str)
devlink_fmsg_string_pair_put(fmsg, "desc", val_str);
devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "severity");
val = mlxsw_reg_mfde_severity_get(mfde_pl);
err = devlink_fmsg_u8_pair_put(fmsg, "id", val);
if (err)
return err;
devlink_fmsg_u8_pair_put(fmsg, "id", val);
switch (val) {
case MLXSW_REG_MFDE_SEVERITY_FATL:
val_str = "Fatal";
@ -1986,15 +1924,9 @@ static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *repor
default:
val_str = NULL;
}
if (val_str) {
err = devlink_fmsg_string_pair_put(fmsg, "desc", val_str);
if (err)
return err;
}
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (err)
return err;
if (val_str)
devlink_fmsg_string_pair_put(fmsg, "desc", val_str);
devlink_fmsg_arr_pair_nest_end(fmsg);
val = mlxsw_reg_mfde_method_get(mfde_pl);
switch (val) {
@ -2007,16 +1939,11 @@ static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *repor
default:
val_str = NULL;
}
if (val_str) {
err = devlink_fmsg_string_pair_put(fmsg, "method", val_str);
if (err)
return err;
}
if (val_str)
devlink_fmsg_string_pair_put(fmsg, "method", val_str);
val = mlxsw_reg_mfde_long_process_get(mfde_pl);
err = devlink_fmsg_bool_pair_put(fmsg, "long_process", val);
if (err)
return err;
devlink_fmsg_bool_pair_put(fmsg, "long_process", val);
val = mlxsw_reg_mfde_command_type_get(mfde_pl);
switch (val) {
@ -2032,29 +1959,25 @@ static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *repor
default:
val_str = NULL;
}
if (val_str) {
err = devlink_fmsg_string_pair_put(fmsg, "command_type", val_str);
if (err)
return err;
}
if (val_str)
devlink_fmsg_string_pair_put(fmsg, "command_type", val_str);
val = mlxsw_reg_mfde_reg_attr_id_get(mfde_pl);
err = devlink_fmsg_u32_pair_put(fmsg, "reg_attr_id", val);
if (err)
return err;
devlink_fmsg_u32_pair_put(fmsg, "reg_attr_id", val);
switch (event_id) {
case MLXSW_REG_MFDE_EVENT_ID_CRSPACE_TO:
return mlxsw_core_health_fw_fatal_dump_crspace_to(mfde_pl,
fmsg);
mlxsw_core_health_fw_fatal_dump_crspace_to(mfde_pl, fmsg);
break;
case MLXSW_REG_MFDE_EVENT_ID_KVD_IM_STOP:
return mlxsw_core_health_fw_fatal_dump_kvd_im_stop(mfde_pl,
fmsg);
mlxsw_core_health_fw_fatal_dump_kvd_im_stop(mfde_pl, fmsg);
break;
case MLXSW_REG_MFDE_EVENT_ID_FW_ASSERT:
return mlxsw_core_health_fw_fatal_dump_fw_assert(mfde_pl, fmsg);
mlxsw_core_health_fw_fatal_dump_fw_assert(mfde_pl, fmsg);
break;
case MLXSW_REG_MFDE_EVENT_ID_FATAL_CAUSE:
return mlxsw_core_health_fw_fatal_dump_fatal_cause(mfde_pl,
fmsg);
mlxsw_core_health_fw_fatal_dump_fatal_cause(mfde_pl, fmsg);
break;
}
return 0;

6
drivers/net/ethernet/qlogic/qed/qed_devlink.c
View File

@ -66,12 +66,12 @@ qed_fw_fatal_reporter_dump(struct devlink_health_reporter *reporter,
return err;
}
err = devlink_fmsg_binary_pair_put(fmsg, "dump_data",
p_dbg_data_buf, dbg_data_buf_size);
devlink_fmsg_binary_pair_put(fmsg, "dump_data", p_dbg_data_buf,
dbg_data_buf_size);
vfree(p_dbg_data_buf);
return err;
return 0;
}
static int

118
drivers/net/netdevsim/health.c
View File

@ -63,91 +63,45 @@ nsim_dev_dummy_reporter_recover(struct devlink_health_reporter *reporter,
static int nsim_dev_dummy_fmsg_put(struct devlink_fmsg *fmsg, u32 binary_len)
{
char *binary;
int err;
int i;
err = devlink_fmsg_bool_pair_put(fmsg, "test_bool", true);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "test_u8", 1);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "test_u32", 3);
if (err)
return err;
err = devlink_fmsg_u64_pair_put(fmsg, "test_u64", 4);
if (err)
return err;
err = devlink_fmsg_string_pair_put(fmsg, "test_string", "somestring");
if (err)
return err;
devlink_fmsg_bool_pair_put(fmsg, "test_bool", true);
devlink_fmsg_u8_pair_put(fmsg, "test_u8", 1);
devlink_fmsg_u32_pair_put(fmsg, "test_u32", 3);
devlink_fmsg_u64_pair_put(fmsg, "test_u64", 4);
devlink_fmsg_string_pair_put(fmsg, "test_string", "somestring");
binary = kmalloc(binary_len, GFP_KERNEL | __GFP_NOWARN);
if (!binary)
return -ENOMEM;
get_random_bytes(binary, binary_len);
err = devlink_fmsg_binary_pair_put(fmsg, "test_binary", binary, binary_len);
devlink_fmsg_binary_pair_put(fmsg, "test_binary", binary, binary_len);
kfree(binary);
if (err)
return err;
err = devlink_fmsg_pair_nest_start(fmsg, "test_nest");
if (err)
return err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_bool_pair_put(fmsg, "nested_test_bool", false);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg, "nested_test_u8", false);
if (err)
return err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
devlink_fmsg_pair_nest_start(fmsg, "test_nest");
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_bool_pair_put(fmsg, "nested_test_bool", false);
devlink_fmsg_u8_pair_put(fmsg, "nested_test_u8", false);
devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_pair_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "test_u32_array");
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (err)
return err;
for (i = 0; i < 10; i++)
devlink_fmsg_u32_put(fmsg, i);
devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_start(fmsg, "test_array_of_objects");
err = devlink_fmsg_arr_pair_nest_start(fmsg, "test_u32_array");
if (err)
return err;
for (i = 0; i < 10; i++) {
err = devlink_fmsg_u32_put(fmsg, i);
if (err)
return err;
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_bool_pair_put(fmsg, "in_array_nested_test_bool",
false);
devlink_fmsg_u8_pair_put(fmsg, "in_array_nested_test_u8", i);
devlink_fmsg_obj_nest_end(fmsg);
}
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (err)
return err;
devlink_fmsg_arr_pair_nest_end(fmsg);
err = devlink_fmsg_arr_pair_nest_start(fmsg, "test_array_of_objects");
if (err)
return err;
for (i = 0; i < 10; i++) {
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_bool_pair_put(fmsg,
"in_array_nested_test_bool",
false);
if (err)
return err;
err = devlink_fmsg_u8_pair_put(fmsg,
"in_array_nested_test_u8",
i);
if (err)
return err;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
}
return devlink_fmsg_arr_pair_nest_end(fmsg);
return 0;
}
static int
@ -157,14 +111,10 @@ nsim_dev_dummy_reporter_dump(struct devlink_health_reporter *reporter,
{
struct nsim_dev_health *health = devlink_health_reporter_priv(reporter);
struct nsim_dev_dummy_reporter_ctx *ctx = priv_ctx;
int err;
if (ctx) {
err = devlink_fmsg_string_pair_put(fmsg, "break_message",
ctx->break_msg);
if (err)
return err;
}
if (ctx)
devlink_fmsg_string_pair_put(fmsg, "break_message", ctx->break_msg);
return nsim_dev_dummy_fmsg_put(fmsg, health->binary_len);
}
@ -174,15 +124,11 @@ nsim_dev_dummy_reporter_diagnose(struct devlink_health_reporter *reporter,
struct netlink_ext_ack *extack)
{
struct nsim_dev_health *health = devlink_health_reporter_priv(reporter);
int err;
if (health->recovered_break_msg) {
err = devlink_fmsg_string_pair_put(fmsg,
"recovered_break_message",
health->recovered_break_msg);
if (err)
return err;
}
if (health->recovered_break_msg)
devlink_fmsg_string_pair_put(fmsg, "recovered_break_message",
health->recovered_break_msg);
return nsim_dev_dummy_fmsg_put(fmsg, health->binary_len);
}

60
drivers/staging/qlge/qlge_devlink.c
View File

@ -2,51 +2,29 @@
#include "qlge.h"
#include "qlge_devlink.h"
static int qlge_fill_seg_(struct devlink_fmsg *fmsg,
struct mpi_coredump_segment_header *seg_header,
u32 *reg_data)
static void qlge_fill_seg_(struct devlink_fmsg *fmsg,
struct mpi_coredump_segment_header *seg_header,
u32 *reg_data)
{
int regs_num = (seg_header->seg_size
- sizeof(struct mpi_coredump_segment_header)) / sizeof(u32);
int err;
int i;
err = devlink_fmsg_pair_nest_start(fmsg, seg_header->description);
if (err)
return err;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
return err;
err = devlink_fmsg_u32_pair_put(fmsg, "segment", seg_header->seg_num);
if (err)
return err;
err = devlink_fmsg_arr_pair_nest_start(fmsg, "values");
if (err)
return err;
devlink_fmsg_pair_nest_start(fmsg, seg_header->description);
devlink_fmsg_obj_nest_start(fmsg);
devlink_fmsg_u32_pair_put(fmsg, "segment", seg_header->seg_num);
devlink_fmsg_arr_pair_nest_start(fmsg, "values");
for (i = 0; i < regs_num; i++) {
err = devlink_fmsg_u32_put(fmsg, *reg_data);
if (err)
return err;
devlink_fmsg_u32_put(fmsg, *reg_data);
reg_data++;
}
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_arr_pair_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
return err;
devlink_fmsg_obj_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_pair_nest_end(fmsg);
}
#define FILL_SEG(seg_hdr, seg_regs) \
do { \
err = qlge_fill_seg_(fmsg, &dump->seg_hdr, dump->seg_regs); \
if (err) { \
kvfree(dump); \
return err; \
} \
} while (0)
#define FILL_SEG(seg_hdr, seg_regs) \
qlge_fill_seg_(fmsg, &dump->seg_hdr, dump->seg_regs)
static int qlge_reporter_coredump(struct devlink_health_reporter *reporter,
struct devlink_fmsg *fmsg, void *priv_ctx,
@ -114,14 +92,8 @@ static int qlge_reporter_coredump(struct devlink_health_reporter *reporter,
FILL_SEG(xfi_hss_tx_hdr, serdes_xfi_hss_tx);
FILL_SEG(xfi_hss_rx_hdr, serdes_xfi_hss_rx);
FILL_SEG(xfi_hss_pll_hdr, serdes_xfi_hss_pll);
err = qlge_fill_seg_(fmsg, &dump->misc_nic_seg_hdr,
(u32 *)&dump->misc_nic_info);
if (err) {
kvfree(dump);
return err;
}
qlge_fill_seg_(fmsg, &dump->misc_nic_seg_hdr,
(u32 *)&dump->misc_nic_info);
FILL_SEG(intr_states_seg_hdr, intr_states);
FILL_SEG(cam_entries_seg_hdr, cam_entries);
FILL_SEG(nic_routing_words_seg_hdr, nic_routing_words);
@ -140,7 +112,7 @@ static int qlge_reporter_coredump(struct devlink_health_reporter *reporter,
FILL_SEG(sem_regs_seg_hdr, sem_regs);
kvfree(dump);
return err;
return 0;
}
static const struct devlink_health_reporter_ops qlge_reporter_ops = {

52
include/net/devlink.h
View File

@ -1854,36 +1854,36 @@ int devlink_info_version_running_put_ext(struct devlink_info_req *req,
const char *version_value,
enum devlink_info_version_type version_type);
int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg);
int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg);
void devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg);
void devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg);
int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name);
int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg);
void devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name);
void devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg);
int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name);
int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg);
int devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name);
int devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg);
void devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name);
void devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg);
void devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name);
void devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg);
int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value);
int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value);
int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
u16 value_len);
void devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value);
void devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value);
void devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
u16 value_len);
int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
bool value);
int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
u8 value);
int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
u32 value);
int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
u64 value);
int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
const char *value);
int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
const void *value, u32 value_len);
void devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
bool value);
void devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
u8 value);
void devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
u32 value);
void devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
u64 value);
void devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
const char *value);
void devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
const void *value, u32 value_len);
struct devlink_health_reporter *
devl_port_health_reporter_create(struct devlink_port *port,

387
net/devlink/health.c
View File

@ -19,6 +19,7 @@ struct devlink_fmsg_item {
struct devlink_fmsg {
struct list_head item_list;
int err; /* first error encountered on some devlink_fmsg_XXX() call */
bool putting_binary; /* This flag forces enclosing of binary data
* in an array brackets. It forces using
* of designated API:
@ -562,21 +563,18 @@ static int devlink_health_do_dump(struct devlink_health_reporter *reporter,
return 0;
reporter->dump_fmsg = devlink_fmsg_alloc();
if (!reporter->dump_fmsg) {
err = -ENOMEM;
return err;
}
if (!reporter->dump_fmsg)
return -ENOMEM;
err = devlink_fmsg_obj_nest_start(reporter->dump_fmsg);
if (err)
goto dump_err;
devlink_fmsg_obj_nest_start(reporter->dump_fmsg);
err = reporter->ops->dump(reporter, reporter->dump_fmsg,
priv_ctx, extack);
if (err)
goto dump_err;
err = devlink_fmsg_obj_nest_end(reporter->dump_fmsg);
devlink_fmsg_obj_nest_end(reporter->dump_fmsg);
err = reporter->dump_fmsg->err;
if (err)
goto dump_err;
@ -670,373 +668,258 @@ int devlink_nl_cmd_health_reporter_recover_doit(struct sk_buff *skb,
return devlink_health_reporter_recover(reporter, NULL, info->extack);
}
static int devlink_fmsg_nest_common(struct devlink_fmsg *fmsg,
int attrtype)
static void devlink_fmsg_err_if_binary(struct devlink_fmsg *fmsg)
{
if (!fmsg->err && fmsg->putting_binary)
fmsg->err = -EINVAL;
}
static void devlink_fmsg_nest_common(struct devlink_fmsg *fmsg, int attrtype)
{
struct devlink_fmsg_item *item;
if (fmsg->err)
return;
item = kzalloc(sizeof(*item), GFP_KERNEL);
if (!item)
return -ENOMEM;
if (!item) {
fmsg->err = -ENOMEM;
return;
}
item->attrtype = attrtype;
list_add_tail(&item->list, &fmsg->item_list);
return 0;
}
int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
void devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_OBJ_NEST_START);
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_OBJ_NEST_START);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_start);
static int devlink_fmsg_nest_end(struct devlink_fmsg *fmsg)
static void devlink_fmsg_nest_end(struct devlink_fmsg *fmsg)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_NEST_END);
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_NEST_END);
}
int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
void devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_nest_end(fmsg);
devlink_fmsg_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_obj_nest_end);
#define DEVLINK_FMSG_MAX_SIZE (GENLMSG_DEFAULT_SIZE - GENL_HDRLEN - NLA_HDRLEN)
static int devlink_fmsg_put_name(struct devlink_fmsg *fmsg, const char *name)
static void devlink_fmsg_put_name(struct devlink_fmsg *fmsg, const char *name)
{
struct devlink_fmsg_item *item;
if (fmsg->putting_binary)
return -EINVAL;
devlink_fmsg_err_if_binary(fmsg);
if (fmsg->err)
return;
if (strlen(name) + 1 > DEVLINK_FMSG_MAX_SIZE)
return -EMSGSIZE;
if (strlen(name) + 1 > DEVLINK_FMSG_MAX_SIZE) {
fmsg->err = -EMSGSIZE;
return;
}
item = kzalloc(sizeof(*item) + strlen(name) + 1, GFP_KERNEL);
if (!item)
return -ENOMEM;
if (!item) {
fmsg->err = -ENOMEM;
return;
}
item->nla_type = NLA_NUL_STRING;
item->len = strlen(name) + 1;
item->attrtype = DEVLINK_ATTR_FMSG_OBJ_NAME;
memcpy(&item->value, name, item->len);
list_add_tail(&item->list, &fmsg->item_list);
return 0;
}
int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
void devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name)
{
int err;
if (fmsg->putting_binary)
return -EINVAL;
err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_PAIR_NEST_START);
if (err)
return err;
err = devlink_fmsg_put_name(fmsg, name);
if (err)
return err;
return 0;
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_PAIR_NEST_START);
devlink_fmsg_put_name(fmsg, name);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_start);
int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
void devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_nest_end(fmsg);
devlink_fmsg_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_pair_nest_end);
int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name)
void devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name)
{
int err;
if (fmsg->putting_binary)
return -EINVAL;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
err = devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_ARR_NEST_START);
if (err)
return err;
return 0;
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_nest_common(fmsg, DEVLINK_ATTR_FMSG_ARR_NEST_START);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_start);
int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
void devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg)
{
int err;
if (fmsg->putting_binary)
return -EINVAL;
err = devlink_fmsg_nest_end(fmsg);
if (err)
return err;
err = devlink_fmsg_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_nest_end(fmsg);
devlink_fmsg_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_arr_pair_nest_end);
int devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name)
void devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg,
const char *name)
{
int err;
err = devlink_fmsg_arr_pair_nest_start(fmsg, name);
if (err)
return err;
devlink_fmsg_arr_pair_nest_start(fmsg, name);
fmsg->putting_binary = true;
return err;
}
EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_start);
int devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg)
void devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg)
{
if (fmsg->err)
return;
if (!fmsg->putting_binary)
return -EINVAL;
fmsg->err = -EINVAL;
fmsg->putting_binary = false;
return devlink_fmsg_arr_pair_nest_end(fmsg);
devlink_fmsg_arr_pair_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_nest_end);
static int devlink_fmsg_put_value(struct devlink_fmsg *fmsg,
const void *value, u16 value_len,
u8 value_nla_type)
static void devlink_fmsg_put_value(struct devlink_fmsg *fmsg,
const void *value, u16 value_len,
u8 value_nla_type)
{
struct devlink_fmsg_item *item;
if (value_len > DEVLINK_FMSG_MAX_SIZE)
return -EMSGSIZE;
if (fmsg->err)
return;
if (value_len > DEVLINK_FMSG_MAX_SIZE) {
fmsg->err = -EMSGSIZE;
return;
}
item = kzalloc(sizeof(*item) + value_len, GFP_KERNEL);
if (!item)
return -ENOMEM;
if (!item) {
fmsg->err = -ENOMEM;
return;
}
item->nla_type = value_nla_type;
item->len = value_len;
item->attrtype = DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA;
memcpy(&item->value, value, item->len);
list_add_tail(&item->list, &fmsg->item_list);
return 0;
}
static int devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
static void devlink_fmsg_bool_put(struct devlink_fmsg *fmsg, bool value)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_FLAG);
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_FLAG);
}
static int devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
static void devlink_fmsg_u8_put(struct devlink_fmsg *fmsg, u8 value)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U8);
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U8);
}
int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
void devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U32);
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U32);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_u32_put);
static int devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
static void devlink_fmsg_u64_put(struct devlink_fmsg *fmsg, u64 value)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U64);
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_put_value(fmsg, &value, sizeof(value), NLA_U64);
}
int devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
void devlink_fmsg_string_put(struct devlink_fmsg *fmsg, const char *value)
{
if (fmsg->putting_binary)
return -EINVAL;
return devlink_fmsg_put_value(fmsg, value, strlen(value) + 1,
NLA_NUL_STRING);
devlink_fmsg_err_if_binary(fmsg);
devlink_fmsg_put_value(fmsg, value, strlen(value) + 1, NLA_NUL_STRING);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_string_put);
int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
u16 value_len)
void devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value,
u16 value_len)
{
if (!fmsg->putting_binary)
return -EINVAL;
if (!fmsg->err && !fmsg->putting_binary)
fmsg->err = -EINVAL;
return devlink_fmsg_put_value(fmsg, value, value_len, NLA_BINARY);
devlink_fmsg_put_value(fmsg, value, value_len, NLA_BINARY);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_binary_put);
int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
bool value)
void devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name,
bool value)
{
int err;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
err = devlink_fmsg_bool_put(fmsg, value);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_bool_put(fmsg, value);
devlink_fmsg_pair_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_bool_pair_put);
int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
u8 value)
void devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name,
u8 value)
{
int err;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
err = devlink_fmsg_u8_put(fmsg, value);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_u8_put(fmsg, value);
devlink_fmsg_pair_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_u8_pair_put);
int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
u32 value)
void devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name,
u32 value)
{
int err;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
err = devlink_fmsg_u32_put(fmsg, value);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_u32_put(fmsg, value);
devlink_fmsg_pair_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_u32_pair_put);
int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
u64 value)
void devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name,
u64 value)
{
int err;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
err = devlink_fmsg_u64_put(fmsg, value);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_u64_put(fmsg, value);
devlink_fmsg_pair_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_u64_pair_put);
int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
const char *value)
void devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name,
const char *value)
{
int err;
err = devlink_fmsg_pair_nest_start(fmsg, name);
if (err)
return err;
err = devlink_fmsg_string_put(fmsg, value);
if (err)
return err;
err = devlink_fmsg_pair_nest_end(fmsg);
if (err)
return err;
return 0;
devlink_fmsg_pair_nest_start(fmsg, name);
devlink_fmsg_string_put(fmsg, value);
devlink_fmsg_pair_nest_end(fmsg);
}
EXPORT_SYMBOL_GPL(devlink_fmsg_string_pair_put);
int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
const void *value, u32 value_len)
void devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name,
const void *value, u32 value_len)
{
u32 data_size;
int end_err;
u32 offset;
int err;
err = devlink_fmsg_binary_pair_nest_start(fmsg, name);
if (err)
return err;
devlink_fmsg_binary_pair_nest_start(fmsg, name);
for (offset = 0; offset < value_len; offset += data_size) {
data_size = value_len - offset;
if (data_size > DEVLINK_FMSG_MAX_SIZE)
data_size = DEVLINK_FMSG_MAX_SIZE;
err = devlink_fmsg_binary_put(fmsg, value + offset, data_size);
if (err)
break;
/* Exit from loop with a break (instead of
* return) to make sure putting_binary is turned off in
* devlink_fmsg_binary_pair_nest_end
*/
devlink_fmsg_binary_put(fmsg, value + offset, data_size);
}
end_err = devlink_fmsg_binary_pair_nest_end(fmsg);
if (end_err)
err = end_err;
return err;
devlink_fmsg_binary_pair_nest_end(fmsg);
fmsg->putting_binary = false;
}
EXPORT_SYMBOL_GPL(devlink_fmsg_binary_pair_put);
@ -1146,6 +1029,9 @@ static int devlink_fmsg_snd(struct devlink_fmsg *fmsg,
void *hdr;
int err;
if (fmsg->err)
return fmsg->err;
while (!last) {
int tmp_index = index;
@ -1199,6 +1085,9 @@ static int devlink_fmsg_dumpit(struct devlink_fmsg *fmsg, struct sk_buff *skb,
void *hdr;
int err;
if (fmsg->err)
return fmsg->err;
hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
&devlink_nl_family, NLM_F_ACK | NLM_F_MULTI, cmd);
if (!hdr) {
@ -1238,17 +1127,13 @@ int devlink_nl_cmd_health_reporter_diagnose_doit(struct sk_buff *skb,
if (!fmsg)
return -ENOMEM;
err = devlink_fmsg_obj_nest_start(fmsg);
if (err)
goto out;
devlink_fmsg_obj_nest_start(fmsg);
err = reporter->ops->diagnose(reporter, fmsg, info->extack);
if (err)
goto out;
err = devlink_fmsg_obj_nest_end(fmsg);
if (err)
goto out;
devlink_fmsg_obj_nest_end(fmsg);
err = devlink_fmsg_snd(fmsg, info,
DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE, 0);