From patchwork Mon Feb 7 23:10:15 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alison Schofield X-Patchwork-Id: 12737945 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9801E2C9C for ; Mon, 7 Feb 2022 23:06:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644275180; x=1675811180; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=a1uUUbOO0AxoqFBQlTh5tCofZu6Z8iVnPREr/9wVts0=; b=i+oVxwNJMmMD5x2ak7JfRVbQ7qc+Ogo2JPV0Fqb4ldSBIop+xoPUMTeH COV+OhWKM+ww7pNVyult47TedaiujVpMKx0G19Umn2EPWsDV24cp1oEer /XD7k4BAIUH6Ay0f+6rg4dx7ZkYDKp+dXTAyGludavWEl4uEaeUy6SYJ7 19YNE9cBYSWoJz1vVm7IJHQjClvbmLNRahziL30InY5G62miZ/fUXjDQ2 XBjtx06keZFjjClm902VM8PSsZvklNUxQpszRVe/q+oCvbFPol3s5rA+B qbDlxaFhC00b5J2DLG94MCCiXhI8/ixG7U82km1eHUhn/ZAFm/0MyQQgR w==; X-IronPort-AV: E=McAfee;i="6200,9189,10251"; a="273351892" X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="273351892" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="632639197" Received: from alison-desk.jf.intel.com (HELO localhost) ([10.54.74.41]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 From: alison.schofield@intel.com To: Ben Widawsky , Dan Williams , Ira Weiny , Vishal Verma Cc: Alison Schofield , nvdimm@lists.linux.dev, linux-cxl@vger.kernel.org Subject: [ndctl PATCH v4 1/6] libcxl: add GET_PARTITION_INFO mailbox command and accessors Date: Mon, 7 Feb 2022 15:10:15 -0800 Message-Id: <396ccc39525b3eb829acd4e06f704f6fb57a94a8.1644271559.git.alison.schofield@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: Precedence: bulk X-Mailing-List: nvdimm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Alison Schofield Users need access to the CXL GET_PARTITION_INFO mailbox command to inspect and confirm changes to the partition layout of a memory device. Add libcxl APIs to create a new GET_PARTITION_INFO mailbox command, the command output data structure (privately), and accessor APIs to return the different fields in the partition info output. Per the CXL 2.0 specification, devices report partition capacities as multiples of 256MB. Define and use a capacity multiplier to convert the raw data into bytes for user consumption. Use byte format as the norm for all capacity values produced or consumed using CXL Mailbox commands. Signed-off-by: Alison Schofield Reviewed-by: Dan Williams --- Documentation/cxl/lib/libcxl.txt | 1 + cxl/lib/libcxl.c | 57 ++++++++++++++++++++++++++++++++ cxl/lib/libcxl.sym | 5 +++ cxl/lib/private.h | 10 ++++++ cxl/libcxl.h | 5 +++ util/size.h | 1 + 6 files changed, 79 insertions(+) diff --git a/Documentation/cxl/lib/libcxl.txt b/Documentation/cxl/lib/libcxl.txt index 4392b47..a6986ab 100644 --- a/Documentation/cxl/lib/libcxl.txt +++ b/Documentation/cxl/lib/libcxl.txt @@ -131,6 +131,7 @@ int cxl_memdev_read_label(struct cxl_memdev *memdev, void *buf, size_t length, size_t offset); int cxl_memdev_write_label(struct cxl_memdev *memdev, void *buf, size_t length, size_t offset); +struct cxl_cmd *cxl_cmd_new_get_partition(struct cxl_memdev *memdev); ---- diff --git a/cxl/lib/libcxl.c b/cxl/lib/libcxl.c index e0b443f..33cf06b 100644 --- a/cxl/lib/libcxl.c +++ b/cxl/lib/libcxl.c @@ -1985,6 +1985,12 @@ static int cxl_cmd_validate_status(struct cxl_cmd *cmd, u32 id) return 0; } +static unsigned long long +capacity_to_bytes(unsigned long long size) +{ + return le64_to_cpu(size) * CXL_CAPACITY_MULTIPLIER; +} + /* Helpers for health_info fields (no endian conversion) */ #define cmd_get_field_u8(cmd, n, N, field) \ do { \ @@ -2371,6 +2377,57 @@ CXL_EXPORT ssize_t cxl_cmd_read_label_get_payload(struct cxl_cmd *cmd, return length; } +CXL_EXPORT struct cxl_cmd *cxl_cmd_new_get_partition(struct cxl_memdev *memdev) +{ + return cxl_cmd_new_generic(memdev, + CXL_MEM_COMMAND_ID_GET_PARTITION_INFO); +} + +static struct cxl_cmd_get_partition * +cmd_to_get_partition(struct cxl_cmd *cmd) +{ + if (cxl_cmd_validate_status(cmd, CXL_MEM_COMMAND_ID_GET_PARTITION_INFO)) + return NULL; + + return cmd->output_payload; +} + +CXL_EXPORT unsigned long long +cxl_cmd_partition_get_active_volatile_size(struct cxl_cmd *cmd) +{ + struct cxl_cmd_get_partition *c; + + c = cmd_to_get_partition(cmd); + return c ? capacity_to_bytes(c->active_volatile) : ULLONG_MAX; +} + +CXL_EXPORT unsigned long long +cxl_cmd_partition_get_active_persistent_size(struct cxl_cmd *cmd) +{ + struct cxl_cmd_get_partition *c; + + c = cmd_to_get_partition(cmd); + return c ? capacity_to_bytes(c->active_persistent) : ULLONG_MAX; +} + +CXL_EXPORT unsigned long long +cxl_cmd_partition_get_next_volatile_size(struct cxl_cmd *cmd) +{ + struct cxl_cmd_get_partition *c; + + c = cmd_to_get_partition(cmd); + return c ? capacity_to_bytes(c->next_volatile) : ULLONG_MAX; +} + +CXL_EXPORT unsigned long long +cxl_cmd_partition_get_next_persistent_size(struct cxl_cmd *cmd) +{ + struct cxl_cmd_get_partition *c; + + c = cmd_to_get_partition(cmd); + return c ? capacity_to_bytes(c->next_persistent) : ULLONG_MAX; +} + CXL_EXPORT int cxl_cmd_submit(struct cxl_cmd *cmd) { struct cxl_memdev *memdev = cmd->memdev; diff --git a/cxl/lib/libcxl.sym b/cxl/lib/libcxl.sym index e56a2bf..509e62d 100644 --- a/cxl/lib/libcxl.sym +++ b/cxl/lib/libcxl.sym @@ -155,4 +155,9 @@ global: cxl_dport_get_port; cxl_port_get_dport_by_memdev; cxl_dport_maps_memdev; + cxl_cmd_new_get_partition; + cxl_cmd_partition_get_active_volatile_size; + cxl_cmd_partition_get_active_persistent_size; + cxl_cmd_partition_get_next_volatile_size; + cxl_cmd_partition_get_next_persistent_size; } LIBCXL_1; diff --git a/cxl/lib/private.h b/cxl/lib/private.h index f483c30..7f3a562 100644 --- a/cxl/lib/private.h +++ b/cxl/lib/private.h @@ -7,6 +7,7 @@ #include #include #include +#include #define CXL_EXPORT __attribute__ ((visibility("default"))) @@ -185,6 +186,15 @@ struct cxl_cmd_get_health_info { le32 pmem_errors; } __attribute__((packed)); +struct cxl_cmd_get_partition { + le64 active_volatile; + le64 active_persistent; + le64 next_volatile; + le64 next_persistent; +} __attribute__((packed)); + +#define CXL_CAPACITY_MULTIPLIER SZ_256M + /* CXL 2.0 8.2.9.5.3 Byte 0 Health Status */ #define CXL_CMD_HEALTH_INFO_STATUS_MAINTENANCE_NEEDED_MASK BIT(0) #define CXL_CMD_HEALTH_INFO_STATUS_PERFORMANCE_DEGRADED_MASK BIT(1) diff --git a/cxl/libcxl.h b/cxl/libcxl.h index 3b2293b..2c0a8d1 100644 --- a/cxl/libcxl.h +++ b/cxl/libcxl.h @@ -242,6 +242,11 @@ ssize_t cxl_cmd_read_label_get_payload(struct cxl_cmd *cmd, void *buf, unsigned int length); struct cxl_cmd *cxl_cmd_new_write_label(struct cxl_memdev *memdev, void *buf, unsigned int offset, unsigned int length); +struct cxl_cmd *cxl_cmd_new_get_partition(struct cxl_memdev *memdev); +unsigned long long cxl_cmd_partition_get_active_volatile_size(struct cxl_cmd *cmd); +unsigned long long cxl_cmd_partition_get_active_persistent_size(struct cxl_cmd *cmd); +unsigned long long cxl_cmd_partition_get_next_volatile_size(struct cxl_cmd *cmd); +unsigned long long cxl_cmd_partition_get_next_persistent_size(struct cxl_cmd *cmd); #ifdef __cplusplus } /* extern "C" */ diff --git a/util/size.h b/util/size.h index a0f3593..e72467f 100644 --- a/util/size.h +++ b/util/size.h @@ -15,6 +15,7 @@ #define SZ_4M 0x00400000 #define SZ_16M 0x01000000 #define SZ_64M 0x04000000 +#define SZ_256M 0x10000000 #define SZ_1G 0x40000000 #define SZ_1T 0x10000000000ULL From patchwork Mon Feb 7 23:10:16 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alison Schofield X-Patchwork-Id: 12737946 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2C9942CA2 for ; Mon, 7 Feb 2022 23:06:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644275182; x=1675811182; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=AT+VHGNddjvlGjH8cs3QAwopGuBl6WtzDH74xT4MqOo=; b=Z4euPxZ2h5bTELqfFTs76J6iwfngD3qzUpYEytRjGUmZuzvfNiCVxzLL HK2dbj8InzesUkOEtfACNKaTheqTQPEOc7FM3wyzf+mzYK+UMeyplJPTq 9r+nyX2dFqRRbB75XCrxXmqGjnuI+n9okAJmMLdoB4QDwpN3JpI2oh6zl z5aoCUfKJoqlq+pxFGJFScpGCoF0RG6ik04pGdW0sI62dIP4kfMclKpYQ LvbXpeCA0/c/C9xtSnaMPGtVspFitKifEkUP32sjfHHX2GS5sl66q3pEw TSZYz0pS29bvsHgKARz69CpzOWxvw0/yMkujZsDLLVXpTCUSEreB34gJL g==; X-IronPort-AV: E=McAfee;i="6200,9189,10251"; a="273351893" X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="273351893" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="632639200" Received: from alison-desk.jf.intel.com (HELO localhost) ([10.54.74.41]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 From: alison.schofield@intel.com To: Ben Widawsky , Dan Williams , Ira Weiny , Vishal Verma Cc: Alison Schofield , nvdimm@lists.linux.dev, linux-cxl@vger.kernel.org Subject: [ndctl PATCH v4 2/6] libcxl: add accessors for capacity fields of the IDENTIFY command Date: Mon, 7 Feb 2022 15:10:16 -0800 Message-Id: <034755a71999a66da79356ec7efbabeaa4eacd88.1644271559.git.alison.schofield@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: Precedence: bulk X-Mailing-List: nvdimm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Alison Schofield Users need access to a few additional fields reported by the IDENTIFY mailbox command: total, volatile_only, and persistent_only capacities. These values are useful when defining partition layouts. Add accessors to the libcxl API to retrieve these values from the IDENTIFY command. The fields are specified in multiples of 256MB per the CXL 2.0 spec. Use the capacity multiplier to convert the raw data into bytes for user consumption. Signed-off-by: Alison Schofield Reviewed-by: Dan Williams --- cxl/lib/libcxl.c | 36 ++++++++++++++++++++++++++++++++++++ cxl/lib/libcxl.sym | 3 +++ cxl/libcxl.h | 3 +++ 3 files changed, 42 insertions(+) diff --git a/cxl/lib/libcxl.c b/cxl/lib/libcxl.c index 33cf06b..e9d7762 100644 --- a/cxl/lib/libcxl.c +++ b/cxl/lib/libcxl.c @@ -2322,6 +2322,42 @@ CXL_EXPORT unsigned int cxl_cmd_identify_get_label_size(struct cxl_cmd *cmd) return le32_to_cpu(id->lsa_size); } +static struct cxl_cmd_identify * +cmd_to_identify(struct cxl_cmd *cmd) +{ + if (cxl_cmd_validate_status(cmd, CXL_MEM_COMMAND_ID_IDENTIFY)) + return NULL; + + return cmd->output_payload; +} + +CXL_EXPORT unsigned long long +cxl_cmd_identify_get_total_size(struct cxl_cmd *cmd) +{ + struct cxl_cmd_identify *c; + + c = cmd_to_identify(cmd); + return c ? capacity_to_bytes(c->total_capacity) : ULLONG_MAX; +} + +CXL_EXPORT unsigned long long +cxl_cmd_identify_get_volatile_only_size(struct cxl_cmd *cmd) +{ + struct cxl_cmd_identify *c; + + c = cmd_to_identify(cmd); + return c ? capacity_to_bytes(c->volatile_capacity) : ULLONG_MAX; +} + +CXL_EXPORT unsigned long long +cxl_cmd_identify_get_persistent_only_size(struct cxl_cmd *cmd) +{ + struct cxl_cmd_identify *c; + + c = cmd_to_identify(cmd); + return c ? capacity_to_bytes(c->persistent_capacity) : ULLONG_MAX; +} + CXL_EXPORT struct cxl_cmd *cxl_cmd_new_raw(struct cxl_memdev *memdev, int opcode) { diff --git a/cxl/lib/libcxl.sym b/cxl/lib/libcxl.sym index 509e62d..5ac6e9b 100644 --- a/cxl/lib/libcxl.sym +++ b/cxl/lib/libcxl.sym @@ -160,4 +160,7 @@ global: cxl_cmd_partition_get_active_persistent_size; cxl_cmd_partition_get_next_volatile_size; cxl_cmd_partition_get_next_persistent_size; + cxl_cmd_identify_get_total_size; + cxl_cmd_identify_get_volatile_only_size; + cxl_cmd_identify_get_persistent_only_size; } LIBCXL_1; diff --git a/cxl/libcxl.h b/cxl/libcxl.h index 2c0a8d1..6e18e84 100644 --- a/cxl/libcxl.h +++ b/cxl/libcxl.h @@ -201,6 +201,9 @@ int cxl_cmd_get_mbox_status(struct cxl_cmd *cmd); int cxl_cmd_get_out_size(struct cxl_cmd *cmd); struct cxl_cmd *cxl_cmd_new_identify(struct cxl_memdev *memdev); int cxl_cmd_identify_get_fw_rev(struct cxl_cmd *cmd, char *fw_rev, int fw_len); +unsigned long long cxl_cmd_identify_get_total_size(struct cxl_cmd *cmd); +unsigned long long cxl_cmd_identify_get_volatile_only_size(struct cxl_cmd *cmd); +unsigned long long cxl_cmd_identify_get_persistent_only_size(struct cxl_cmd *cmd); unsigned long long cxl_cmd_identify_get_partition_align(struct cxl_cmd *cmd); unsigned int cxl_cmd_identify_get_label_size(struct cxl_cmd *cmd); struct cxl_cmd *cxl_cmd_new_get_health_info(struct cxl_memdev *memdev); From patchwork Mon Feb 7 23:10:17 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alison Schofield X-Patchwork-Id: 12737947 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 57BDB2C9C for ; Mon, 7 Feb 2022 23:06:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644275182; x=1675811182; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=F44UHN3rHqegtj2FoCEG5GqNLVnIuqt9mQoN6J5UurI=; b=Bw3U3POQ1uKCetpjU/pBq+7HZ1Yuv8y3kFMQtmpZWjVOcuQAUOVk/tWe tVKRJdIUjMqSf95WrivdXBILK5LLRvGcib6El5fv4ayOj4/YNJoUV4EN3 CP+lAKu8dD5Nxh8VHUF33Hh0+hgZCRhde1PktgrPZrmV1hybLm18Pgque GeRYNBaxZNZx2PSufjKwsH0TV1Rg+dhz+FoUwDEihI1H/5O3izwi0C9G9 9doG+eZ6Uix9pYm8cjIdaGtr3XuO9UowdA4GLo8iysxmq1tG0OUbZNAqZ PF2BwmQtaAvRaux75IbNfnEjMaFqOJOny8a7BZTT5Q4jjE/JJJcirEa1l w==; X-IronPort-AV: E=McAfee;i="6200,9189,10251"; a="273351894" X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="273351894" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="632639204" Received: from alison-desk.jf.intel.com (HELO localhost) ([10.54.74.41]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 From: alison.schofield@intel.com To: Ben Widawsky , Dan Williams , Ira Weiny , Vishal Verma Cc: Alison Schofield , nvdimm@lists.linux.dev, linux-cxl@vger.kernel.org Subject: [ndctl PATCH v4 3/6] libcxl: return the partition alignment field in bytes Date: Mon, 7 Feb 2022 15:10:17 -0800 Message-Id: X-Mailer: git-send-email 2.25.1 In-Reply-To: References: Precedence: bulk X-Mailing-List: nvdimm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Alison Schofield Per the CXL specification, the partition alignment field reports the alignment value in multiples of 256MB. In the libcxl API, values for all capacity fields are defined to return bytes. Update the partition alignment accessor to return bytes so that it is in sync with other capacity related fields. Signed-off-by: Alison Schofield --- cxl/lib/libcxl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cxl/lib/libcxl.c b/cxl/lib/libcxl.c index e9d7762..307e5c4 100644 --- a/cxl/lib/libcxl.c +++ b/cxl/lib/libcxl.c @@ -2306,7 +2306,7 @@ CXL_EXPORT unsigned long long cxl_cmd_identify_get_partition_align( if (cmd->status < 0) return cmd->status; - return le64_to_cpu(id->partition_align); + return capacity_to_bytes(id->partition_align); } CXL_EXPORT unsigned int cxl_cmd_identify_get_label_size(struct cxl_cmd *cmd) From patchwork Mon Feb 7 23:10:18 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alison Schofield X-Patchwork-Id: 12737948 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4E4382CA7 for ; Mon, 7 Feb 2022 23:06:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644275183; x=1675811183; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=nd7JQvx9kDBncdqOhCh9gJ15hHW2cHjxWuE85PIPins=; b=boSAJxx4l8jMch7iNLrpCAv5YmGv+FZicqVkWDLz1kLZXVgRR0kZ2u5e Txi8bDoioVYIza3Jbb8Z95H2nS0ptPBVJPIookRTOag3BsnT/0/EdLHti bsRx6DIyOJcGsg5saJTiAsGMLabqfEMjttRhFXjviwYCetluyhFWAKm5I Y+IQnZHskimXB92Jr44YgkDX5eITKZrWLFTOaZb25ejgjaOCuGR8oyLXN T4PZ9NEK+V9xHtHGheWkBL9aQ2yjeGYTQkeTW19QBCNSOgMWbEBaou7PY /VkiCipoOwwucIDpnMQ3fc7xT5kgP7Kv6G8Gs7y4fmrpUQfZ3+Odmaven A==; X-IronPort-AV: E=McAfee;i="6200,9189,10251"; a="273351895" X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="273351895" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:15 -0800 X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="632639207" Received: from alison-desk.jf.intel.com (HELO localhost) ([10.54.74.41]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 From: alison.schofield@intel.com To: Ben Widawsky , Dan Williams , Ira Weiny , Vishal Verma Cc: Alison Schofield , nvdimm@lists.linux.dev, linux-cxl@vger.kernel.org Subject: [ndctl PATCH v4 4/6] cxl: add memdev partition information to cxl-list Date: Mon, 7 Feb 2022 15:10:18 -0800 Message-Id: <5f548fa5a5f3b6416008099d6b21687bad5d7e3c.1644271559.git.alison.schofield@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: Precedence: bulk X-Mailing-List: nvdimm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Alison Schofield Users may want to check the partition information of a memory device using the CXL command line tool. This is useful for understanding the active, as well as creating the next, partition layout. Add an option to the 'cxl list' command to display partition information. Include all of the fields from GET_PARTITION_INFO and the partitioning related fields from the IDENTIFY mailbox command. Example: "partition_info":{ "active_volatile_size":273535729664, "active_persistent_size":0, "next_volatile_size":0, "next_persistent_size":0, "total_size":273535729664, "volatile_only_size":0, "persistent_only_size":0, "partition_alignment_size":268435456 } Signed-off-by: Alison Schofield Reviewed-by: Dan Williams --- Documentation/cxl/cxl-list.txt | 23 +++++++ cxl/filter.c | 2 + cxl/filter.h | 1 + cxl/json.c | 113 +++++++++++++++++++++++++++++++++ cxl/list.c | 2 + util/json.h | 1 + 6 files changed, 142 insertions(+) diff --git a/Documentation/cxl/cxl-list.txt b/Documentation/cxl/cxl-list.txt index 90e6d9f..86fc4e7 100644 --- a/Documentation/cxl/cxl-list.txt +++ b/Documentation/cxl/cxl-list.txt @@ -196,6 +196,29 @@ OPTIONS } ] ---- +-I:: +--partition:: + Include partition information in the memdev listing. Example listing: +---- +# cxl list -m mem0 -I +[ + { + "memdev":"mem0", + "pmem_size":0, + "ram_size":273535729664, + "partition_info":{ + "active_volatile_size":273535729664, + "active_persistent_size":0, + "next_volatile_size":0, + "next_persistent_size":0, + "total_size":273535729664, + "volatile_only_size":0, + "persistent_only_size":0, + "partition_alignment_size":268435456 + } + } +] +---- -B:: --buses:: diff --git a/cxl/filter.c b/cxl/filter.c index 925bf3a..b339642 100644 --- a/cxl/filter.c +++ b/cxl/filter.c @@ -581,6 +581,8 @@ static unsigned long params_to_flags(struct cxl_filter_params *param) flags |= UTIL_JSON_HEALTH; if (param->targets) flags |= UTIL_JSON_TARGETS; + if (param->partition) + flags |= UTIL_JSON_PARTITION; return flags; } diff --git a/cxl/filter.h b/cxl/filter.h index 5deabb3..697b777 100644 --- a/cxl/filter.h +++ b/cxl/filter.h @@ -23,6 +23,7 @@ struct cxl_filter_params { bool idle; bool human; bool health; + bool partition; struct log_ctx ctx; }; diff --git a/cxl/json.c b/cxl/json.c index f3b536e..69671b3 100644 --- a/cxl/json.c +++ b/cxl/json.c @@ -185,6 +185,114 @@ err_jobj: return NULL; } +/* + * Present complete view of memdev partition by presenting fields from + * both GET_PARTITION_INFO and IDENTIFY mailbox commands. + */ +static struct json_object *util_cxl_memdev_partition_to_json(struct cxl_memdev *memdev, + unsigned long flags) +{ + struct json_object *jobj = NULL; + struct json_object *jpart; + unsigned long long cap; + struct cxl_cmd *cmd; + int rc; + + jpart = json_object_new_object(); + if (!jpart) + return NULL; + if (!memdev) + goto err_jobj; + + /* Retrieve partition info in GET_PARTITION_INFO mbox cmd */ + cmd = cxl_cmd_new_get_partition(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; + + cap = cxl_cmd_partition_get_active_volatile_size(cmd); + if (cap != ULLONG_MAX) { + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, + "active_volatile_size", jobj); + } + cap = cxl_cmd_partition_get_active_persistent_size(cmd); + if (cap != ULLONG_MAX) { + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, + "active_persistent_size", jobj); + } + cap = cxl_cmd_partition_get_next_volatile_size(cmd); + if (cap != ULLONG_MAX) { + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, + "next_volatile_size", jobj); + } + cap = cxl_cmd_partition_get_next_persistent_size(cmd); + if (cap != ULLONG_MAX) { + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, + "next_persistent_size", jobj); + } + cxl_cmd_unref(cmd); + + /* Retrieve partition info in the IDENTIFY mbox cmd */ + cmd = cxl_cmd_new_identify(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; + + cap = cxl_cmd_identify_get_total_size(cmd); + if (cap != ULLONG_MAX) { + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, "total_size", jobj); + } + cap = cxl_cmd_identify_get_volatile_only_size(cmd); + if (cap != ULLONG_MAX) { + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, + "volatile_only_size", jobj); + } + cap = cxl_cmd_identify_get_persistent_only_size(cmd); + if (cap != ULLONG_MAX) { + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, + "persistent_only_size", jobj); + } + cap = cxl_cmd_identify_get_partition_align(cmd); + jobj = util_json_object_size(cap, flags); + if (jobj) + json_object_object_add(jpart, "partition_alignment_size", jobj); + + cxl_cmd_unref(cmd); + return jpart; + +err_cmd: + cxl_cmd_unref(cmd); +err_jobj: + json_object_put(jpart); + return NULL; +} + struct json_object *util_cxl_memdev_to_json(struct cxl_memdev *memdev, unsigned long flags) { @@ -239,6 +347,11 @@ struct json_object *util_cxl_memdev_to_json(struct cxl_memdev *memdev, json_object_object_add(jdev, "state", jobj); } + if (flags & UTIL_JSON_PARTITION) { + jobj = util_cxl_memdev_partition_to_json(memdev, flags); + if (jobj) + json_object_object_add(jdev, "partition_info", jobj); + } return jdev; } diff --git a/cxl/list.c b/cxl/list.c index de96ff9..1e9d441 100644 --- a/cxl/list.c +++ b/cxl/list.c @@ -48,6 +48,8 @@ static const struct option options[] = { "use human friendly number formats "), OPT_BOOLEAN('H', "health", ¶m.health, "include memory device health information "), + OPT_BOOLEAN('I', "partition", ¶m.partition, + "include memory device partition information "), #ifdef ENABLE_DEBUG OPT_BOOLEAN(0, "debug", &debug, "debug list walk"), #endif diff --git a/util/json.h b/util/json.h index e026df1..73bb9f0 100644 --- a/util/json.h +++ b/util/json.h @@ -19,6 +19,7 @@ enum util_json_flags { UTIL_JSON_DAX_MAPPINGS = (1 << 9), UTIL_JSON_HEALTH = (1 << 10), UTIL_JSON_TARGETS = (1 << 11), + UTIL_JSON_PARTITION = (1 << 12), }; void util_display_json_array(FILE *f_out, struct json_object *jarray, From patchwork Mon Feb 7 23:10:19 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alison Schofield X-Patchwork-Id: 12737950 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6C6812F2C for ; Mon, 7 Feb 2022 23:06:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644275183; x=1675811183; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=UCibke1LlNk3o58hklc1YHk+2ui0lmeYc6ks3030QGM=; b=OSjRicJkG9BnWli6YsP+iP8FM8LWKdyq3aZfO5RHayI1DrthR/cMGO6N YzTu/twkKzV6AzRAM3GMLLjxc79zmLDGZVXtL/27ukXJ2/dYUcRtNEP64 I6gBUrAeA4aZBoLyanp07ZcfdkI3pWYiKoDYUj61doNbyD6UgKqzPrL38 YU576syDa9vU9fP/K9vW3EvPWhs5PZY8lg0n9xpNmcMkoOvFbWitOgFea 3lbc6FBFtrdIDn24Jn70eTR5aZSXxpttHhuqjJZAvjSbj+F4tqzRLUxsd L9nnEmFoiiUPnizkLHQyC1Fm4fzywezwGTr5smPV5llEfVGLqYtDo5HWN Q==; X-IronPort-AV: E=McAfee;i="6200,9189,10251"; a="273351898" X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="273351898" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:15 -0800 X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="632639209" Received: from alison-desk.jf.intel.com (HELO localhost) ([10.54.74.41]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 From: alison.schofield@intel.com To: Ben Widawsky , Dan Williams , Ira Weiny , Vishal Verma Cc: Alison Schofield , nvdimm@lists.linux.dev, linux-cxl@vger.kernel.org Subject: [ndctl PATCH v4 5/6] libcxl: add interfaces for SET_PARTITION_INFO mailbox command Date: Mon, 7 Feb 2022 15:10:19 -0800 Message-Id: <7d1ebd8316584d065133ab7343e14eba2810f98e.1644271559.git.alison.schofield@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: Precedence: bulk X-Mailing-List: nvdimm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Alison Schofield Users may want the ability to change the partition layout of a CXL memory device. Add interfaces to libcxl to allocate and send a SET_PARTITION_INFO mailbox command as defined in the CXL 2.0 specification. Signed-off-by: Alison Schofield Reviewed-by: Dan Williams --- Documentation/cxl/lib/libcxl.txt | 4 ++++ cxl/lib/libcxl.c | 28 ++++++++++++++++++++++++++++ cxl/lib/libcxl.sym | 2 ++ cxl/lib/private.h | 8 ++++++++ cxl/libcxl.h | 10 ++++++++++ 5 files changed, 52 insertions(+) diff --git a/Documentation/cxl/lib/libcxl.txt b/Documentation/cxl/lib/libcxl.txt index a6986ab..301b4d7 100644 --- a/Documentation/cxl/lib/libcxl.txt +++ b/Documentation/cxl/lib/libcxl.txt @@ -132,6 +132,8 @@ int cxl_memdev_read_label(struct cxl_memdev *memdev, void *buf, size_t length, int cxl_memdev_write_label(struct cxl_memdev *memdev, void *buf, size_t length, size_t offset); struct cxl_cmd *cxl_cmd_new_get_partition(struct cxl_memdev *memdev); +struct cxl_cmd *cxl_cmd_new_set_partition(struct cxl_memdev *memdev, + unsigned long long volatile_size); ---- @@ -148,6 +150,8 @@ this sub-class of interfaces, there are: a CXL standard opcode. See the potential command ids in /usr/include/linux/cxl_mem.h. + * 'cxl_cmd__set_' interfaces that set specific fields in a cxl_cmd + * 'cxl_cmd_submit' which submits the command via ioctl() * 'cxl_cmd__get_' interfaces that get specific fields out of the diff --git a/cxl/lib/libcxl.c b/cxl/lib/libcxl.c index 307e5c4..3f04421 100644 --- a/cxl/lib/libcxl.c +++ b/cxl/lib/libcxl.c @@ -2464,6 +2464,34 @@ cxl_cmd_partition_get_next_persistent_size(struct cxl_cmd *cmd) return c ? capacity_to_bytes(c->next_persistent) : ULLONG_MAX; } +CXL_EXPORT int cxl_cmd_partition_set_mode(struct cxl_cmd *cmd, + enum cxl_setpartition_mode mode) +{ + struct cxl_cmd_set_partition *setpart = cmd->input_payload; + + if (mode == CXL_SETPART_IMMEDIATE) + setpart->flags = CXL_CMD_SET_PARTITION_FLAG_IMMEDIATE; + else + setpart->flags = !CXL_CMD_SET_PARTITION_FLAG_IMMEDIATE; + + return 0; +} + +CXL_EXPORT struct cxl_cmd *cxl_cmd_new_set_partition(struct cxl_memdev *memdev, + unsigned long long volatile_size) +{ + struct cxl_cmd_set_partition *setpart; + struct cxl_cmd *cmd; + + cmd = cxl_cmd_new_generic(memdev, + CXL_MEM_COMMAND_ID_SET_PARTITION_INFO); + + setpart = cmd->input_payload; + setpart->volatile_size = cpu_to_le64(volatile_size) + / CXL_CAPACITY_MULTIPLIER; + return cmd; +} + CXL_EXPORT int cxl_cmd_submit(struct cxl_cmd *cmd) { struct cxl_memdev *memdev = cmd->memdev; diff --git a/cxl/lib/libcxl.sym b/cxl/lib/libcxl.sym index 5ac6e9b..aab1112 100644 --- a/cxl/lib/libcxl.sym +++ b/cxl/lib/libcxl.sym @@ -163,4 +163,6 @@ global: cxl_cmd_identify_get_total_size; cxl_cmd_identify_get_volatile_only_size; cxl_cmd_identify_get_persistent_only_size; + cxl_cmd_new_set_partition; + cxl_cmd_partition_set_mode; } LIBCXL_1; diff --git a/cxl/lib/private.h b/cxl/lib/private.h index 7f3a562..c6d88f7 100644 --- a/cxl/lib/private.h +++ b/cxl/lib/private.h @@ -195,6 +195,14 @@ struct cxl_cmd_get_partition { #define CXL_CAPACITY_MULTIPLIER SZ_256M +struct cxl_cmd_set_partition { + le64 volatile_size; + u8 flags; +} __attribute__((packed)); + +/* CXL 2.0 8.2.9.5.2 Set Partition Info */ +#define CXL_CMD_SET_PARTITION_FLAG_IMMEDIATE BIT(0) + /* CXL 2.0 8.2.9.5.3 Byte 0 Health Status */ #define CXL_CMD_HEALTH_INFO_STATUS_MAINTENANCE_NEEDED_MASK BIT(0) #define CXL_CMD_HEALTH_INFO_STATUS_PERFORMANCE_DEGRADED_MASK BIT(1) diff --git a/cxl/libcxl.h b/cxl/libcxl.h index 6e18e84..0063d31 100644 --- a/cxl/libcxl.h +++ b/cxl/libcxl.h @@ -250,6 +250,16 @@ unsigned long long cxl_cmd_partition_get_active_volatile_size(struct cxl_cmd *cm unsigned long long cxl_cmd_partition_get_active_persistent_size(struct cxl_cmd *cmd); unsigned long long cxl_cmd_partition_get_next_volatile_size(struct cxl_cmd *cmd); unsigned long long cxl_cmd_partition_get_next_persistent_size(struct cxl_cmd *cmd); +struct cxl_cmd *cxl_cmd_new_set_partition(struct cxl_memdev *memdev, + unsigned long long volatile_size); + +enum cxl_setpartition_mode { + CXL_SETPART_NEXTBOOT, + CXL_SETPART_IMMEDIATE, +}; + +int cxl_cmd_partition_set_mode(struct cxl_cmd *cmd, + enum cxl_setpartition_mode mode); #ifdef __cplusplus } /* extern "C" */ From patchwork Mon Feb 7 23:10:20 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Alison Schofield X-Patchwork-Id: 12737949 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 78EA62F30 for ; Mon, 7 Feb 2022 23:06:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1644275183; x=1675811183; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=sjFriqt6/5te5WE9hr9ZVHMe9Go9+l16UAJ0+U7gaXI=; b=nh9gCjbI8FVioe4tMDEZNEvxmcLaipq0+kvP9R2gxR2od11aHq1jdF9L Hn6ra+jajywo3slggTIR4IwvIQ3n5pQUIkW1n54klmWeRlPnMEmYThTxf BlWgQ5RTdGeJpAhgC4CiXlHLQKOsyTQtSOsYmhB+hiRQrSKA+OBoXWWIr eBY/s34xj+4tZBGx23fMtOOS4nayPujTdGO9J+Iv71UOcEvmLRfsSPinF j5UOnRv11sjs4gSEwvRVcBB4Chp7VqfOzLSjKxuPhyWTHBIwX4+hH3ZJ0 5wiTUgAkJIHKywaOzYw7t4EZz2Pe6mKA76f0WXBlw8mq7SGPpeipvMTFD Q==; X-IronPort-AV: E=McAfee;i="6200,9189,10251"; a="273351899" X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="273351899" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:15 -0800 X-IronPort-AV: E=Sophos;i="5.88,351,1635231600"; d="scan'208";a="632639212" Received: from alison-desk.jf.intel.com (HELO localhost) ([10.54.74.41]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Feb 2022 15:06:14 -0800 From: alison.schofield@intel.com To: Ben Widawsky , Dan Williams , Ira Weiny , Vishal Verma Cc: Alison Schofield , nvdimm@lists.linux.dev, linux-cxl@vger.kernel.org Subject: [ndctl PATCH v4 6/6] cxl: add command set-partition Date: Mon, 7 Feb 2022 15:10:20 -0800 Message-Id: X-Mailer: git-send-email 2.25.1 In-Reply-To: References: Precedence: bulk X-Mailing-List: nvdimm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Alison Schofield CXL devices may support both volatile and persistent memory capacity. The amount of device capacity set aside for each type is typically established at the factory, but some devices also allow for dynamic re-partitioning, add a command for this purpose. Synopsis: cxl set-partition [..] [] -t, --type= 'pmem' or 'volatile' (Default: 'pmem') -s, --size= size in bytes (Default: all partitionable capacity) -a, --align allow alignment correction -v, --verbose turn on debug Signed-off-by: Alison Schofield Reviewed-by: Dan Williams --- Documentation/cxl/cxl-set-partition.txt | 60 ++++++++ Documentation/cxl/meson.build | 1 + cxl/builtin.h | 1 + cxl/cxl.c | 1 + cxl/memdev.c | 196 ++++++++++++++++++++++++ 5 files changed, 259 insertions(+) create mode 100644 Documentation/cxl/cxl-set-partition.txt diff --git a/Documentation/cxl/cxl-set-partition.txt b/Documentation/cxl/cxl-set-partition.txt new file mode 100644 index 0000000..e20afba --- /dev/null +++ b/Documentation/cxl/cxl-set-partition.txt @@ -0,0 +1,60 @@ +// SPDX-License-Identifier: GPL-2.0 + +cxl-set-partition(1) +==================== + +NAME +---- +cxl-set-partition - set the partitioning between volatile and persistent capacity on a CXL memdev + +SYNOPSIS +-------- +[verse] +'cxl set-partition [ [..] []' + +DESCRIPTION +----------- +Partition the device into volatile and persistent capacity. The change +in partitioning will become the “next” configuration, to become active +on the next device reset. + +Use "cxl list -m -I" to examine the partitioning capabilities +of a device. A partition_alignment_bytes value of zero means there are +no partitionable bytes available and therefore the partitions cannot be +changed. + +Using this command to change the size of the persistent capacity shall +result in the loss of data stored. + +OPTIONS +------- +:: +include::memdev-option.txt[] + +-t:: +--type=:: + Type of partition, 'pmem' or 'volatile', to create. + Default: 'pmem' + +-s:: +--size=:: + Size of the partition in bytes. Size must align to the + devices alignment size. Use 'cxl list -m -I' to find + the 'partition_alignment_size', or, use the 'align' option. + Default: All partitionable capacity is assigned to . + +-a:: +--align:: + This option allows the size of the partition to be increased to + meet device alignment requirements. + +-v:: + Turn on verbose debug messages in the library (if libcxl was built with + logging and debug enabled). + +include::../copyright.txt[] + +SEE ALSO +-------- +linkcxl:cxl-list[1], +CXL-2.0 8.2.9.5.2 diff --git a/Documentation/cxl/meson.build b/Documentation/cxl/meson.build index 96f4666..e927644 100644 --- a/Documentation/cxl/meson.build +++ b/Documentation/cxl/meson.build @@ -34,6 +34,7 @@ cxl_manpages = [ 'cxl-disable-memdev.txt', 'cxl-enable-port.txt', 'cxl-disable-port.txt', + 'cxl-set-partition.txt', ] foreach man : cxl_manpages diff --git a/cxl/builtin.h b/cxl/builtin.h index 3123d5e..7bbad98 100644 --- a/cxl/builtin.h +++ b/cxl/builtin.h @@ -14,4 +14,5 @@ int cmd_disable_memdev(int argc, const char **argv, struct cxl_ctx *ctx); int cmd_enable_memdev(int argc, const char **argv, struct cxl_ctx *ctx); int cmd_disable_port(int argc, const char **argv, struct cxl_ctx *ctx); int cmd_enable_port(int argc, const char **argv, struct cxl_ctx *ctx); +int cmd_set_partition(int argc, const char **argv, struct cxl_ctx *ctx); #endif /* _CXL_BUILTIN_H_ */ diff --git a/cxl/cxl.c b/cxl/cxl.c index c20c569..ab4bbec 100644 --- a/cxl/cxl.c +++ b/cxl/cxl.c @@ -68,6 +68,7 @@ static struct cmd_struct commands[] = { { "enable-memdev", .c_fn = cmd_enable_memdev }, { "disable-port", .c_fn = cmd_disable_port }, { "enable-port", .c_fn = cmd_enable_port }, + { "set-partition", .c_fn = cmd_set_partition }, }; int main(int argc, const char **argv) diff --git a/cxl/memdev.c b/cxl/memdev.c index 90b33e1..5d97610 100644 --- a/cxl/memdev.c +++ b/cxl/memdev.c @@ -6,11 +6,14 @@ #include #include #include +#include +#include #include #include #include #include +#include "json.h" #include "filter.h" struct action_context { @@ -26,6 +29,9 @@ static struct parameters { bool verbose; bool serial; bool force; + bool align; + const char *type; + const char *size; } param; static struct log_ctx ml; @@ -51,6 +57,14 @@ OPT_UINTEGER('O', "offset", ¶m.offset, \ OPT_BOOLEAN('f', "force", ¶m.force, \ "DANGEROUS: override active memdev safety checks") +#define SET_PARTITION_OPTIONS() \ +OPT_STRING('t', "type", ¶m.type, "type", \ + "'pmem' or 'volatile' (Default: 'pmem')"), \ +OPT_STRING('s', "size", ¶m.size, "size", \ + "size in bytes (Default: all partitionable capacity)"), \ +OPT_BOOLEAN('a', "align", ¶m.align, \ + "allow alignment correction") + static const struct option read_options[] = { BASE_OPTIONS(), LABEL_OPTIONS(), @@ -82,6 +96,12 @@ static const struct option enable_options[] = { OPT_END(), }; +static const struct option set_partition_options[] = { + BASE_OPTIONS(), + SET_PARTITION_OPTIONS(), + OPT_END(), +}; + static int action_disable(struct cxl_memdev *memdev, struct action_context *actx) { if (!cxl_memdev_is_enabled(memdev)) @@ -209,6 +229,171 @@ out: return rc; } +static unsigned long long +partition_align(const char *devname, unsigned long long volatile_size, + unsigned long long alignment, unsigned long long partitionable) +{ + if (IS_ALIGNED(volatile_size, alignment)) + return volatile_size; + + if (!param.align) { + log_err(&ml, "%s: size %lld is not partition aligned %lld\n", + devname, volatile_size, alignment); + return ULLONG_MAX; + } + + /* Align based on partition type to fulfill users size request */ + if (strcmp(param.type, "pmem") == 0) + volatile_size = ALIGN_DOWN(volatile_size, alignment); + else + volatile_size = ALIGN(volatile_size, alignment); + + /* Fail if the align pushes size over the partitionable limit. */ + if (volatile_size > partitionable) { + log_err(&ml, "%s: aligned partition size %lld exceeds partitionable size %lld\n", + devname, volatile_size, partitionable); + volatile_size = ULLONG_MAX; + } + + return volatile_size; +} + +static unsigned long long +param_size_to_volatile_size(const char *devname, unsigned long long size, + unsigned long long partitionable) +{ + /* User omits size option. Apply all partitionable capacity to type. */ + if (size == ULLONG_MAX) + return (strcmp(param.type, "pmem") == 0) ? 0 : partitionable; + + /* User includes a size option. Apply it to type */ + if (size > partitionable) { + log_err(&ml, "%s: %lld exceeds partitionable capacity %lld\n", + devname, size, partitionable); + return ULLONG_MAX; + } + return (strcmp(param.type, "pmem") == 0) ? partitionable - size : size; +} + +/* + * Return the volatile_size to use in the CXL set paritition + * command, or ULLONG_MAX if unable to validate the partition + * request. + */ +static unsigned long long +validate_partition(struct cxl_memdev *memdev, unsigned long long size) +{ + unsigned long long total_cap, volatile_only, persistent_only; + const char *devname = cxl_memdev_get_devname(memdev); + unsigned long long volatile_size = ULLONG_MAX; + unsigned long long partitionable, alignment; + struct cxl_cmd *cmd; + int rc; + + cmd = cxl_cmd_new_identify(memdev); + if (!cmd) + return ULLONG_MAX; + rc = cxl_cmd_submit(cmd); + if (rc < 0) + goto out; + rc = cxl_cmd_get_mbox_status(cmd); + if (rc != 0) + goto out; + + alignment = cxl_cmd_identify_get_partition_align(cmd); + if (alignment == 0) { + log_err(&ml, "%s: no partitionable capacity\n", devname); + goto out; + } + + /* Calculate the actual partitionable capacity */ + total_cap = cxl_cmd_identify_get_total_size(cmd); + volatile_only = cxl_cmd_identify_get_volatile_only_size(cmd); + persistent_only = cxl_cmd_identify_get_persistent_only_size(cmd); + partitionable = total_cap - volatile_only - persistent_only; + + /* Translate the users size request into an aligned volatile_size */ + volatile_size = param_size_to_volatile_size(devname, size, + partitionable); + if (volatile_size == ULLONG_MAX) + goto out; + + volatile_size = partition_align(devname, volatile_size, alignment, + partitionable); + +out: + cxl_cmd_unref(cmd); + return volatile_size; +} + +static int action_setpartition(struct cxl_memdev *memdev, + struct action_context *actx) +{ + const char *devname = cxl_memdev_get_devname(memdev); + unsigned long long size = ULLONG_MAX; + struct json_object *jmemdev; + struct cxl_cmd *cmd; + int rc; + + if (param.type) { + if (strcmp(param.type, "pmem") == 0) + /* pass */; + else if (strcmp(param.type, "volatile") == 0) + /* pass */; + else { + log_err(&ml, "invalid type '%s'\n", param.type); + return -EINVAL; + } + } else { + /* Default type is PMEM */ + param.type = "pmem"; + } + + if (param.size) { + size = parse_size64(param.size); + if (size == ULLONG_MAX) { + log_err(&ml, "%s: failed to parse size option '%s'\n", + devname, param.size); + return -EINVAL; + } + } + + size = validate_partition(memdev, size); + if (size == ULLONG_MAX) + return -EINVAL; + + cmd = cxl_cmd_new_set_partition(memdev, size); + if (!cmd) { + rc = -ENXIO; + goto out_err; + } + + rc = cxl_cmd_submit(cmd); + if (rc < 0) { + log_err(&ml, "cmd submission failed: %s\n", strerror(-rc)); + goto out_cmd; + } + + rc = cxl_cmd_get_mbox_status(cmd); + if (rc != 0) { + log_err(&ml, "%s: mbox status: %d\n", __func__, rc); + rc = -ENXIO; + } + +out_cmd: + cxl_cmd_unref(cmd); +out_err: + if (rc) + log_err(&ml, "%s error: %s\n", devname, strerror(-rc)); + + jmemdev = util_cxl_memdev_to_json(memdev, UTIL_JSON_PARTITION); + if (jmemdev) + printf("%s\n", json_object_to_json_string_ext(jmemdev, + JSON_C_TO_STRING_PRETTY)); + + return rc; +} + static int memdev_action(int argc, const char **argv, struct cxl_ctx *ctx, int (*action)(struct cxl_memdev *memdev, struct action_context *actx), @@ -398,3 +583,14 @@ int cmd_enable_memdev(int argc, const char **argv, struct cxl_ctx *ctx) count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } + +int cmd_set_partition(int argc, const char **argv, struct cxl_ctx *ctx) +{ + int count = memdev_action(argc, argv, ctx, action_setpartition, + set_partition_options, + "cxl set-partition [..] []"); + log_info(&ml, "set_partition %d mem%s\n", count >= 0 ? count : 0, + count > 1 ? "s" : ""); + + return count >= 0 ? 0 : EXIT_FAILURE; +}