From patchwork Mon Oct 31 23:54:49 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Zhang X-Patchwork-Id: 13026518 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2C0B2ECAAA1 for ; Mon, 31 Oct 2022 23:55:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229910AbiJaXzK (ORCPT ); Mon, 31 Oct 2022 19:55:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42428 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229881AbiJaXzI (ORCPT ); Mon, 31 Oct 2022 19:55:08 -0400 Received: from mx0a-00082601.pphosted.com (mx0b-00082601.pphosted.com [67.231.153.30]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 632CC120A7 for ; Mon, 31 Oct 2022 16:55:07 -0700 (PDT) Received: from pps.filterd (m0001303.ppops.net [127.0.0.1]) by m0001303.ppops.net (8.17.1.5/8.17.1.5) with ESMTP id 29VMPIZP007814 for ; Mon, 31 Oct 2022 16:55:06 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=meta.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=s2048-2021-q4; bh=wedYb4AzkE49YzI1GgvJ8kY5CJC6EdoIJSilHgayRjM=; b=mp1wjdcXlI0OhVM6j2CTOXBj3ecPwoknAk1iDIO94ql7gXI+323KqFzFYJ41b3Az3S9t YyX21Efl9+55fgjogjahp9yzLG+B0vWCERZKwNL7Ko8CJ7N44k2dQkRjpGIjRS3mQPXo 9F4QUc6tl0yiMdMNh/O3GtRtfrTYO9xN5WtfIuLKz1lWgkPumyaxXWdVyRQPeJl1Spu0 Msu+TnNnW6JF/v33oDRp8APqjWJfhnDlhyRS7GmLZlwnLEQz1i3lRJ7GRVcvgGBTWdFW 5KVb/fOOskM9ZQhkIRSjnJjtFU22wVJ68FZ+v8WEbquYDgUYLgOhC0eAGYMeS55KFTMd tA== Received: from maileast.thefacebook.com ([163.114.130.16]) by m0001303.ppops.net (PPS) with ESMTPS id 3kgyux4kf3-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Mon, 31 Oct 2022 16:55:06 -0700 Received: from twshared24130.14.prn3.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:83::4) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.31; Mon, 31 Oct 2022 16:55:05 -0700 Received: by devvm7073.vll0.facebook.com (Postfix, from userid 175343) id CED6929EC761; Mon, 31 Oct 2022 16:54:53 -0700 (PDT) From: Jonathan Zhang To: , , , CC: Jonathan Zhang , Jonathan Zhang Subject: [ndctl PATCH V3 1/2] libcxl: add accessors for Get Alert Configuration CCI output Date: Mon, 31 Oct 2022 16:54:49 -0700 Message-ID: <20221031235450.1775068-2-jonzhang@meta.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20221031235450.1775068-1-jonzhang@meta.com> References: <20221031235450.1775068-1-jonzhang@meta.com> MIME-Version: 1.0 X-FB-Internal: Safe X-Proofpoint-ORIG-GUID: tPj8csWZl-wA1uj02as1n8fspZgtwFl7 X-Proofpoint-GUID: tPj8csWZl-wA1uj02as1n8fspZgtwFl7 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-10-31_21,2022-10-31_01,2022-06-22_01 Precedence: bulk List-ID: X-Mailing-List: linux-cxl@vger.kernel.org From: Jonathan Zhang CXL 3.0 spec section 8.2.9.8.3.2 "Get Alert Configuration (Opcode 4201h) defines the get-alert-config command to retrieve the devices's critical alert and programmable warning configurations. Add the methods to issue the CCI command and get the fields defined. Signed-off-by: Jonathan Zhang --- Documentation/cxl/lib/libcxl.txt | 1 + cxl/lib/libcxl.c | 163 +++++++++++++++++++++++++++++++ cxl/lib/libcxl.sym | 23 +++++ cxl/lib/private.h | 38 +++++++ cxl/libcxl.h | 35 +++++++ 5 files changed, 260 insertions(+) diff --git a/Documentation/cxl/lib/libcxl.txt b/Documentation/cxl/lib/libcxl.txt index fd2962a..dec3641 100644 --- a/Documentation/cxl/lib/libcxl.txt +++ b/Documentation/cxl/lib/libcxl.txt @@ -121,6 +121,7 @@ information this call requires root / CAP_SYS_ADMIN. struct cxl_cmd *cxl_cmd_new_raw(struct cxl_memdev *memdev, int opcode); struct cxl_cmd *cxl_cmd_new_identify(struct cxl_memdev *memdev); struct cxl_cmd *cxl_cmd_new_get_health_info(struct cxl_memdev *memdev); +struct cxl_cmd *cxl_cmd_new_get_alert_config(struct cxl_memdev *memdev); struct cxl_cmd *cxl_cmd_new_read_label(struct cxl_memdev *memdev, unsigned int offset, unsigned int length); struct cxl_cmd *cxl_cmd_new_write_label(struct cxl_memdev *memdev, void *buf, diff --git a/cxl/lib/libcxl.c b/cxl/lib/libcxl.c index e8c5d44..f175d05 100644 --- a/cxl/lib/libcxl.c +++ b/cxl/lib/libcxl.c @@ -3140,6 +3140,169 @@ do { \ return !!(c->field & mask); \ } while(0) +CXL_EXPORT struct cxl_cmd * +cxl_cmd_new_get_alert_config(struct cxl_memdev *memdev) +{ + return cxl_cmd_new_generic(memdev, CXL_MEM_COMMAND_ID_GET_ALERT_CONFIG); +} + +#define cmd_alert_get_valid_alerts_field(c, m) \ + cmd_get_field_u8_mask(c, get_alert_config, GET_ALERT_CONFIG, \ + valid_alerts, m) + +CXL_EXPORT int +cxl_cmd_alert_config_life_used_prog_warn_threshold_valid(struct cxl_cmd *cmd) +{ + cmd_alert_get_valid_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_VALID_ALERTS_LIFE_USED_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_valid( + struct cxl_cmd *cmd) +{ + cmd_alert_get_valid_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_VALID_ALERTS_DEV_OVER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_valid( + struct cxl_cmd *cmd) +{ + cmd_alert_get_valid_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_VALID_ALERTS_DEV_UNDER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_valid( + struct cxl_cmd *cmd) +{ + cmd_alert_get_valid_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_VALID_ALERTS_CORRECTED_VOLATILE_MEM_ERR_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_valid( + struct cxl_cmd *cmd) +{ + cmd_alert_get_valid_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_VALID_ALERTS_CORRECTED_PMEM_ERR_PROG_WARN_THRESHOLD_MASK); +} + +#define cmd_alert_get_prog_alerts_field(c, m) \ + cmd_get_field_u8_mask(c, get_alert_config, GET_ALERT_CONFIG, \ + programmable_alerts, m) + +CXL_EXPORT int +cxl_cmd_alert_config_life_used_prog_warn_threshold_writable(struct cxl_cmd *cmd) +{ + cmd_alert_get_prog_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_PROG_ALERTS_LIEF_USED_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_writable( + struct cxl_cmd *cmd) +{ + cmd_alert_get_prog_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_PROG_ALERTS_DEV_OVER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_writable( + struct cxl_cmd *cmd) +{ + cmd_alert_get_prog_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_PROG_ALERTS_DEV_UNDER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_writable( + struct cxl_cmd *cmd) +{ + cmd_alert_get_prog_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_PROG_ALERTS_CORRECTED_VOLATILE_MEM_ERR_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_writable( + struct cxl_cmd *cmd) +{ + cmd_alert_get_prog_alerts_field( + cmd, + CXL_CMD_ALERT_CONFIG_PROG_ALERTS_CORRECTED_PMEM_ERR_PROG_WARN_THRESHOLD_MASK); +} + +CXL_EXPORT int +cxl_cmd_alert_config_get_life_used_crit_alert_threshold(struct cxl_cmd *cmd) +{ + cmd_get_field_u8(cmd, get_alert_config, GET_ALERT_CONFIG, + life_used_crit_alert_threshold); +} + +CXL_EXPORT int +cxl_cmd_alert_config_get_life_used_prog_warn_threshold(struct cxl_cmd *cmd) +{ + cmd_get_field_u8(cmd, get_alert_config, GET_ALERT_CONFIG, + life_used_prog_warn_threshold); +} + +CXL_EXPORT int +cxl_cmd_alert_config_get_dev_over_temperature_crit_alert_threshold( + struct cxl_cmd *cmd) +{ + cmd_get_field_u16(cmd, get_alert_config, GET_ALERT_CONFIG, + dev_over_temperature_crit_alert_threshold); +} + +CXL_EXPORT int +cxl_cmd_alert_config_get_dev_under_temperature_crit_alert_threshold( + struct cxl_cmd *cmd) +{ + cmd_get_field_u16(cmd, get_alert_config, GET_ALERT_CONFIG, + dev_under_temperature_crit_alert_threshold); +} + +CXL_EXPORT int +cxl_cmd_alert_config_get_dev_over_temperature_prog_warn_threshold( + struct cxl_cmd *cmd) +{ + cmd_get_field_u16(cmd, get_alert_config, GET_ALERT_CONFIG, + dev_over_temperature_prog_warn_threshold); +} + +CXL_EXPORT int +cxl_cmd_alert_config_get_dev_under_temperature_prog_warn_threshold( + struct cxl_cmd *cmd) +{ + cmd_get_field_u16(cmd, get_alert_config, GET_ALERT_CONFIG, + dev_under_temperature_prog_warn_threshold); +} + +CXL_EXPORT int +cxl_cmd_alert_config_get_corrected_volatile_mem_err_prog_warn_threshold( + struct cxl_cmd *cmd) +{ + cmd_get_field_u16(cmd, get_alert_config, GET_ALERT_CONFIG, + corrected_volatile_mem_err_prog_warn_threshold); +} + +CXL_EXPORT int cxl_cmd_alert_config_get_corrected_pmem_err_prog_warn_threshold( + struct cxl_cmd *cmd) +{ + cmd_get_field_u16(cmd, get_alert_config, GET_ALERT_CONFIG, + corrected_pmem_err_prog_warn_threshold); +} + CXL_EXPORT struct cxl_cmd *cxl_cmd_new_get_health_info( struct cxl_memdev *memdev) { diff --git a/cxl/lib/libcxl.sym b/cxl/lib/libcxl.sym index 8bb91e0..d63fde9 100644 --- a/cxl/lib/libcxl.sym +++ b/cxl/lib/libcxl.sym @@ -217,3 +217,26 @@ global: cxl_decoder_get_max_available_extent; cxl_decoder_get_region; } LIBCXL_2; + +LIBCXL_4 { +global: + cxl_cmd_new_get_alert_config; + cxl_cmd_alert_config_life_used_prog_warn_threshold_valid; + cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_valid; + cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_valid; + cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_valid; + cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_valid; + cxl_cmd_alert_config_life_used_prog_warn_threshold_writable; + cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_writable; + cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_writable; + cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_writable; + cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_writable; + cxl_cmd_alert_config_get_life_used_crit_alert_threshold; + cxl_cmd_alert_config_get_life_used_prog_warn_threshold; + cxl_cmd_alert_config_get_dev_over_temperature_crit_alert_threshold; + cxl_cmd_alert_config_get_dev_under_temperature_crit_alert_threshold; + cxl_cmd_alert_config_get_dev_over_temperature_prog_warn_threshold; + cxl_cmd_alert_config_get_dev_under_temperature_prog_warn_threshold; + cxl_cmd_alert_config_get_corrected_volatile_mem_err_prog_warn_threshold; + cxl_cmd_alert_config_get_corrected_pmem_err_prog_warn_threshold; +} LIBCXL_3; diff --git a/cxl/lib/private.h b/cxl/lib/private.h index 437eade..ee902c0 100644 --- a/cxl/lib/private.h +++ b/cxl/lib/private.h @@ -228,6 +228,44 @@ struct cxl_cmd_get_health_info { le32 pmem_errors; } __attribute__((packed)); +/* CXL 3.0 8.2.9.8.3.2 Get Alert Configuration */ +struct cxl_cmd_get_alert_config { + u8 valid_alerts; + u8 programmable_alerts; + u8 life_used_crit_alert_threshold; + u8 life_used_prog_warn_threshold; + le16 dev_over_temperature_crit_alert_threshold; + le16 dev_under_temperature_crit_alert_threshold; + le16 dev_over_temperature_prog_warn_threshold; + le16 dev_under_temperature_prog_warn_threshold; + le16 corrected_volatile_mem_err_prog_warn_threshold; + le16 corrected_pmem_err_prog_warn_threshold; +} __attribute__((packed)); + +/* CXL 3.0 8.2.9.8.3.2 Get Alert Configuration Byte 0 Valid Alerts */ +#define CXL_CMD_ALERT_CONFIG_VALID_ALERTS_LIFE_USED_PROG_WARN_THRESHOLD_MASK \ + BIT(0) +#define CXL_CMD_ALERT_CONFIG_VALID_ALERTS_DEV_OVER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK \ + BIT(1) +#define CXL_CMD_ALERT_CONFIG_VALID_ALERTS_DEV_UNDER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK \ + BIT(2) +#define CXL_CMD_ALERT_CONFIG_VALID_ALERTS_CORRECTED_VOLATILE_MEM_ERR_PROG_WARN_THRESHOLD_MASK \ + BIT(3) +#define CXL_CMD_ALERT_CONFIG_VALID_ALERTS_CORRECTED_PMEM_ERR_PROG_WARN_THRESHOLD_MASK \ + BIT(4) + +/* CXL 3.0 8.2.9.8.3.2 Get Alert Configuration Byte 1 Programmable Alerts */ +#define CXL_CMD_ALERT_CONFIG_PROG_ALERTS_LIEF_USED_PROG_WARN_THRESHOLD_MASK \ + BIT(0) +#define CXL_CMD_ALERT_CONFIG_PROG_ALERTS_DEV_OVER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK \ + BIT(1) +#define CXL_CMD_ALERT_CONFIG_PROG_ALERTS_DEV_UNDER_TEMPERATURE_PROG_WARN_THRESHOLD_MASK \ + BIT(2) +#define CXL_CMD_ALERT_CONFIG_PROG_ALERTS_CORRECTED_VOLATILE_MEM_ERR_PROG_WARN_THRESHOLD_MASK \ + BIT(3) +#define CXL_CMD_ALERT_CONFIG_PROG_ALERTS_CORRECTED_PMEM_ERR_PROG_WARN_THRESHOLD_MASK \ + BIT(4) + struct cxl_cmd_get_partition { le64 active_volatile; le64 active_persistent; diff --git a/cxl/libcxl.h b/cxl/libcxl.h index 9fe4e99..8b4b182 100644 --- a/cxl/libcxl.h +++ b/cxl/libcxl.h @@ -354,6 +354,41 @@ int cxl_cmd_health_info_get_temperature(struct cxl_cmd *cmd); int cxl_cmd_health_info_get_dirty_shutdowns(struct cxl_cmd *cmd); int cxl_cmd_health_info_get_volatile_errors(struct cxl_cmd *cmd); int cxl_cmd_health_info_get_pmem_errors(struct cxl_cmd *cmd); +struct cxl_cmd *cxl_cmd_new_get_alert_config(struct cxl_memdev *memdev); +int cxl_cmd_alert_config_life_used_prog_warn_threshold_valid( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_valid( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_valid( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_valid( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_valid( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_life_used_prog_warn_threshold_writable( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_writable( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_writable( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_writable( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_writable( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_life_used_crit_alert_threshold(struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_life_used_prog_warn_threshold(struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_dev_over_temperature_crit_alert_threshold( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_dev_under_temperature_crit_alert_threshold( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_dev_over_temperature_prog_warn_threshold( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_dev_under_temperature_prog_warn_threshold( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_corrected_volatile_mem_err_prog_warn_threshold( + struct cxl_cmd *cmd); +int cxl_cmd_alert_config_get_corrected_pmem_err_prog_warn_threshold( + struct cxl_cmd *cmd); struct cxl_cmd *cxl_cmd_new_read_label(struct cxl_memdev *memdev, unsigned int offset, unsigned int length); ssize_t cxl_cmd_read_label_get_payload(struct cxl_cmd *cmd, void *buf, From patchwork Mon Oct 31 23:54:50 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Zhang X-Patchwork-Id: 13026517 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 67655FA3741 for ; Mon, 31 Oct 2022 23:55:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229868AbiJaXzB (ORCPT ); Mon, 31 Oct 2022 19:55:01 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42388 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229642AbiJaXzA (ORCPT ); Mon, 31 Oct 2022 19:55:00 -0400 Received: from mx0a-00082601.pphosted.com (mx0a-00082601.pphosted.com [67.231.145.42]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5E432120A7 for ; Mon, 31 Oct 2022 16:54:59 -0700 (PDT) Received: from pps.filterd (m0109333.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 29VMPCpe006418 for ; Mon, 31 Oct 2022 16:54:59 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=meta.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=s2048-2021-q4; bh=7jcySguExvEgSiLCeKUiaKl8K9OnQVjePJRZ9qf0/vo=; b=NoECQ8pJgkj6qdtZvBwHMsqvdPZzWmwDhfUIqtmjlOGyFWqz6H58QqDaEljZHgixjWsB FJ28uwxDOB/Xn7QDNZKpptAncSU801Cu8SiUeJ/Uf+Hka4Yxq2o7nioigFEzN93Dvu8b RT8OShd7ESGRDyX1Rydn14497GvWeL3kP0nXrxadHTuOOjb+qbCw7pUirzgT4SYwCXr5 MVmc1KX/JGDd6SyTqV83DuHT61wgTLp5B2iswh3Gm4VNjKcaIIhVncxCuCfL28dh8C+h 7zbr5wPXbjhiVfq5TOXTC6W9EqqFaHtZ3THPKVwq6Vq+v4tbQ41qUv786LxtcZ11RKCq sQ== Received: from mail.thefacebook.com ([163.114.132.120]) by mx0a-00082601.pphosted.com (PPS) with ESMTPS id 3kh07pc1td-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Mon, 31 Oct 2022 16:54:59 -0700 Received: from twshared13315.14.prn3.facebook.com (2620:10d:c085:108::8) by mail.thefacebook.com (2620:10d:c085:21d::5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.31; Mon, 31 Oct 2022 16:54:58 -0700 Received: by devvm7073.vll0.facebook.com (Postfix, from userid 175343) id 8890B29EC76B; Mon, 31 Oct 2022 16:54:55 -0700 (PDT) From: Jonathan Zhang To: , , , CC: Jonathan Zhang , Jonathan Zhang Subject: [ndctl PATCH V3 2/2] cxl: display alert configuration fields Date: Mon, 31 Oct 2022 16:54:50 -0700 Message-ID: <20221031235450.1775068-3-jonzhang@meta.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20221031235450.1775068-1-jonzhang@meta.com> References: <20221031235450.1775068-1-jonzhang@meta.com> MIME-Version: 1.0 X-FB-Internal: Safe X-Proofpoint-GUID: Der1Y7HW9E_r2RqYlM0JSkPDwn0EoE8H X-Proofpoint-ORIG-GUID: Der1Y7HW9E_r2RqYlM0JSkPDwn0EoE8H X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-10-31_21,2022-10-31_01,2022-06-22_01 Precedence: bulk List-ID: X-Mailing-List: linux-cxl@vger.kernel.org From: Jonathan Zhang CXL device's critical alert and programmable warning configurations are displayed when: * list command is issued. * "--alert-config" is issued. Signed-off-by: Jonathan Zhang --- Documentation/cxl/cxl-list.txt | 33 ++++++ cxl/filter.c | 2 + cxl/filter.h | 1 + cxl/json.c | 185 +++++++++++++++++++++++++++++++++ cxl/list.c | 6 +- util/json.h | 1 + 6 files changed, 226 insertions(+), 2 deletions(-) diff --git a/Documentation/cxl/cxl-list.txt b/Documentation/cxl/cxl-list.txt index 14a2b4b..7a7a503 100644 --- a/Documentation/cxl/cxl-list.txt +++ b/Documentation/cxl/cxl-list.txt @@ -219,6 +219,39 @@ OPTIONS } ] ---- +-A:: +--alert-config:: + Include alert configuration in the memdev listing. Example listing: +---- +# cxl list -m mem0 -A +[ + { + "memdev":"mem0", + "pmem_size":0, + "ram_size":273535729664, + "alert":{ + "life_used_prog_warn_threshold_valid":false, + "dev_over_temperature_prog_warn_threshold_valid":false, + "dev_under_temperature_prog_warn_threshold_valid":false, + "corrected_volatile_mem_err_prog_warn_threshold_valid":true, + "corrected_pmem_err_prog_warn_threshold_valid":false, + "life_used_prog_warn_threshold_writable":false, + "dev_over_temperature_prog_warn_threshold_writable":false, + "dev_under_temperature_prog_warn_threshold_writable":false, + "corrected_volatile_mem_err_prog_warn_threshold_writable":true, + "corrected_pmem_err_prog_warn_threshold_writable":false, + "life_used_crit_alert_threshold":0, + "life_used_prog_warn_threshold":0, + "dev_over_temperature_crit_alert_threshold":0, + "dev_under_temperature_crit_alert_threshold":0, + "dev_over_temperature_prog_warn_threshold":0, + "dev_under_temperature_prog_warn_threshold":0, + "corrected_volatile_mem_err_prog_warn_threshold":0, + "corrected_pmem_err_prog_warn_threshold":0 + }, + } +] +---- -B:: --buses:: diff --git a/cxl/filter.c b/cxl/filter.c index 56c6599..beb64de 100644 --- a/cxl/filter.c +++ b/cxl/filter.c @@ -686,6 +686,8 @@ static unsigned long params_to_flags(struct cxl_filter_params *param) flags |= UTIL_JSON_TARGETS; if (param->partition) flags |= UTIL_JSON_PARTITION; + if (param->alert_config) + flags |= UTIL_JSON_ALERT_CONFIG; return flags; } diff --git a/cxl/filter.h b/cxl/filter.h index 256df49..cd514c9 100644 --- a/cxl/filter.h +++ b/cxl/filter.h @@ -26,6 +26,7 @@ struct cxl_filter_params { bool human; bool health; bool partition; + bool alert_config; int verbose; struct log_ctx ctx; }; diff --git a/cxl/json.c b/cxl/json.c index 63c1751..2a56e27 100644 --- a/cxl/json.c +++ b/cxl/json.c @@ -185,6 +185,185 @@ err_jobj: return NULL; } +static struct json_object * +util_cxl_memdev_alert_config_to_json(struct cxl_memdev *memdev, + unsigned long flags) +{ + struct json_object *jalert_config; + struct json_object *jobj; + struct cxl_cmd *cmd; + int rc; + + jalert_config = json_object_new_object(); + if (!jalert_config) + return NULL; + if (!memdev) + goto err_jobj; + + cmd = cxl_cmd_new_get_alert_config(memdev); + if (!cmd) + goto err_jobj; + + rc = cxl_cmd_submit(cmd); + if (rc < 0) + goto err_cmd; + rc = cxl_cmd_get_mbox_status(cmd); + if (rc != 0) + goto err_cmd; + + rc = cxl_cmd_alert_config_life_used_prog_warn_threshold_valid(cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add(jalert_config, + "life_used_prog_warn_threshold_valid", + jobj); + + rc = cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_valid( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_over_temperature_prog_warn_threshold_valid", jobj); + + rc = cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_valid( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_under_temperature_prog_warn_threshold_valid", + jobj); + + rc = cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_valid( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "corrected_volatile_mem_err_prog_warn_threshold_valid", + jobj); + + rc = cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_valid( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "corrected_pmem_err_prog_warn_threshold_valid", + jobj); + + rc = cxl_cmd_alert_config_life_used_prog_warn_threshold_writable(cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add(jalert_config, + "life_used_prog_warn_threshold_writable", + jobj); + + rc = cxl_cmd_alert_config_dev_over_temperature_prog_warn_threshold_writable( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_over_temperature_prog_warn_threshold_writable", + jobj); + + rc = cxl_cmd_alert_config_dev_under_temperature_prog_warn_threshold_writable( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_under_temperature_prog_warn_threshold_writable", + jobj); + + rc = cxl_cmd_alert_config_corrected_volatile_mem_err_prog_warn_threshold_writable( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "corrected_volatile_mem_err_prog_warn_threshold_writable", + jobj); + + rc = cxl_cmd_alert_config_corrected_pmem_err_prog_warn_threshold_writable( + cmd); + jobj = json_object_new_boolean(rc); + if (jobj) + json_object_object_add( + jalert_config, + "corrected_pmem_err_prog_warn_threshold_writable", jobj); + + rc = cxl_cmd_alert_config_get_life_used_crit_alert_threshold(cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add(jalert_config, + "life_used_crit_alert_threshold", jobj); + + rc = cxl_cmd_alert_config_get_life_used_prog_warn_threshold(cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add(jalert_config, + "life_used_prog_warn_threshold", jobj); + + rc = cxl_cmd_alert_config_get_dev_over_temperature_crit_alert_threshold( + cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_over_temperature_crit_alert_threshold", jobj); + + rc = cxl_cmd_alert_config_get_dev_under_temperature_crit_alert_threshold( + cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_under_temperature_crit_alert_threshold", jobj); + + rc = cxl_cmd_alert_config_get_dev_over_temperature_prog_warn_threshold( + cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_over_temperature_prog_warn_threshold", jobj); + + rc = cxl_cmd_alert_config_get_dev_under_temperature_prog_warn_threshold( + cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add( + jalert_config, + "dev_under_temperature_prog_warn_threshold", jobj); + + rc = cxl_cmd_alert_config_get_corrected_volatile_mem_err_prog_warn_threshold( + cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add( + jalert_config, + "corrected_volatile_mem_err_prog_warn_threshold", jobj); + + rc = cxl_cmd_alert_config_get_corrected_pmem_err_prog_warn_threshold( + cmd); + jobj = json_object_new_int(rc); + if (jobj) + json_object_object_add(jalert_config, + "corrected_pmem_err_prog_warn_threshold", jobj); + + cxl_cmd_unref(cmd); + return jalert_config; + +err_cmd: + cxl_cmd_unref(cmd); +err_jobj: + json_object_put(jalert_config); + return NULL; +} + /* * Present complete view of memdev partition by presenting fields from * both GET_PARTITION_INFO and IDENTIFY mailbox commands. @@ -330,6 +509,12 @@ struct json_object *util_cxl_memdev_to_json(struct cxl_memdev *memdev, json_object_object_add(jdev, "health", jobj); } + if (flags & UTIL_JSON_ALERT_CONFIG) { + jobj = util_cxl_memdev_alert_config_to_json(memdev, flags); + if (jobj) + json_object_object_add(jdev, "alert_config", jobj); + } + serial = cxl_memdev_get_serial(memdev); if (serial < ULLONG_MAX) { jobj = util_json_object_hex(serial, flags); diff --git a/cxl/list.c b/cxl/list.c index 8c48fbb..5dd76b9 100644 --- a/cxl/list.c +++ b/cxl/list.c @@ -52,8 +52,9 @@ static const struct option options[] = { "include memory device health information"), OPT_BOOLEAN('I', "partition", ¶m.partition, "include memory device partition information"), - OPT_INCR('v', "verbose", ¶m.verbose, - "increase output detail"), + OPT_BOOLEAN('A', "alert-config", ¶m.alert_config, + "include alert configuration information"), + OPT_INCR('v', "verbose", ¶m.verbose, "increase output detail"), #ifdef ENABLE_DEBUG OPT_BOOLEAN(0, "debug", &debug, "debug list walk"), #endif @@ -113,6 +114,7 @@ int cmd_list(int argc, const char **argv, struct cxl_ctx *ctx) case 3: param.health = true; param.partition = true; + param.alert_config = true; /* fallthrough */ case 2: param.idle = true; diff --git a/util/json.h b/util/json.h index 73bb9f0..ea370df 100644 --- a/util/json.h +++ b/util/json.h @@ -20,6 +20,7 @@ enum util_json_flags { UTIL_JSON_HEALTH = (1 << 10), UTIL_JSON_TARGETS = (1 << 11), UTIL_JSON_PARTITION = (1 << 12), + UTIL_JSON_ALERT_CONFIG = (1 << 13), }; void util_display_json_array(FILE *f_out, struct json_object *jarray,