diff --git a/0042-mdadm-Move-pr_vrb-define-to-mdadm.h.patch b/0042-mdadm-Move-pr_vrb-define-to-mdadm.h.patch new file mode 100644 index 0000000..932b0c8 --- /dev/null +++ b/0042-mdadm-Move-pr_vrb-define-to-mdadm.h.patch @@ -0,0 +1,44 @@ +From cc75b0faaa016e54d569486c9a7abe6c39cb883a Mon Sep 17 00:00:00 2001 +From: Blazej Kucman +Date: Fri, 22 Mar 2024 12:51:15 +0100 +Subject: [PATCH 42/69] mdadm: Move pr_vrb define to mdadm.h + +Move pr_vrb define from super-intel.c to mdadm.h to make it widely +available. This change will be used in the next patches. + +Signed-off-by: Blazej Kucman +Signed-off-by: Mariusz Tkaczyk +--- + mdadm.h | 2 ++ + super-intel.c | 2 -- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/mdadm.h b/mdadm.h +index ae2106a2..fbb161ba 100644 +--- a/mdadm.h ++++ b/mdadm.h +@@ -1911,6 +1911,8 @@ static inline int xasprintf(char **strp, const char *fmt, ...) { + + #define pr_info(fmt, args...) printf("%s: "fmt, Name, ##args) + ++#define pr_vrb(fmt, arg...) ((void)(verbose && pr_err(fmt, ##arg))) ++ + void *xmalloc(size_t len); + void *xrealloc(void *ptr, size_t len); + void *xcalloc(size_t num, size_t size); +diff --git a/super-intel.c b/super-intel.c +index 70f3c4ef..212387ec 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -393,8 +393,6 @@ struct md_list { + struct md_list *next; + }; + +-#define pr_vrb(fmt, arg...) (void) (verbose && pr_err(fmt, ##arg)) +- + static __u8 migr_type(struct imsm_dev *dev) + { + if (dev->vol.migr_type == MIGR_VERIFY && +-- +2.41.0 + diff --git a/0043-Add-reading-Opal-NVMe-encryption-information.patch b/0043-Add-reading-Opal-NVMe-encryption-information.patch new file mode 100644 index 0000000..a795a62 --- /dev/null +++ b/0043-Add-reading-Opal-NVMe-encryption-information.patch @@ -0,0 +1,463 @@ +From cc48406887b3bc439e3462e8e4d20f992e81b87e Mon Sep 17 00:00:00 2001 +From: Blazej Kucman +Date: Fri, 22 Mar 2024 12:51:16 +0100 +Subject: [PATCH 43/69] Add reading Opal NVMe encryption information + +For NVMe devices with Opal support, encryption information, status and +ability are determined based on Opal Level 0 discovery response. Technical +documentation used is given in the implementation. + +Ability in general describes what type of encryption is supported, Status +describes in what state the disk with encryption support is. The current +patch includes only the implementation of reading encryption information, +functions will be used in one of the next patches. + +Motivation for adding this functionality is to block mixing of disks in +IMSM arrays with encryption enabled and disabled. The main goal is to not +allow stealing data by rebuilding array to not encrypted drive which can be +read elsewhere. + +Value ENA_OTHER from enum encryption_ability will be used in the next +patch. + +Signed-off-by: Blazej Kucman +Signed-off-by: Mariusz Tkaczyk +--- + Makefile | 4 +- + drive_encryption.c | 362 +++++++++++++++++++++++++++++++++++++++++++++ + drive_encryption.h | 32 ++++ + 3 files changed, 396 insertions(+), 2 deletions(-) + create mode 100644 drive_encryption.c + create mode 100644 drive_encryption.h + +diff --git a/Makefile b/Makefile +index cbdba49a..7c221a89 100644 +--- a/Makefile ++++ b/Makefile +@@ -170,7 +170,7 @@ OBJS = mdadm.o config.o policy.o mdstat.o ReadMe.o uuid.o util.o maps.o lib.o u + mdopen.o super0.o super1.o super-ddf.o super-intel.o bitmap.o \ + super-mbr.o super-gpt.o \ + restripe.o sysfs.o sha1.o mapfile.o crc32.o sg_io.o msg.o xmalloc.o \ +- platform-intel.o probe_roms.o crc32c.o ++ platform-intel.o probe_roms.o crc32c.o drive_encryption.o + + CHECK_OBJS = restripe.o uuid.o sysfs.o maps.o lib.o xmalloc.o dlink.o + +@@ -183,7 +183,7 @@ MON_OBJS = mdmon.o monitor.o managemon.o uuid.o util.o maps.o mdstat.o sysfs.o c + Kill.o sg_io.o dlink.o ReadMe.o super-intel.o \ + super-mbr.o super-gpt.o \ + super-ddf.o sha1.o crc32.o msg.o bitmap.o xmalloc.o \ +- platform-intel.o probe_roms.o crc32c.o ++ platform-intel.o probe_roms.o crc32c.o drive_encryption.o + + MON_SRCS = $(patsubst %.o,%.c,$(MON_OBJS)) + +diff --git a/drive_encryption.c b/drive_encryption.c +new file mode 100644 +index 00000000..b44585a7 +--- /dev/null ++++ b/drive_encryption.c +@@ -0,0 +1,362 @@ ++// SPDX-License-Identifier: GPL-2.0-only ++/* ++ * Read encryption information for Opal and ATA devices. ++ * ++ * Copyright (C) 2024 Intel Corporation ++ * Author: Blazej Kucman ++ */ ++ ++#include "mdadm.h" ++ ++#include ++#include ++#include "drive_encryption.h" ++ ++/* ++ * Opal defines ++ * TCG Storage Opal SSC 2.01 chapter 3.3.3 ++ * NVM ExpressTM Revision 1.4c, chapter 5 ++ */ ++#define TCG_SECP_01 (0x01) ++#define TCG_SECP_00 (0x00) ++#define OPAL_DISCOVERY_COMID (0x0001) ++#define OPAL_LOCKING_FEATURE (0x0002) ++#define OPAL_IO_BUFFER_LEN 2048 ++#define OPAL_DISCOVERY_FEATURE_HEADER_LEN (4) ++ ++/* ++ * NVMe defines ++ * NVM ExpressTM Revision 1.4c, chapter 5 ++ */ ++#define NVME_SECURITY_RECV (0x82) ++#define NVME_IDENTIFY (0x06) ++#define NVME_IDENTIFY_RESPONSE_LEN 4096 ++#define NVME_OACS_BYTE_POSITION (256) ++#define NVME_IDENTIFY_CONTROLLER_DATA (1) ++ ++typedef enum drive_feature_support_status { ++ /* Drive feature is supported. */ ++ DRIVE_FEAT_SUP_ST = 0, ++ /* Drive feature is not supported. */ ++ DRIVE_FEAT_NOT_SUP_ST, ++ /* Drive feature support check failed. */ ++ DRIVE_FEAT_CHECK_FAILED_ST ++} drive_feat_sup_st; ++ ++/* TCG Storage Opal SSC 2.01 chapter 3.1.1.3 */ ++typedef struct opal_locking_feature { ++ /* feature header */ ++ __u16 feature_code; ++ __u8 reserved : 4; ++ __u8 version : 4; ++ __u8 description_length; ++ /* feature description */ ++ __u8 locking_supported : 1; ++ __u8 locking_enabled : 1; ++ __u8 locked : 1; ++ __u8 media_encryption : 1; ++ __u8 mbr_enabled : 1; ++ __u8 mbr_done : 1; ++ __u8 mbr_shadowing_not_supported : 1; ++ __u8 hw_reset_for_dor_supported : 1; ++ __u8 reserved1[11]; ++} __attribute__((__packed__)) opal_locking_feature_t; ++ ++/* TCG Storage Opal SSC 2.01 chapter 3.1.1.1 */ ++typedef struct opal_level0_header { ++ __u32 length; ++ __u32 version; ++ __u64 reserved; ++ __u8 vendor_specific[32]; ++} opal_level0_header_t; ++ ++/** ++ * NVM ExpressTM Revision 1.4c, Figure 249 ++ * Structure specifies only OACS filed, which is needed in the current use case. ++ */ ++typedef struct nvme_identify_ctrl { ++ __u8 reserved[255]; ++ __u16 oacs; ++ __u8 reserved2[3839]; ++} nvme_identify_ctrl_t; ++ ++/* SCSI Primary Commands - 4 (SPC-4), Table 512 */ ++typedef struct supported_security_protocols { ++ __u8 reserved[6]; ++ __u16 list_length; ++ __u8 list[504]; ++} supported_security_protocols_t; ++ ++/** ++ * get_opal_locking_feature_description() - get opal locking feature description. ++ * @response: response from Opal Discovery Level 0. ++ * ++ * Based on the documentation TCG Storage Opal SSC 2.01 chapter 3.1.1, ++ * a Locking feature is searched for in Opal Level 0 Discovery response. ++ * ++ * Return: if locking feature is found, pointer to struct %opal_locking_feature_t, NULL otherwise. ++ */ ++static opal_locking_feature_t *get_opal_locking_feature_description(__u8 *response) ++{ ++ opal_level0_header_t *response_header = (opal_level0_header_t *)response; ++ int features_length = __be32_to_cpu(response_header->length); ++ int current_position = sizeof(*response_header); ++ ++ while (current_position < features_length) { ++ opal_locking_feature_t *feature; ++ ++ feature = (opal_locking_feature_t *)(response + current_position); ++ ++ if (__be16_to_cpu(feature->feature_code) == OPAL_LOCKING_FEATURE) ++ return feature; ++ ++ current_position += feature->description_length + OPAL_DISCOVERY_FEATURE_HEADER_LEN; ++ } ++ ++ return NULL; ++} ++ ++/** ++ * nvme_security_recv_ioctl() - nvme security receive ioctl. ++ * @disk_fd: a disk file descriptor. ++ * @sec_protocol: security protocol. ++ * @comm_id: command id. ++ * @response_buffer: response buffer to fill out. ++ * @buf_size: response buffer size. ++ * @verbose: verbose flag. ++ * ++ * Based on the documentations TCG Storage Opal SSC 2.01 chapter 3.3.3 and ++ * NVM ExpressTM Revision 1.4c, chapter 5.25, ++ * read security receive command via ioctl(). ++ * On success, @response_buffer is completed. ++ * ++ * Return: %MDADM_STATUS_SUCCESS on success, %MDADM_STATUS_ERROR otherwise. ++ */ ++static mdadm_status_t ++nvme_security_recv_ioctl(int disk_fd, __u8 sec_protocol, __u16 comm_id, void *response_buffer, ++ size_t buf_size, const int verbose) ++{ ++ struct nvme_admin_cmd nvme_cmd = {0}; ++ int status; ++ ++ nvme_cmd.opcode = NVME_SECURITY_RECV; ++ nvme_cmd.cdw10 = sec_protocol << 24 | comm_id << 8; ++ nvme_cmd.cdw11 = buf_size; ++ nvme_cmd.data_len = buf_size; ++ nvme_cmd.addr = (__u64)response_buffer; ++ ++ status = ioctl(disk_fd, NVME_IOCTL_ADMIN_CMD, &nvme_cmd); ++ if (status != 0) { ++ pr_vrb("Failed to read NVMe security receive ioctl() for device /dev/%s, status: %d\n", ++ fd2kname(disk_fd), status); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ return MDADM_STATUS_SUCCESS; ++} ++ ++/** ++ * nvme_identify_ioctl() - NVMe identify ioctl. ++ * @disk_fd: a disk file descriptor. ++ * @response_buffer: response buffer to fill out. ++ * @buf_size: response buffer size. ++ * @verbose: verbose flag. ++ * ++ * Based on the documentations TCG Storage Opal SSC 2.01 chapter 3.3.3 and ++ * NVM ExpressTM Revision 1.4c, chapter 5.25, ++ * read NVMe identify via ioctl(). ++ * On success, @response_buffer will be completed. ++ * ++ * Return: %MDADM_STATUS_SUCCESS on success, %MDADM_STATUS_ERROR otherwise. ++ */ ++static mdadm_status_t ++nvme_identify_ioctl(int disk_fd, void *response_buffer, size_t buf_size, const int verbose) ++{ ++ struct nvme_admin_cmd nvme_cmd = {0}; ++ int status; ++ ++ nvme_cmd.opcode = NVME_IDENTIFY; ++ nvme_cmd.cdw10 = NVME_IDENTIFY_CONTROLLER_DATA; ++ nvme_cmd.data_len = buf_size; ++ nvme_cmd.addr = (__u64)response_buffer; ++ ++ status = ioctl(disk_fd, NVME_IOCTL_ADMIN_CMD, &nvme_cmd); ++ if (status != 0) { ++ pr_vrb("Failed to read NVMe identify ioctl() for device /dev/%s, status: %d\n", ++ fd2kname(disk_fd), status); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ return MDADM_STATUS_SUCCESS; ++} ++ ++/** ++ * is_sec_prot_01h_supported() - check if security protocol 01h supported. ++ * @security_protocols: struct with response from disk (NVMe, SATA) describing supported ++ * security protocols. ++ * ++ * Return: true if TCG_SECP_01 found, false otherwise. ++ */ ++static bool is_sec_prot_01h_supported(supported_security_protocols_t *security_protocols) ++{ ++ int list_length = be16toh(security_protocols->list_length); ++ int index; ++ ++ for (index = 0 ; index < list_length; index++) { ++ if (security_protocols->list[index] == TCG_SECP_01) ++ return true; ++ } ++ ++ return false; ++} ++ ++/** ++ * is_sec_prot_01h_supported_nvme() - check if security protocol 01h supported for given NVMe disk. ++ * @disk_fd: a disk file descriptor. ++ * @verbose: verbose flag. ++ * ++ * Return: %DRIVE_FEAT_SUP_ST if TCG_SECP_01 supported, %DRIVE_FEAT_NOT_SUP_ST if not supported, ++ * %DRIVE_FEAT_CHECK_FAILED_ST if failed to check. ++ */ ++static drive_feat_sup_st is_sec_prot_01h_supported_nvme(int disk_fd, const int verbose) ++{ ++ supported_security_protocols_t security_protocols = {0}; ++ ++ /* security_protocol: TCG_SECP_00, comm_id: not applicable */ ++ if (nvme_security_recv_ioctl(disk_fd, TCG_SECP_00, 0x0, &security_protocols, ++ sizeof(security_protocols), verbose)) ++ return DRIVE_FEAT_CHECK_FAILED_ST; ++ ++ if (is_sec_prot_01h_supported(&security_protocols)) ++ return DRIVE_FEAT_SUP_ST; ++ ++ return DRIVE_FEAT_NOT_SUP_ST; ++} ++ ++/** ++ * is_nvme_sec_send_recv_supported() - check if Security Send and Security Receive is supported. ++ * @disk_fd: a disk file descriptor. ++ * @verbose: verbose flag. ++ * ++ * Check if "Optional Admin Command Support" bit 0 is set in NVMe identify. ++ * Bit 0 set to 1 means controller supports the Security Send and Security Receive commands. ++ * ++ * Return: %DRIVE_FEAT_SUP_ST if security send/receive supported, ++ * %DRIVE_FEAT_NOT_SUP_ST if not supported, %DRIVE_FEAT_CHECK_FAILED_ST if check failed. ++ */ ++static drive_feat_sup_st is_nvme_sec_send_recv_supported(int disk_fd, const int verbose) ++{ ++ nvme_identify_ctrl_t nvme_identify = {0}; ++ int status = 0; ++ ++ status = nvme_identify_ioctl(disk_fd, &nvme_identify, sizeof(nvme_identify), verbose); ++ if (status) ++ return DRIVE_FEAT_CHECK_FAILED_ST; ++ ++ if ((__le16_to_cpu(nvme_identify.oacs) & 0x1) == 0x1) ++ return DRIVE_FEAT_SUP_ST; ++ ++ return DRIVE_FEAT_NOT_SUP_ST; ++} ++ ++/** ++ * get_opal_encryption_information() - get Opal encryption information. ++ * @buffer: buffer with Opal Level 0 Discovery response. ++ * @information: struct to fill out, describing encryption status of disk. ++ * ++ * If Locking feature frame is in response from Opal Level 0 discovery, &encryption_information_t ++ * structure is completed with status and ability otherwise the status is set to &None. ++ * For possible encryption statuses and abilities, ++ * please refer to enums &encryption_status and &encryption_ability. ++ * ++ * Return: %MDADM_STATUS_SUCCESS on success, %MDADM_STATUS_ERROR otherwise. ++ */ ++static mdadm_status_t get_opal_encryption_information(__u8 *buffer, ++ encryption_information_t *information) ++{ ++ opal_locking_feature_t *opal_locking_feature = ++ get_opal_locking_feature_description(buffer); ++ ++ if (!opal_locking_feature) ++ return MDADM_STATUS_ERROR; ++ ++ if (opal_locking_feature->locking_supported == 1) { ++ information->ability = ENC_ABILITY_SED; ++ ++ if (opal_locking_feature->locking_enabled == 0) ++ information->status = ENC_STATUS_UNENCRYPTED; ++ else if (opal_locking_feature->locked == 1) ++ information->status = ENC_STATUS_LOCKED; ++ else ++ information->status = ENC_STATUS_UNLOCKED; ++ } else { ++ information->ability = ENC_ABILITY_NONE; ++ information->status = ENC_STATUS_UNENCRYPTED; ++ } ++ ++ return MDADM_STATUS_SUCCESS; ++} ++ ++/** ++ * get_nvme_opal_encryption_information() - get NVMe Opal encryption information. ++ * @disk_fd: a disk file descriptor. ++ * @information: struct to fill out, describing encryption status of disk. ++ * @verbose: verbose flag. ++ * ++ * In case the disk supports Opal Level 0 discovery, &encryption_information_t structure ++ * is completed with status and ability based on ioctl response, ++ * otherwise the ability is set to %ENC_ABILITY_NONE and &status to %ENC_STATUS_UNENCRYPTED. ++ * As the current use case does not need the knowledge of Opal support, if there is no support, ++ * %MDADM_STATUS_SUCCESS will be returned, with the values described above. ++ * For possible encryption statuses and abilities, ++ * please refer to enums &encryption_status and &encryption_ability. ++ * ++ * %MDADM_STATUS_SUCCESS on success, %MDADM_STATUS_ERROR otherwise. ++ */ ++mdadm_status_t ++get_nvme_opal_encryption_information(int disk_fd, encryption_information_t *information, ++ const int verbose) ++{ ++ __u8 buffer[OPAL_IO_BUFFER_LEN]; ++ int sec_send_recv_supported = 0; ++ int protocol_01h_supported = 0; ++ mdadm_status_t status; ++ ++ information->ability = ENC_ABILITY_NONE; ++ information->status = ENC_STATUS_UNENCRYPTED; ++ ++ sec_send_recv_supported = is_nvme_sec_send_recv_supported(disk_fd, verbose); ++ if (sec_send_recv_supported == DRIVE_FEAT_CHECK_FAILED_ST) ++ return MDADM_STATUS_ERROR; ++ ++ /* Opal not supported */ ++ if (sec_send_recv_supported == DRIVE_FEAT_NOT_SUP_ST) ++ return MDADM_STATUS_SUCCESS; ++ ++ /** ++ * sec_send_recv_supported determine that it should be possible to read ++ * supported sec protocols ++ */ ++ protocol_01h_supported = is_sec_prot_01h_supported_nvme(disk_fd, verbose); ++ if (protocol_01h_supported == DRIVE_FEAT_CHECK_FAILED_ST) ++ return MDADM_STATUS_ERROR; ++ ++ /* Opal not supported */ ++ if (sec_send_recv_supported == DRIVE_FEAT_SUP_ST && ++ protocol_01h_supported == DRIVE_FEAT_NOT_SUP_ST) ++ return MDADM_STATUS_SUCCESS; ++ ++ if (nvme_security_recv_ioctl(disk_fd, TCG_SECP_01, OPAL_DISCOVERY_COMID, (void *)&buffer, ++ OPAL_IO_BUFFER_LEN, verbose)) ++ return MDADM_STATUS_ERROR; ++ ++ status = get_opal_encryption_information((__u8 *)&buffer, information); ++ if (status) ++ pr_vrb("Locking feature description not found in Level 0 discovery response. Device /dev/%s.\n", ++ fd2kname(disk_fd)); ++ ++ if (information->ability == ENC_ABILITY_NONE) ++ assert(information->status == ENC_STATUS_UNENCRYPTED); ++ ++ return status; ++} +diff --git a/drive_encryption.h b/drive_encryption.h +new file mode 100644 +index 00000000..82c2c624 +--- /dev/null ++++ b/drive_encryption.h +@@ -0,0 +1,32 @@ ++/* SPDX-License-Identifier: GPL-2.0-only */ ++/* ++ * Read encryption information for Opal and ATA devices. ++ * ++ * Copyright (C) 2024 Intel Corporation ++ * Author: Blazej Kucman ++ */ ++ ++typedef enum encryption_status { ++ /* The drive is not currently encrypted. */ ++ ENC_STATUS_UNENCRYPTED = 0, ++ /* The drive is encrypted and the data is not accessible. */ ++ ENC_STATUS_LOCKED, ++ /* The drive is encrypted but the data is accessible in unencrypted form. */ ++ ENC_STATUS_UNLOCKED ++} encryption_status_t; ++ ++typedef enum encryption_ability { ++ ENC_ABILITY_NONE = 0, ++ ENC_ABILITY_OTHER, ++ /* Self encrypted drive */ ++ ENC_ABILITY_SED ++} encryption_ability_t; ++ ++typedef struct encryption_information { ++ encryption_ability_t ability; ++ encryption_status_t status; ++} encryption_information_t; ++ ++mdadm_status_t ++get_nvme_opal_encryption_information(int disk_fd, struct encryption_information *information, ++ const int verbose); +-- +2.41.0 + diff --git a/0044-Add-reading-SATA-encryption-information.patch b/0044-Add-reading-SATA-encryption-information.patch new file mode 100644 index 0000000..f15fb84 --- /dev/null +++ b/0044-Add-reading-SATA-encryption-information.patch @@ -0,0 +1,459 @@ +From df38df3052c3386c0fd076e0d534b4f688b5c8a4 Mon Sep 17 00:00:00 2001 +From: Blazej Kucman +Date: Fri, 22 Mar 2024 12:51:17 +0100 +Subject: [PATCH 44/69] Add reading SATA encryption information + +Functionality reads information about SATA disk encryption. Technical +documentation used is given in the implementation. + +The implementation is able to recognized two encryption standards for SATA +drives, OPAL and ATA security. + +If the SATA drive supports OPAL, encryption status and ability are +determined based on Opal Level 0 discovery response, for ATA security, +based on ATA identify response. If SATA supports OPAL, ability is set to +"SED", for ATA security to "Other". + +SED(Self-Encrypting Drive) is commonly used to describe drive which using +OPAL or Enterprise standards developed by Trusted Computing Group. Ability +"Other" is used for ATA security because we rely only on information from +ATA identify which describe the overall state of encryption. + +It is allowed to mix disks with different encryption ability such as "SED" +and "Other" and it is not security gap. + +Motivation for adding this functionality is to block mixing of disks in +IMSM arrays with encryption enabled and disabled. The main goal is to not +allow stealing data by rebuilding array to not encrypted drive which can be +read elsewhere. + +For SATA Opal drives, libata allow_tmp parameter enabled is required, which +is necessary for Opal Security commands to work, therefore, if the +parameter is not enabled, SATA Opal disk cannot be used in case the +encryption will be checked by metadata. + +Implemented functions will be used in one of the next patches. In one of +the next patches, a flag will be added to enable disabling SATA Opal +encryption checking due to allow_tpm kernel setting dependency. + +Signed-off-by: Blazej Kucman +Signed-off-by: Mariusz Tkaczyk +--- + drive_encryption.c | 318 +++++++++++++++++++++++++++++++++++++++++++++ + drive_encryption.h | 3 + + mdadm.h | 1 + + sysfs.c | 29 +++++ + 4 files changed, 351 insertions(+) + +diff --git a/drive_encryption.c b/drive_encryption.c +index b44585a7..d520f0c7 100644 +--- a/drive_encryption.c ++++ b/drive_encryption.c +@@ -10,8 +10,12 @@ + + #include + #include ++#include ++#include + #include "drive_encryption.h" + ++#define DEFAULT_SECTOR_SIZE (512) ++ + /* + * Opal defines + * TCG Storage Opal SSC 2.01 chapter 3.3.3 +@@ -34,6 +38,35 @@ + #define NVME_OACS_BYTE_POSITION (256) + #define NVME_IDENTIFY_CONTROLLER_DATA (1) + ++/* ++ * ATA defines ++ * ATA/ATAPI Command Set ATA8-ACS ++ * SCSI / ATA Translation - 3 (SAT-3) ++ * SCSI Primary Commands - 4 (SPC-4) ++ * AT Attachment-8 - ATA Serial Transport (ATA8-AST) ++ * ATA Command Pass-Through ++ */ ++#define ATA_IDENTIFY (0xec) ++#define ATA_TRUSTED_RECEIVE (0x5c) ++#define ATA_SECURITY_WORD_POSITION (128) ++#define HDIO_DRIVE_CMD (0x031f) ++#define ATA_TRUSTED_COMPUTING_POS (48) ++#define ATA_PASS_THROUGH_12 (0xa1) ++#define ATA_IDENTIFY_RESPONSE_LEN (512) ++#define ATA_PIO_DATA_IN (4) ++#define SG_CHECK_CONDITION (0x02) ++#define ATA_STATUS_RETURN_DESCRIPTOR (0x09) ++#define ATA_PT_INFORMATION_AVAILABLE_ASCQ (0x1d) ++#define ATA_PT_INFORMATION_AVAILABLE_ASC (0x00) ++#define ATA_INQUIRY_LENGTH (0x0c) ++#define SG_INTERFACE_ID 'S' ++#define SG_IO_TIMEOUT (60000) ++#define SG_SENSE_SIZE (32) ++#define SENSE_DATA_CURRENT_FIXED (0x70) ++#define SENSE_DATA_CURRENT_DESC (0x72) ++#define SENSE_CURRENT_RES_DESC_POS (8) ++#define SG_DRIVER_SENSE (0x08) ++ + typedef enum drive_feature_support_status { + /* Drive feature is supported. */ + DRIVE_FEAT_SUP_ST = 0, +@@ -87,6 +120,27 @@ typedef struct supported_security_protocols { + __u8 list[504]; + } supported_security_protocols_t; + ++/* ATA/ATAPI Command Set - 3 (ACS-3), Table 45 */ ++typedef struct ata_security_status { ++ __u16 security_supported : 1; ++ __u16 security_enabled : 1; ++ __u16 security_locked : 1; ++ __u16 security_frozen : 1; ++ __u16 security_count_expired : 1; ++ __u16 enhanced_security_erase_supported : 1; ++ __u16 reserved1 : 2; ++ __u16 security_level : 1; ++ __u16 reserved2 : 7; ++} __attribute__((__packed__)) ata_security_status_t; ++ ++/* ATA/ATAPI Command Set - 3 (ACS-3), Table 45 */ ++typedef struct ata_trusted_computing { ++ __u16 tc_feature :1; ++ __u16 reserved : 13; ++ __u16 var1 : 1; ++ __u16 var2 : 1; ++} __attribute__((__packed__)) ata_trusted_computing_t; ++ + /** + * get_opal_locking_feature_description() - get opal locking feature description. + * @response: response from Opal Discovery Level 0. +@@ -360,3 +414,267 @@ get_nvme_opal_encryption_information(int disk_fd, encryption_information_t *info + + return status; + } ++ ++/** ++ * ata_pass_through12_ioctl() - ata pass through12 ioctl. ++ * @disk_fd: a disk file descriptor. ++ * @ata_command: ata command. ++ * @sec_protocol: security protocol. ++ * @comm_id: additional command id. ++ * @response_buffer: response buffer to fill out. ++ * @buf_size: response buffer size. ++ * @verbose: verbose flag. ++ * ++ * Based on the documentations ATA Command Pass-Through, chapter 13.2.2 and ++ * ATA Translation - 3 (SAT-3), send read ata pass through 12 command via ioctl(). ++ * On success, @response_buffer will be completed. ++ * ++ * Return: %MDADM_STATUS_SUCCESS on success, %MDADM_STATUS_ERROR on fail. ++ */ ++static mdadm_status_t ++ata_pass_through12_ioctl(int disk_fd, __u8 ata_command, __u8 sec_protocol, __u16 comm_id, ++ void *response_buffer, size_t buf_size, const int verbose) ++{ ++ __u8 cdb[ATA_INQUIRY_LENGTH] = {0}; ++ __u8 sense[SG_SENSE_SIZE] = {0}; ++ __u8 *sense_desc = NULL; ++ sg_io_hdr_t sg = {0}; ++ ++ /* ++ * ATA Command Pass-Through, chapter 13.2.2 ++ * SCSI Primary Commands - 4 (SPC-4) ++ * ATA Translation - 3 (SAT-3) ++ */ ++ cdb[0] = ATA_PASS_THROUGH_12; ++ /* protocol, bits 1-4 */ ++ cdb[1] = ATA_PIO_DATA_IN << 1; ++ /* Bytes: CK_COND=1, T_DIR = 1, BYTE_BLOCK = 1, Length in Sector Count = 2 */ ++ cdb[2] = 0x2E; ++ cdb[3] = sec_protocol; ++ /* Sector count */ ++ cdb[4] = buf_size / DEFAULT_SECTOR_SIZE; ++ cdb[6] = (comm_id) & 0xFF; ++ cdb[7] = (comm_id >> 8) & 0xFF; ++ cdb[9] = ata_command; ++ ++ sg.interface_id = SG_INTERFACE_ID; ++ sg.cmd_len = sizeof(cdb); ++ sg.mx_sb_len = sizeof(sense); ++ sg.dxfer_direction = SG_DXFER_FROM_DEV; ++ sg.dxfer_len = buf_size; ++ sg.dxferp = response_buffer; ++ sg.cmdp = cdb; ++ sg.sbp = sense; ++ sg.timeout = SG_IO_TIMEOUT; ++ sg.usr_ptr = NULL; ++ ++ if (ioctl(disk_fd, SG_IO, &sg) < 0) { ++ pr_vrb("Failed ata passthrough12 ioctl. Device: /dev/%s.\n", fd2kname(disk_fd)); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ if ((sg.status && sg.status != SG_CHECK_CONDITION) || sg.host_status || ++ (sg.driver_status && sg.driver_status != SG_DRIVER_SENSE)) { ++ pr_vrb("Failed ata passthrough12 ioctl. Device: /dev/%s.\n", fd2kname(disk_fd)); ++ pr_vrb("SG_IO error: ATA_12 Status: %d Host Status: %d, Driver Status: %d\n", ++ sg.status, sg.host_status, sg.driver_status); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ /* verify expected sense response code */ ++ if (!(sense[0] == SENSE_DATA_CURRENT_DESC || sense[0] == SENSE_DATA_CURRENT_FIXED)) { ++ pr_vrb("Failed ata passthrough12 ioctl. Device: /dev/%s.\n", fd2kname(disk_fd)); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ sense_desc = sense + SENSE_CURRENT_RES_DESC_POS; ++ /* verify sense data current response with descriptor format */ ++ if (sense[0] == SENSE_DATA_CURRENT_DESC && ++ !(sense_desc[0] == ATA_STATUS_RETURN_DESCRIPTOR && ++ sense_desc[1] == ATA_INQUIRY_LENGTH)) { ++ pr_vrb("Failed ata passthrough12 ioctl. Device: /dev/%s. Sense data ASC: %d, ASCQ: %d.\n", ++ fd2kname(disk_fd), sense[2], sense[3]); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ /* verify sense data current response with fixed format */ ++ if (sense[0] == SENSE_DATA_CURRENT_FIXED && ++ !(sense[12] == ATA_PT_INFORMATION_AVAILABLE_ASC && ++ sense[13] == ATA_PT_INFORMATION_AVAILABLE_ASCQ)) { ++ pr_vrb("Failed ata passthrough12 ioctl. Device: /dev/%s. Sense data ASC: %d, ASCQ: %d.\n", ++ fd2kname(disk_fd), sense[12], sense[13]); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ return MDADM_STATUS_SUCCESS; ++} ++ ++/** ++ * is_sec_prot_01h_supported_ata() - check if security protocol 01h supported for given SATA disk. ++ * @disk_fd: a disk file descriptor. ++ * @verbose: verbose flag. ++ * ++ * Return: %DRIVE_FEAT_SUP_ST if TCG_SECP_01 supported, %DRIVE_FEAT_NOT_SUP_ST if not supported, ++ * %DRIVE_FEAT_CHECK_FAILED_ST if failed. ++ */ ++static drive_feat_sup_st is_sec_prot_01h_supported_ata(int disk_fd, const int verbose) ++{ ++ supported_security_protocols_t security_protocols; ++ ++ mdadm_status_t result = ata_pass_through12_ioctl(disk_fd, ATA_TRUSTED_RECEIVE, TCG_SECP_00, ++ 0x0, &security_protocols, ++ sizeof(security_protocols), verbose); ++ if (result) ++ return DRIVE_FEAT_CHECK_FAILED_ST; ++ ++ if (is_sec_prot_01h_supported(&security_protocols)) ++ return DRIVE_FEAT_SUP_ST; ++ ++ return DRIVE_FEAT_NOT_SUP_ST; ++} ++ ++/** ++ * is_ata_trusted_computing_supported() - check if ata trusted computing supported. ++ * @buffer: buffer with ATA identify response, not NULL. ++ * ++ * Return: true if trusted computing bit set, false otherwise. ++ */ ++bool is_ata_trusted_computing_supported(__u16 *buffer) ++{ ++ /* Added due to warnings from the compiler about a possible uninitialized variable below. */ ++ assert(buffer); ++ ++ __u16 security_tc_frame = __le16_to_cpu(buffer[ATA_TRUSTED_COMPUTING_POS]); ++ ata_trusted_computing_t *security_tc = (ata_trusted_computing_t *)&security_tc_frame; ++ ++ if (security_tc->tc_feature == 1) ++ return true; ++ ++ return false; ++} ++ ++/** ++ * get_ata_standard_security_status() - get ATA disk encryption information from ATA identify. ++ * @buffer: buffer with response from ATA identify, not NULL. ++ * @information: struct to fill out, describing encryption status of disk. ++ * ++ * The function based on the Security status frame from ATA identify, ++ * completed encryption information. ++ * For possible encryption statuses and abilities, ++ * please refer to enums &encryption_status and &encryption_ability. ++ * ++ * Return: %MDADM_STATUS_SUCCESS on success, %MDADM_STATUS_ERROR on fail. ++ */ ++static mdadm_status_t get_ata_standard_security_status(__u16 *buffer, ++ struct encryption_information *information) ++{ ++ /* Added due to warnings from the compiler about a possible uninitialized variable below. */ ++ assert(buffer); ++ ++ __u16 security_status_frame = __le16_to_cpu(buffer[ATA_SECURITY_WORD_POSITION]); ++ ata_security_status_t *security_status = (ata_security_status_t *)&security_status_frame; ++ ++ if (!security_status->security_supported) { ++ information->ability = ENC_ABILITY_NONE; ++ information->status = ENC_STATUS_UNENCRYPTED; ++ ++ return MDADM_STATUS_SUCCESS; ++ } ++ ++ information->ability = ENC_ABILITY_OTHER; ++ ++ if (security_status->security_enabled == 0) ++ information->status = ENC_STATUS_UNENCRYPTED; ++ else if (security_status->security_locked == 1) ++ information->status = ENC_STATUS_LOCKED; ++ else ++ information->status = ENC_STATUS_UNLOCKED; ++ ++ return MDADM_STATUS_SUCCESS; ++} ++ ++/** ++ * is_ata_opal() - check if SATA disk support Opal. ++ * @disk_fd: a disk file descriptor. ++ * @buffer: buffer with ATA identify response. ++ * @verbose: verbose flag. ++ * ++ * Return: %DRIVE_FEAT_SUP_ST if TCG_SECP_01 supported, %DRIVE_FEAT_NOT_SUP_ST if not supported, ++ * %DRIVE_FEAT_CHECK_FAILED_ST if failed to check. ++ */ ++static drive_feat_sup_st is_ata_opal(int disk_fd, __u16 *buffer_identify, const int verbose) ++{ ++ bool tc_status = is_ata_trusted_computing_supported(buffer_identify); ++ drive_feat_sup_st tcg_sec_prot_status; ++ ++ if (!tc_status) ++ return DRIVE_FEAT_NOT_SUP_ST; ++ ++ tcg_sec_prot_status = is_sec_prot_01h_supported_ata(disk_fd, verbose); ++ ++ if (tcg_sec_prot_status == DRIVE_FEAT_CHECK_FAILED_ST) { ++ pr_vrb("Failed to verify if security protocol 01h supported. Device /dev/%s.\n", ++ fd2kname(disk_fd)); ++ return DRIVE_FEAT_CHECK_FAILED_ST; ++ } ++ ++ if (tc_status && tcg_sec_prot_status == DRIVE_FEAT_SUP_ST) ++ return DRIVE_FEAT_SUP_ST; ++ ++ return DRIVE_FEAT_NOT_SUP_ST; ++} ++ ++/** ++ * get_ata_encryption_information() - get ATA disk encryption information. ++ * @disk_fd: a disk file descriptor. ++ * @information: struct to fill out, describing encryption status of disk. ++ * @verbose: verbose flag. ++ * ++ * The function reads information about encryption, if the disk supports Opal, ++ * the information is completed based on Opal Level 0 discovery, otherwise, ++ * based on ATA security status frame from ATA identification response. ++ * For possible encryption statuses and abilities, ++ * please refer to enums &encryption_status and &encryption_ability. ++ * ++ * Based on the documentations ATA/ATAPI Command Set ATA8-ACS and ++ * AT Attachment-8 - ATA Serial Transport (ATA8-AST). ++ * ++ * Return: %MDADM_STATUS_SUCCESS on success, %MDADM_STATUS_ERROR on fail. ++ */ ++mdadm_status_t ++get_ata_encryption_information(int disk_fd, struct encryption_information *information, ++ const int verbose) ++{ ++ __u8 buffer_opal_level0_discovery[OPAL_IO_BUFFER_LEN] = {0}; ++ __u16 buffer_identify[ATA_IDENTIFY_RESPONSE_LEN] = {0}; ++ drive_feat_sup_st ata_opal_status; ++ mdadm_status_t status; ++ ++ /* Get disk ATA identification */ ++ status = ata_pass_through12_ioctl(disk_fd, ATA_IDENTIFY, 0x0, 0x0, buffer_identify, ++ sizeof(buffer_identify), verbose); ++ if (status == MDADM_STATUS_ERROR) ++ return MDADM_STATUS_ERROR; ++ ++ if (is_ata_trusted_computing_supported(buffer_identify) && ++ !sysfs_is_libata_allow_tpm_enabled(verbose)) { ++ pr_vrb("For SATA with Trusted Computing support, required libata.tpm_enabled=1.\n"); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ ata_opal_status = is_ata_opal(disk_fd, buffer_identify, verbose); ++ if (ata_opal_status == DRIVE_FEAT_CHECK_FAILED_ST) ++ return MDADM_STATUS_ERROR; ++ ++ if (ata_opal_status == DRIVE_FEAT_NOT_SUP_ST) ++ return get_ata_standard_security_status(buffer_identify, information); ++ ++ /* SATA Opal */ ++ status = ata_pass_through12_ioctl(disk_fd, ATA_TRUSTED_RECEIVE, TCG_SECP_01, ++ OPAL_DISCOVERY_COMID, buffer_opal_level0_discovery, ++ OPAL_IO_BUFFER_LEN, verbose); ++ if (status != MDADM_STATUS_SUCCESS) ++ return MDADM_STATUS_ERROR; ++ ++ return get_opal_encryption_information(buffer_opal_level0_discovery, information); ++} +diff --git a/drive_encryption.h b/drive_encryption.h +index 82c2c624..77c7f10f 100644 +--- a/drive_encryption.h ++++ b/drive_encryption.h +@@ -30,3 +30,6 @@ typedef struct encryption_information { + mdadm_status_t + get_nvme_opal_encryption_information(int disk_fd, struct encryption_information *information, + const int verbose); ++mdadm_status_t ++get_ata_encryption_information(int disk_fd, struct encryption_information *information, ++ const int verbose); +diff --git a/mdadm.h b/mdadm.h +index fbb161ba..52a66b9a 100644 +--- a/mdadm.h ++++ b/mdadm.h +@@ -853,6 +853,7 @@ extern int restore_stripes(int *dest, unsigned long long *offsets, + int source, unsigned long long read_offset, + unsigned long long start, unsigned long long length, + char *src_buf); ++extern bool sysfs_is_libata_allow_tpm_enabled(const int verbose); + + #ifndef Sendmail + #define Sendmail "/usr/lib/sendmail -t" +diff --git a/sysfs.c b/sysfs.c +index 4ded1672..20fe1e9e 100644 +--- a/sysfs.c ++++ b/sysfs.c +@@ -1121,3 +1121,32 @@ void sysfsline(char *line) + sr->next = sysfs_rules; + sysfs_rules = sr; + } ++ ++/** ++ * sysfs_is_libata_allow_tpm_enabled() - check if libata allow_tmp is enabled. ++ * @verbose: verbose flag. ++ * ++ * Check if libata allow_tmp flag is set, this is required for SATA Opal Security commands to work. ++ * ++ * Return: true if allow_tpm enable, false otherwise. ++ */ ++bool sysfs_is_libata_allow_tpm_enabled(const int verbose) ++{ ++ const char *path = "/sys/module/libata/parameters/allow_tpm"; ++ const char *expected_value = "1"; ++ int fd = open(path, O_RDONLY); ++ char buf[3]; ++ ++ if (!is_fd_valid(fd)) { ++ pr_vrb("Failed open file descriptor to %s. Cannot check libata allow_tpm param.\n", ++ path); ++ return false; ++ } ++ ++ sysfs_fd_get_str(fd, buf, sizeof(buf)); ++ close(fd); ++ ++ if (strncmp(buf, expected_value, 1) == 0) ++ return true; ++ return false; ++} +-- +2.41.0 + diff --git a/0045-Add-key-ENCRYPTION_NO_VERIFY-to-conf.patch b/0045-Add-key-ENCRYPTION_NO_VERIFY-to-conf.patch new file mode 100644 index 0000000..13ea340 --- /dev/null +++ b/0045-Add-key-ENCRYPTION_NO_VERIFY-to-conf.patch @@ -0,0 +1,163 @@ +From 336e13fc5ef43bc5b4633a9dadac5f7208e6c241 Mon Sep 17 00:00:00 2001 +From: Blazej Kucman +Date: Fri, 22 Mar 2024 12:51:18 +0100 +Subject: [PATCH 45/69] Add key ENCRYPTION_NO_VERIFY to conf + +Add ENCRYPTION_NO_VERIFY config key and allow to disable checking +encryption status for given type of drives. + +The key is introduced because of SATA Opal disks for which TPM commands +must be enabled in libata kernel module, (libata.allow_tpm=1), otherwise +it is impossible to verify encryption status. TPM commands are disabled by +default. + +Currently the key only supports the "sata_opal" value, if necessary, +the functionality is ready to support more types of disks. This +functionality will be used in the next patches. + +Signed-off-by: Blazej Kucman +Signed-off-by: Mariusz Tkaczyk +--- + config.c | 25 ++++++++++++++++++++++++- + drive_encryption.c | 16 ++++++++++++---- + mdadm.conf.5.in | 13 +++++++++++++ + mdadm.h | 1 + + 4 files changed, 50 insertions(+), 5 deletions(-) + +diff --git a/config.c b/config.c +index 44f7dd2f..b46d71cb 100644 +--- a/config.c ++++ b/config.c +@@ -81,7 +81,7 @@ char DefaultAltConfDir[] = CONFFILE2 ".d"; + + enum linetype { Devices, Array, Mailaddr, Mailfrom, Program, CreateDev, + Homehost, HomeCluster, AutoMode, Policy, PartPolicy, Sysfs, +- MonitorDelay, LTEnd }; ++ MonitorDelay, EncryptionNoVerify, LTEnd }; + char *keywords[] = { + [Devices] = "devices", + [Array] = "array", +@@ -96,6 +96,7 @@ char *keywords[] = { + [PartPolicy]="part-policy", + [Sysfs] = "sysfs", + [MonitorDelay] = "monitordelay", ++ [EncryptionNoVerify] = "ENCRYPTION_NO_VERIFY", + [LTEnd] = NULL + }; + +@@ -729,6 +730,19 @@ void monitordelayline(char *line) + } + } + ++static bool sata_opal_encryption_no_verify; ++void encryption_no_verify_line(char *line) ++{ ++ char *word; ++ ++ for (word = dl_next(line); word != line; word = dl_next(word)) { ++ if (strcasecmp(word, "sata_opal") == 0) ++ sata_opal_encryption_no_verify = true; ++ else ++ pr_err("unrecognised word on ENCRYPTION_NO_VERIFY line: %s\n", word); ++ } ++} ++ + char auto_yes[] = "yes"; + char auto_no[] = "no"; + char auto_homehost[] = "homehost"; +@@ -913,6 +927,9 @@ void conf_file(FILE *f) + case MonitorDelay: + monitordelayline(line); + break; ++ case EncryptionNoVerify: ++ encryption_no_verify_line(line); ++ break; + default: + pr_err("Unknown keyword %s\n", line); + } +@@ -1075,6 +1092,12 @@ int conf_get_monitor_delay(void) + return monitor_delay; + } + ++bool conf_get_sata_opal_encryption_no_verify(void) ++{ ++ load_conffile(); ++ return sata_opal_encryption_no_verify; ++} ++ + struct createinfo *conf_get_create_info(void) + { + load_conffile(); +diff --git a/drive_encryption.c b/drive_encryption.c +index d520f0c7..6b2bd358 100644 +--- a/drive_encryption.c ++++ b/drive_encryption.c +@@ -656,10 +656,18 @@ get_ata_encryption_information(int disk_fd, struct encryption_information *infor + if (status == MDADM_STATUS_ERROR) + return MDADM_STATUS_ERROR; + +- if (is_ata_trusted_computing_supported(buffer_identify) && +- !sysfs_is_libata_allow_tpm_enabled(verbose)) { +- pr_vrb("For SATA with Trusted Computing support, required libata.tpm_enabled=1.\n"); +- return MDADM_STATUS_ERROR; ++ /* Possible OPAL support, further checks require tpm_enabled.*/ ++ if (is_ata_trusted_computing_supported(buffer_identify)) { ++ /* OPAL SATA encryption checking disabled. */ ++ if (conf_get_sata_opal_encryption_no_verify()) ++ return MDADM_STATUS_SUCCESS; ++ ++ if (!sysfs_is_libata_allow_tpm_enabled(verbose)) { ++ pr_vrb("Detected SATA drive /dev/%s with Trusted Computing support.\n", ++ fd2kname(disk_fd)); ++ pr_vrb("Cannot verify encryption state. Requires libata.tpm_enabled=1.\n"); ++ return MDADM_STATUS_ERROR; ++ } + } + + ata_opal_status = is_ata_opal(disk_fd, buffer_identify, verbose); +diff --git a/mdadm.conf.5.in b/mdadm.conf.5.in +index 787e51e9..afb0a296 100644 +--- a/mdadm.conf.5.in ++++ b/mdadm.conf.5.in +@@ -636,6 +636,17 @@ If multiple + .B MINITORDELAY + lines are provided, only first non-zero value is considered. + ++.TP ++.B ENCRYPTION_NO_VERIFY ++The ++.B ENCRYPTION_NO_VERIFY ++disables encryption verification for devices with particular encryption support detected. ++Currently, only verification of SATA OPAL encryption can be disabled. ++It does not disable ATA security encryption verification. ++Available parameter ++.I "sata_opal". ++ ++ + .SH FILES + + .SS {CONFFILE} +@@ -744,6 +755,8 @@ SYSFS uuid=bead5eb6:31c17a27:da120ba2:7dfda40d group_thread_cnt=4 + sync_speed_max=1000000 + .br + MONITORDELAY 60 ++.br ++ENCRYPTION_NO_VERIFY sata_opal + + .SH SEE ALSO + .BR mdadm (8), +diff --git a/mdadm.h b/mdadm.h +index 52a66b9a..2640b396 100644 +--- a/mdadm.h ++++ b/mdadm.h +@@ -1673,6 +1673,7 @@ extern char *conf_get_program(void); + extern char *conf_get_homehost(int *require_homehostp); + extern char *conf_get_homecluster(void); + extern int conf_get_monitor_delay(void); ++extern bool conf_get_sata_opal_encryption_no_verify(void); + extern char *conf_line(FILE *file); + extern char *conf_word(FILE *file, int allow_key); + extern void print_quoted(char *str); +-- +2.41.0 + diff --git a/0046-imsm-print-disk-encryption-information.patch b/0046-imsm-print-disk-encryption-information.patch new file mode 100644 index 0000000..3d7767d --- /dev/null +++ b/0046-imsm-print-disk-encryption-information.patch @@ -0,0 +1,217 @@ +From bf62ed5d9642aa60abf4ac2d1d89f173bd66ae48 Mon Sep 17 00:00:00 2001 +From: Blazej Kucman +Date: Fri, 22 Mar 2024 12:51:19 +0100 +Subject: [PATCH 46/69] imsm: print disk encryption information + +Print SATA/NVMe disk encryption information in --detail-platform. +Encryption Ability and Status will be printed for each disk. + +There is one exception, Opal SATA drives encryption is not checked when +ENCRYPTION_NO_VERIFY key with "sata_opal" value is set in conf, for this +reason such drives are treated as without encryption support. + +To test this feature, drives SATA/NVMe with Opal support or SATA drives +with encryption support have to be used. + +Example outputs of --detail-platform: + +Non Opal, encryption enabled, SATA drive: +Port0 : /dev/sdc (CVPR050600G3120LGN) + Encryption(Ability|Status): Other|Unlocked + +NVMe drive without Opal support: +NVMe under VMD : /dev/nvme2n1 (PHLF737302GB1P0GGN) + Encryption(Ability|Status): None|Unencrypted + +Unencrypted SATA drive with OPAL support: + +- default allow_tpm, we will get an error from mdadm: + Port6 : /dev/sdi (CVTS4246015V180IGN) +mdadm: Detected SATA drive /dev/sdi with Trusted Computing support. +mdadm: Cannot verify encryption state. Requires libata.tpm_enabled=1. +mdadm: Failed to get drive encrytpion information. + +- default "allow_tpm" and config entry "ENCRYPTION_NO_VERIFY sata_opal": +Port6 : /dev/sdi (CVTS4246015V180IGN) + Encryption(Ability|Status): None|Unencrypted + +- added "libata.allow_tpm=1" to boot parameters(requires reboot), +the status will be read correctly: +Port6 : /dev/sdi (CVTS4246015V180IGN) + Encryption(Ability|Status): SED|Unencrypted + +Signed-off-by: Blazej Kucman +Signed-off-by: Mariusz Tkaczyk +--- + drive_encryption.c | 36 ++++++++++++++++++++++++++++++++++++ + drive_encryption.h | 2 ++ + mdadm.conf.5.in | 3 +++ + super-intel.c | 42 ++++++++++++++++++++++++++++++++++++++---- + 4 files changed, 79 insertions(+), 4 deletions(-) + +diff --git a/drive_encryption.c b/drive_encryption.c +index 6b2bd358..27da9621 100644 +--- a/drive_encryption.c ++++ b/drive_encryption.c +@@ -141,6 +141,42 @@ typedef struct ata_trusted_computing { + __u16 var2 : 1; + } __attribute__((__packed__)) ata_trusted_computing_t; + ++mapping_t encryption_ability_map[] = { ++ { "None", ENC_ABILITY_NONE }, ++ { "Other", ENC_ABILITY_OTHER }, ++ { "SED", ENC_ABILITY_SED }, ++ { NULL, UnSet } ++}; ++ ++mapping_t encryption_status_map[] = { ++ { "Unencrypted", ENC_STATUS_UNENCRYPTED }, ++ { "Locked", ENC_STATUS_LOCKED }, ++ { "Unlocked", ENC_STATUS_UNLOCKED }, ++ { NULL, UnSet } ++}; ++ ++/** ++ * get_encryption_ability_string() - get encryption ability name string. ++ * @ability: encryption ability enum. ++ * ++ * Return: encryption ability string. ++ */ ++const char *get_encryption_ability_string(enum encryption_ability ability) ++{ ++ return map_num_s(encryption_ability_map, ability); ++} ++ ++/** ++ * get_encryption_status_string() - get encryption status name string. ++ * @ability: encryption status enum. ++ * ++ * Return: encryption status string. ++ */ ++const char *get_encryption_status_string(enum encryption_status status) ++{ ++ return map_num_s(encryption_status_map, status); ++} ++ + /** + * get_opal_locking_feature_description() - get opal locking feature description. + * @response: response from Opal Discovery Level 0. +diff --git a/drive_encryption.h b/drive_encryption.h +index 77c7f10f..0cb8ff1b 100644 +--- a/drive_encryption.h ++++ b/drive_encryption.h +@@ -33,3 +33,5 @@ get_nvme_opal_encryption_information(int disk_fd, struct encryption_information + mdadm_status_t + get_ata_encryption_information(int disk_fd, struct encryption_information *information, + const int verbose); ++const char *get_encryption_ability_string(enum encryption_ability ability); ++const char *get_encryption_status_string(enum encryption_status status); +diff --git a/mdadm.conf.5.in b/mdadm.conf.5.in +index afb0a296..14302a91 100644 +--- a/mdadm.conf.5.in ++++ b/mdadm.conf.5.in +@@ -643,6 +643,9 @@ The + disables encryption verification for devices with particular encryption support detected. + Currently, only verification of SATA OPAL encryption can be disabled. + It does not disable ATA security encryption verification. ++Currently effective only for ++.I IMSM ++metadata. + Available parameter + .I "sata_opal". + +diff --git a/super-intel.c b/super-intel.c +index 212387ec..fbd1c11f 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -27,6 +27,7 @@ + #include + #include + #include ++#include "drive_encryption.h" + + /* MPB == Metadata Parameter Block */ + #define MPB_SIGNATURE "Intel Raid ISM Cfg Sig. " +@@ -2349,12 +2350,41 @@ static int imsm_read_serial(int fd, char *devname, __u8 *serial, + size_t serial_buf_len); + static void fd2devname(int fd, char *name); + +-static int ahci_enumerate_ports(const char *hba_path, int port_count, int host_base, int verbose) ++void print_encryption_information(int disk_fd, enum sys_dev_type hba_type) ++{ ++ struct encryption_information information = {0}; ++ mdadm_status_t status = MDADM_STATUS_SUCCESS; ++ const char *indent = " "; ++ ++ switch (hba_type) { ++ case SYS_DEV_VMD: ++ case SYS_DEV_NVME: ++ status = get_nvme_opal_encryption_information(disk_fd, &information, 1); ++ break; ++ case SYS_DEV_SATA: ++ case SYS_DEV_SATA_VMD: ++ status = get_ata_encryption_information(disk_fd, &information, 1); ++ break; ++ default: ++ return; ++ } ++ ++ if (status) { ++ pr_err("Failed to get drive encryption information.\n"); ++ return; ++ } ++ ++ printf("%sEncryption(Ability|Status): %s|%s\n", indent, ++ get_encryption_ability_string(information.ability), ++ get_encryption_status_string(information.status)); ++} ++ ++static int ahci_enumerate_ports(struct sys_dev *hba, int port_count, int host_base, int verbose) + { + /* dump an unsorted list of devices attached to AHCI Intel storage + * controller, as well as non-connected ports + */ +- int hba_len = strlen(hba_path) + 1; ++ int hba_len = strlen(hba->path) + 1; + struct dirent *ent; + DIR *dir; + char *path = NULL; +@@ -2390,7 +2420,7 @@ static int ahci_enumerate_ports(const char *hba_path, int port_count, int host_b + path = devt_to_devpath(makedev(major, minor), 1, NULL); + if (!path) + continue; +- if (!path_attached_to_hba(path, hba_path)) { ++ if (!path_attached_to_hba(path, hba->path)) { + free(path); + path = NULL; + continue; +@@ -2493,6 +2523,8 @@ static int ahci_enumerate_ports(const char *hba_path, int port_count, int host_b + printf(" (%s)\n", buf); + else + printf(" ()\n"); ++ ++ print_encryption_information(fd, hba->type); + close(fd); + } + free(path); +@@ -2557,6 +2589,8 @@ static int print_nvme_info(struct sys_dev *hba) + else + printf("()\n"); + ++ print_encryption_information(fd, hba->type); ++ + skip: + close_fd(&fd); + } +@@ -2812,7 +2846,7 @@ static int detail_platform_imsm(int verbose, int enumerate_only, char *controlle + hba->path, get_sys_dev_type(hba->type)); + if (hba->type == SYS_DEV_SATA || hba->type == SYS_DEV_SATA_VMD) { + host_base = ahci_get_port_count(hba->path, &port_count); +- if (ahci_enumerate_ports(hba->path, port_count, host_base, verbose)) { ++ if (ahci_enumerate_ports(hba, port_count, host_base, verbose)) { + if (verbose > 0) + pr_err("failed to enumerate ports on %s controller at %s.\n", + get_sys_dev_type(hba->type), hba->pci_id); +-- +2.41.0 + diff --git a/0047-imsm-drive-encryption-policy-implementation.patch b/0047-imsm-drive-encryption-policy-implementation.patch new file mode 100644 index 0000000..91d3292 --- /dev/null +++ b/0047-imsm-drive-encryption-policy-implementation.patch @@ -0,0 +1,114 @@ +From acb8f13be88c224eb1e01f72c1e1fda955bc80ba Mon Sep 17 00:00:00 2001 +From: Blazej Kucman +Date: Fri, 22 Mar 2024 12:51:20 +0100 +Subject: [PATCH 47/69] imsm: drive encryption policy implementation + +IMSM cares about drive encryption state. It is not allowed to mix disks +with different encryption state within one md device. This policy will +verify that attempt to use disks with different encryption states will +fail. Verification is performed for devices NVMe/SATA Opal and SATA. + +There is one exception, Opal SATA drives encryption is not checked when +ENCRYPTION_NO_VERIFY key with "sata_opal" value is set in conf, for this +reason such drives are treated as without encryption support. + +Signed-off-by: Blazej Kucman +Signed-off-by: Mariusz Tkaczyk +--- + super-intel.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 73 insertions(+) + +diff --git a/super-intel.c b/super-intel.c +index fbd1c11f..1faab607 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -11291,6 +11291,78 @@ test_and_add_drive_controller_policy_imsm(const char * const type, dev_policy_t + return MDADM_STATUS_ERROR; + } + ++/** ++ * test_and_add_drive_encryption_policy_imsm() - add disk encryption to policies list. ++ * @type: policy type to search in the list. ++ * @pols: list of currently recorded policies. ++ * @disk_fd: file descriptor of the device to check. ++ * @hba: The hba to which the drive is attached, could be NULL if verification is disabled. ++ * @verbose: verbose flag. ++ * ++ * IMSM cares about drive encryption state. It is not allowed to mix disks with different ++ * encryption state within one md device. ++ * If there is no encryption policy on pols we are free to add first one. ++ * If there is a policy then, new must be the same. ++ */ ++static mdadm_status_t ++test_and_add_drive_encryption_policy_imsm(const char * const type, dev_policy_t **pols, int disk_fd, ++ struct sys_dev *hba, const int verbose) ++{ ++ struct dev_policy *expected_policy = pol_find(*pols, (char *)type); ++ struct encryption_information information = {0}; ++ char *encryption_state = "Unknown"; ++ int status = MDADM_STATUS_SUCCESS; ++ bool encryption_checked = true; ++ char devname[PATH_MAX]; ++ ++ if (!hba) ++ goto check_policy; ++ ++ switch (hba->type) { ++ case SYS_DEV_NVME: ++ case SYS_DEV_VMD: ++ status = get_nvme_opal_encryption_information(disk_fd, &information, verbose); ++ break; ++ case SYS_DEV_SATA: ++ case SYS_DEV_SATA_VMD: ++ status = get_ata_encryption_information(disk_fd, &information, verbose); ++ break; ++ default: ++ encryption_checked = false; ++ } ++ ++ if (status) { ++ fd2devname(disk_fd, devname); ++ pr_vrb("Failed to read encryption information of device %s\n", devname); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ if (encryption_checked) { ++ if (information.status == ENC_STATUS_LOCKED) { ++ fd2devname(disk_fd, devname); ++ pr_vrb("Device %s is in Locked state, cannot use. Aborting.\n", devname); ++ return MDADM_STATUS_ERROR; ++ } ++ encryption_state = (char *)get_encryption_status_string(information.status); ++ } ++ ++check_policy: ++ if (expected_policy) { ++ if (strcmp(expected_policy->value, encryption_state) == 0) ++ return MDADM_STATUS_SUCCESS; ++ ++ fd2devname(disk_fd, devname); ++ pr_vrb("Encryption status \"%s\" detected for disk %s, but \"%s\" status was detected eariler.\n", ++ encryption_state, devname, expected_policy->value); ++ pr_vrb("Disks with different encryption status cannot be used.\n"); ++ return MDADM_STATUS_ERROR; ++ } ++ ++ pol_add(pols, (char *)type, encryption_state, "imsm"); ++ ++ return MDADM_STATUS_SUCCESS; ++} ++ + struct imsm_drive_policy { + char *type; + mdadm_status_t (*test_and_add_drive_policy)(const char * const type, +@@ -11300,6 +11372,7 @@ struct imsm_drive_policy { + + struct imsm_drive_policy imsm_policies[] = { + {"controller", test_and_add_drive_controller_policy_imsm}, ++ {"encryption", test_and_add_drive_encryption_policy_imsm} + }; + + mdadm_status_t test_and_add_drive_policies_imsm(struct dev_policy **pols, int disk_fd, +-- +2.41.0 + diff --git a/0048-mdadm-add-CHANGELOG.md.patch b/0048-mdadm-add-CHANGELOG.md.patch new file mode 100644 index 0000000..1432c1e --- /dev/null +++ b/0048-mdadm-add-CHANGELOG.md.patch @@ -0,0 +1,2010 @@ +From 275e5d2fe316202cce5cb1319a83c3cd8fb22dd3 Mon Sep 17 00:00:00 2001 +From: Mariusz Tkaczyk +Date: Tue, 26 Mar 2024 13:21:10 +0100 +Subject: [PATCH 48/69] mdadm: add CHANGELOG.md + +Bring changelog back to life. Remove ANNOUCEs. It will use markdown +format, to have one style. All releases are migrated to new +changelog. It was a exercise I have taken, to familiarize with the +mdadm history. + +Signed-off-by: Mariusz Tkaczyk +--- + ANNOUNCE-3.0 | 98 ------------- + ANNOUNCE-3.0.1 | 22 --- + ANNOUNCE-3.0.2 | 21 --- + ANNOUNCE-3.0.3 | 29 ---- + ANNOUNCE-3.1 | 33 ----- + ANNOUNCE-3.1.1 | 39 ------ + ANNOUNCE-3.1.2 | 46 ------- + ANNOUNCE-3.1.3 | 46 ------- + ANNOUNCE-3.1.4 | 37 ----- + ANNOUNCE-3.1.5 | 42 ------ + ANNOUNCE-3.2 | 77 ----------- + ANNOUNCE-3.2.1 | 75 ---------- + ANNOUNCE-3.2.2 | 36 ----- + ANNOUNCE-3.2.3 | 24 ---- + ANNOUNCE-3.2.4 | 144 ------------------- + ANNOUNCE-3.2.5 | 31 ----- + ANNOUNCE-3.2.6 | 57 -------- + ANNOUNCE-3.3 | 63 --------- + ANNOUNCE-3.3.1 | 23 ---- + ANNOUNCE-3.3.2 | 16 --- + ANNOUNCE-3.3.3 | 18 --- + ANNOUNCE-3.3.4 | 37 ----- + ANNOUNCE-3.4 | 24 ---- + ANNOUNCE-4.0 | 22 --- + ANNOUNCE-4.1 | 16 --- + ANNOUNCE-4.2 | 19 --- + CHANGELOG.md | 368 +++++++++++++++++++++++++++++++++++++++++++++++++ + ChangeLog | 306 ---------------------------------------- + 28 files changed, 368 insertions(+), 1401 deletions(-) + delete mode 100644 ANNOUNCE-3.0 + delete mode 100644 ANNOUNCE-3.0.1 + delete mode 100644 ANNOUNCE-3.0.2 + delete mode 100644 ANNOUNCE-3.0.3 + delete mode 100644 ANNOUNCE-3.1 + delete mode 100644 ANNOUNCE-3.1.1 + delete mode 100644 ANNOUNCE-3.1.2 + delete mode 100644 ANNOUNCE-3.1.3 + delete mode 100644 ANNOUNCE-3.1.4 + delete mode 100644 ANNOUNCE-3.1.5 + delete mode 100644 ANNOUNCE-3.2 + delete mode 100644 ANNOUNCE-3.2.1 + delete mode 100644 ANNOUNCE-3.2.2 + delete mode 100644 ANNOUNCE-3.2.3 + delete mode 100644 ANNOUNCE-3.2.4 + delete mode 100644 ANNOUNCE-3.2.5 + delete mode 100644 ANNOUNCE-3.2.6 + delete mode 100644 ANNOUNCE-3.3 + delete mode 100644 ANNOUNCE-3.3.1 + delete mode 100644 ANNOUNCE-3.3.2 + delete mode 100644 ANNOUNCE-3.3.3 + delete mode 100644 ANNOUNCE-3.3.4 + delete mode 100644 ANNOUNCE-3.4 + delete mode 100644 ANNOUNCE-4.0 + delete mode 100644 ANNOUNCE-4.1 + delete mode 100644 ANNOUNCE-4.2 + create mode 100644 CHANGELOG.md + delete mode 100644 ChangeLog + +diff --git a/ANNOUNCE-3.0 b/ANNOUNCE-3.0 +deleted file mode 100644 +index f2d4f847..00000000 +--- a/ANNOUNCE-3.0 ++++ /dev/null +@@ -1,98 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.0 - A tool for managing Soft RAID under Linux +- +-I am pleased to (finally) announce the availability of +- mdadm version 3.0 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +- +-This is a major new version and as such should be treated with some +-caution. However it has seen substantial testing and is considerred +-to be ready for wide use. +- +- +-The significant change which justifies the new major version number is +-that mdadm can now handle metadata updates entirely in userspace. +-This allows mdadm to support metadata formats that the kernel knows +-nothing about. +- +-Currently two such metadata formats are supported: +- - DDF - The SNIA standard format +- - Intel Matrix - The metadata used by recent Intel ICH controlers. +- +-Also the approach to device names has changed significantly. +- +-If udev is installed on the system, mdadm will not create any devices +-in /dev. Rather it allows udev to manage those devices. For this to work +-as expected, the included udev rules file should be installed. +- +-If udev is not installed, mdadm will still create devices and symlinks +-as required, and will also remove them when the array is stopped. +- +-mdadm now requires all devices which do not have a standard name (mdX +-or md_dX) to live in the directory /dev/md/. Names in this directory +-will always be created as symlinks back to the standard name in /dev. +- +-The man pages contain some information about the new externally managed +-metadata. However see below for a more condensed overview. +- +-Externally managed metadata introduces the concept of a 'container'. +-A container is a collection of (normally) physical devices which have +-a common set of metadata. A container is assembled as an md array, but +-is left 'inactive'. +- +-A container can contain one or more data arrays. These are composed from +-slices (partitions?) of various devices in the container. +- +-For example, a 5 devices DDF set can container a RAID1 using the first +-half of two devices, a RAID0 using the first half of the remain 3 devices, +-and a RAID5 over thte second half of all 5 devices. +- +-A container can be created with +- +- mdadm --create /dev/md0 -e ddf -n5 /dev/sd[abcde] +- +-or "-e imsm" to use the Intel Matrix Storage Manager. +- +-An array can be created within a container either by giving the +-container name and the only member: +- +- mdadm -C /dev/md1 --level raid1 -n 2 /dev/md0 +- +-or by listing the component devices +- +- mdadm -C /dev/md2 --level raid0 -n 3 /dev/sd[cde] +- +-To assemble a container, it is easiest just to pass each device in turn to +-mdadm -I +- +- for i in /dev/sd[abcde] +- do mdadm -I $i +- done +- +-This will assemble the container and the components. +- +-Alternately the container can be assembled explicitly +- +- mdadm -A /dev/md0 /dev/sd[abcde] +- +-Then the components can all be assembled with +- +- mdadm -I /dev/md0 +- +-For each container, mdadm will start a program called "mdmon" which will +-monitor the array and effect any metadata updates needed. The array is +-initially assembled readonly. It is up to "mdmon" to mark the metadata +-as 'dirty' and which the array to 'read-write'. +- +-The version 0.90 and 1.x metadata formats supported by previous +-versions for mdadm are still supported and the kernel still performs +-the same updates it use to. The new 'mdmon' approach is only used for +-newly introduced metadata types. +- +-NeilBrown 2nd June 2009 +diff --git a/ANNOUNCE-3.0.1 b/ANNOUNCE-3.0.1 +deleted file mode 100644 +index 91b44284..00000000 +--- a/ANNOUNCE-3.0.1 ++++ /dev/null +@@ -1,22 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.0.1 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.0.1 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +- +-This contains only minor bug fixes over 3.0. If you are using +-3.0, you could consider upgrading. +- +-The brief change log is: +- - Fix various segfaults +- - Fixed for --examine with containers +- - Lots of other little fixes. +- +-NeilBrown 25th September 2009 +diff --git a/ANNOUNCE-3.0.2 b/ANNOUNCE-3.0.2 +deleted file mode 100644 +index 93643d17..00000000 +--- a/ANNOUNCE-3.0.2 ++++ /dev/null +@@ -1,21 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.0.2 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.0.2 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +- +-This just contains one bugfix over 3.0.1 - I was obviously a bit hasty +-in releasing that one. +- +-The brief change log is: +- - Fix crash when hosthost is not set, as often happens in +- early boot. +- +-NeilBrown 25th September 2009 +diff --git a/ANNOUNCE-3.0.3 b/ANNOUNCE-3.0.3 +deleted file mode 100644 +index d6117a1d..00000000 +--- a/ANNOUNCE-3.0.3 ++++ /dev/null +@@ -1,29 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.0.3 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.0.3 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +- +-This contains a collection of bug fixes and minor enhancements over +-3.0.1. +- +-The brief change log is: +- - Improvements for creating arrays giving just a name, like 'foo', +- rather than the full '/dev/md/foo'. +- - Improvements for assembling member arrays of containers. +- - Improvements to test suite +- - Add option to change increment for RebuildNN messages reported +- by "mdadm --monitor" +- - Improvements to mdmon 'hand-over' from initrd to final root. +- - Handle merging of devices that have left an IMSM array and are +- being re-incorporated. +- - Add missing space in "--detail --brief" output. +- +-NeilBrown 22nd October 2009 +diff --git a/ANNOUNCE-3.1 b/ANNOUNCE-3.1 +deleted file mode 100644 +index 343b85da..00000000 +--- a/ANNOUNCE-3.1 ++++ /dev/null +@@ -1,33 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.1 - A tool for managing Soft RAID under Linux +- +-Hot on the heals of 3.0.3 I am pleased to announce the availability of +- mdadm version 3.1 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +- +-It contains significant feature enhancements over 3.0.x +- +-The brief change log is: +- - Support --grow to change the layout of RAID4/5/6 +- - Support --grow to change the chunksize of raid 4/5/6 +- - Support --grow to change level from RAID1 -> RAID5 -> RAID6 and +- back. +- - Support --grow to reduce the number of devices in RAID4/5/6. +- - Support restart of these grow options which assembling an array +- which is partially grown. +- - Assorted tests of this code, and of different RAID6 layouts. +- +-Note that a 2.6.31 or later is needed to have access to these. +-Reducing devices in a RAID4/5/6 requires 2.6.32. +-Changing RAID5 to RAID1 requires 2.6.33. +- +-You should only upgrade if you need to use, or which to test, these +-features. +- +-NeilBrown 22nd October 2009 +diff --git a/ANNOUNCE-3.1.1 b/ANNOUNCE-3.1.1 +deleted file mode 100644 +index 9e480dc0..00000000 +--- a/ANNOUNCE-3.1.1 ++++ /dev/null +@@ -1,39 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.1.1 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.1.1 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +-This is a bugfix release over 3.1, which was withdrawn due to serious +-bugs. So it might be best to ignore 3.1 and say that this is a significant +-feature release over 3.0.x +- +-Significant changes are: +- - RAID level conversion between RAID1, RAID5, and RAID6 are +- possible were the kernel supports it (2.6.32 at least) +- - online chunksize and layout changing for RAID5 and RAID6 +- where the kernel supports it. +- - reduce the number of devices in a RAID4/5/6 array. +- +- - The default metadata is not v1.1. This metadata is stored at the +- start of the device so is safer in many ways but could interfere with +- boot loaded. The old default (0.90) is still available and fully +- supported. +- +- - The default chunksize is now 512K rather than 64K. This seems more +- appropriate for modern devices. +- +- - The default bitmap chunksize for internal bitmaps is now at least +- 64Meg as fine grained bitmaps tend to impact performance more for +- little extra gain. +- +-This release is believed to be stable and you should feel free to +-upgrade to 3.1.1. +- +-NeilBrown 19th November 2009 +diff --git a/ANNOUNCE-3.1.2 b/ANNOUNCE-3.1.2 +deleted file mode 100644 +index 321b8bef..00000000 +--- a/ANNOUNCE-3.1.2 ++++ /dev/null +@@ -1,46 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.1.2 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.1.2 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +-This is a bugfix/stability release over 3.1.1. +- +-Significant changes are: +- - The default metadata has change again (sorry about that). +- It is now v1.2 and will hopefully stay that way. It turned +- out there with boot-block issues with v1.1 which make it +- unsuitable for a default, though in many cases it is still +- suitable to use. +- - Stopping a container is not permitted when members are still +- active +- - Add 'homehost' to the valid words for the "AUTO" config file +- line. When followed by "-all", this causes mdadm to +- auto-assemble any array belonging to this host, but not +- auto-assemble anything else. +- - Fix some bugs with "--grow --chunksize=" for changing chunksize. +- - VAR_RUN can be easily changed at compile time just like ALT_RUN. +- This gives distros more flexability in how to manage the +- pid and sock files that mdmon needs. +- - Various mdmon fixes +- - Alway make bitmap 4K-aligned if at all possible. +- - If mdadm.conf lists arrays which have inter-dependencies, +- the previously had to be listed in the "right" order. Now +- any order should work. +- - Fix --force assembly of v1.x arrays which are in the process +- of recovering. +- - Add section on 'scrubbing' to 'md' man page. +- - Various command-line-option parsing improvements. +- - ... and lots of other bug fixes. +- +- +-This release is believed to be stable and you should feel free to +-upgrade to 3.1.2 +- +-NeilBrown 10th March 2010 +diff --git a/ANNOUNCE-3.1.3 b/ANNOUNCE-3.1.3 +deleted file mode 100644 +index 95b2b6c1..00000000 +--- a/ANNOUNCE-3.1.3 ++++ /dev/null +@@ -1,46 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.1.3 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.1.3 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +-This is a bugfix/stability release over 3.1.2 +- +-Significant changes are: +- - mapfile now lives in a fixed location which default to +- /dev/.mdadm/map but can be changed at compile time. This +- location is choses and most distros provide it during early +- boot and preserve it through. As long a /dev exists and is +- writable, /dev/.mdadm will be created. +- Other files file communication with mdmon live here too. +- This fixes a bug reported by Debian and Gentoo users where +- udev would spin in early-boot. +- - IMSM and DDF metadata will not be recognised on partitions +- as they should only be used on whole-disks. +- - Various overflows causes by 2G drives have been addressed. +- - A subarray of an IMSM contain can now be killed with +- --kill-subarray. Also subarrays can be renamed with +- --update-subarray +- - -If (or --incremental --fail) can be used from udev to +- fail and remove from all arrays a device which has been +- unplugged from the system. i.e. hot-unplug-support. +- - "mdadm /dev/mdX --re-add missing" will look for any device +- that looks like it should be a member of /dev/mdX but isn't +- and will automatically --re-add it +- - Now compile with -Wextra to get extra warnings. +- - Lots of minor bug fixes, documentation improvements, etcc +- +-This release is believed to be stable and you should feel free to +-upgrade to 3.1.3 +- +-It is expected that the next release will be 3.2 with a number of new +-features. 3.1.4 will only happen if important bugs show up before 3.2 +-is stable. +- +-NeilBrown 6th August 2010 +diff --git a/ANNOUNCE-3.1.4 b/ANNOUNCE-3.1.4 +deleted file mode 100644 +index c157a36a..00000000 +--- a/ANNOUNCE-3.1.4 ++++ /dev/null +@@ -1,37 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.1.4 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.1.4 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +-This is a bugfix/stability release over 3.1.3. +-3.1.3 had a couple of embarrasing regressions and a couple of other +-issues surfaces which had easy fixes so I decided to make a 3.1.4 +-release after all. +- +-Two fixes related to configs that aren't using udev: +- - Don't remove md devices which 'standard' names on --stop +- - Allow dev_open to work on read-only /dev +-And fixed regressions: +- - Allow --incremental to add spares to an array +- - Accept --no-degraded as a deprecated option rather than +- throwing an error +- - Return correct success status when --incrmental assembling +- a container which does not yet have enough devices. +- - Don't link mdadm with pthreads, only mdmon needs it. +- - Fix compiler warning due to bad use of snprintf +- - Fix spare migration +- +-This release is believed to be stable and you should feel free to +-upgrade to 3.1.4 +- +-It is expected that the next release will be 3.2 with a number of new +-features. +- +-NeilBrown 31st August 2010 +diff --git a/ANNOUNCE-3.1.5 b/ANNOUNCE-3.1.5 +deleted file mode 100644 +index baa1f921..00000000 +--- a/ANNOUNCE-3.1.5 ++++ /dev/null +@@ -1,42 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.1.5 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.1.5 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git?p=mdadm +- +-This is a bugfix/stability release over 3.1.4. It contains all the +-important bugfixes found while working on 3.2 and 3.2.1. It will be +-the last 3.1.x release - 3.2.1 is expected to be released in a few days. +- +-Changes include: +- - Fixes for v1.x metadata on big-endian machines. +- - man page improvements +- - Improve '--detail --export' when run on partitions of an md array. +- - Fix regression with removing 'failed' or 'detached' devices. +- - Fixes for "--assemble --force" in various unusual cases. +- - Allow '-Y' to mean --export. This was documented but not implemented. +- - Various fixed for handling 'ddf' metadata. This is now more reliable +- but could benefit from more interoperability testing. +- - Correctly list subarrays of a container in "--detail" output. +- - Improve checks on whether the requested number of devices is supported +- by the metadata - both for --create and --grow. +- - Don't remove partitions from a device that is being included in an +- array until we are fully committed to including it. +- - Allow "--assemble --update=no-bitmap" so an array with a corrupt +- bitmap can still be assembled. +- - Don't allow --add to succeed if it looks like a "--re-add" is probably +- wanted, but cannot succeed. This avoids inadvertently turning +- devices into spares when an array is failed. +- +-This release is believed to be stable and you should feel free to +-upgrade to 3.1.5 +- +- +-NeilBrown 23rd March 2011 +- +diff --git a/ANNOUNCE-3.2 b/ANNOUNCE-3.2 +deleted file mode 100644 +index 9e282bc6..00000000 +--- a/ANNOUNCE-3.2 ++++ /dev/null +@@ -1,77 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.2 - A tool for managing Soft RAID under Linux (DEVEL ONLY) +- +-I am pleased to announce the availability of +- mdadm version 3.2 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm devel-3.2 +- http://neil.brown.name/git?p=mdadm +- +-This is a "Developers only" release. Please don't consider using it +-or making it available to others without reading the following. +- +- +-By far the most significant change in this release related to the +-management of reshaping arrays. This code has been substantially +-re-written so that it can work with 'externally managed metadata' - +-Intel's IMSM in particular. We now support level migration and +-OnLine Capacity Expansion on these arrays. +- +-However, while the code largely works it has not been tested +-exhaustively so there are likely to be problems. As the reshape code +-for native metadata arrays was changed as part of this rewrite these +-problems could also result in regressions for reshape of native +-metadata. +- +-It is partly to encourage greater testing that this release is being +-made. Any reports of problem - particular reproducible recipes for +-triggering the problems - will be gratefully received. +- +-It is hopped that a "3.2.1" release will be available in early March +-which will be a bugfix release over this and can be considered +-suitable for general use. +- +-Other changes of note: +- +- - Policy framework. +- Various policy statements can be made in the mdadm.conf to guide +- the behaviour of mdadm, particular with regards to how new devices +- are treated by "mdadm -I". +- Depending on the 'action' associated with a device (identified by +- its 'path') such need devices can be automatically re-added to and +- existing array that they previously fell out off, or automatically +- added as a spare if they appear to contain no data. +- +- - mdadm now has a limited understanding of partition tables. This +- allows the policy framework to make decisions about partitioned +- devices as well. +- +- - --incremental --remove can be told what --path the device was on, +- and this info will be recorded so that another device appearing at +- the same physical location can be preferentially added to the same +- array (provides the spare-same-slot action policy applied to the +- path). +- +- - A new flags "--invalid-backup" flag is available in --assemble +- mode. This can be used to re-assemble an array which was stopping +- in the middle of a reshape, and for which the 'backup file' is no +- longer available or is corrupted. The array may have some +- corruption in it at the point where reshape was up to, but at least +- the rest of the array will become available. +- +- +- - Various internal restructuring - more is needed. +- +- +-Any feed back and bug reports are always welcomed at: +- linux-raid@vger.kernel.org +- +-And please: don't use this in production - particularly not the +---grow functionality. +- +-NeilBrown 1st February 2011 +- +- +diff --git a/ANNOUNCE-3.2.1 b/ANNOUNCE-3.2.1 +deleted file mode 100644 +index 0e7826ca..00000000 +--- a/ANNOUNCE-3.2.1 ++++ /dev/null +@@ -1,75 +0,0 @@ +- +- +-I am pleased to announce the availability of +- mdadm version 3.2.1 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git/mdadm +- +-Many of the changes in this release are of internal interest only, +-restructuring and refactoring code and so forth. +- +-Most of the bugs found and fixed during development for 3.2.1 have been +-back-ported for the recently-release 3.1.5 so this release primarily +-provides a few new features over 3.1.5. +- +-They include: +- - policy framework +- Policy can be expressed for moving spare devices between arrays, and +- for how to handle hot-plugged devices. This policy can be different +- for devices plugged in to different controllers etc. +- This, for example, allows a configuration where when a device is plugged +- in it is immediately included in an md array as a hot spare and +- possibly starts recovery immediately if an array is degraded. +- +- - some understanding of mbr and gpt paritition tables +- This is primarly to support the new hot-plug support. If a +- device is plugged in and policy suggests it should have a partition table, +- the partition table will be copied from a suitably similar device, and +- then the partitions will hot-plug and can then be added to md arrays. +- +- - "--incremental --remove" can remember where a device was removed from +- so if a device gets plugged back in the same place, special policy applies +- to it, allowing it to be included in an array even if a general hotplug +- will not be included. +- +- - enhanced reshape options, including growing a RAID0 by converting to RAID4, +- restriping, and converting back. Also convertions between RAID0 and +- RAID10 and between RAID1 and RAID10 are possible (with a suitably recent +- kernel). +- +- - spare migration for IMSM arrays. +- Spare migration can now work across 'containers' using non-native metadata +- and specifically Intel's IMSM arrays support spare migrations. +- +- - OLCE and level migration for Intel IMSM arrays. +- OnLine Capacity Expansion and level migration (e.g. RAID0 -> RAID5) is +- supported for Intel Matrix Storage Manager arrays. +- This support is currently 'experimental' for technical reasons. It can +- be enabled with "export MDADM_EXPERIMENTAL=1" +- +- - avoid including wayward devices +- If you split a RAID1, mount the two halves as two separate degraded RAID1s, +- and then later bring the two back together, it is possible that the md +- metadata won't properly show that one must over-ride the other. +- mdadm now does extra checking to detect this possibilty and avoid +- potentially corrupting data. +- +- - remove any possible confusion between similar options. +- e.g. --brief and --bitmap were mapped to 'b' and mdadm wouldn't +- notice if one was used where the other was expected. +- +- - allow K,M,G suffixes on chunk sizes +- +- +-While mdadm-3.2.1 is considered to be reasonably stable, you should +-only use it if you want to try out the new features, or if you +-generally like to be on the bleeding edge. If the new features are not +-important to you, then 3.1.5 is probably the appropriate version to be using +-until 3.2.2 comes out. +- +-NeilBrown 28th March 2011 +diff --git a/ANNOUNCE-3.2.2 b/ANNOUNCE-3.2.2 +deleted file mode 100644 +index b70d18b9..00000000 +--- a/ANNOUNCE-3.2.2 ++++ /dev/null +@@ -1,36 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.2.2 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.2.2 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git/mdadm +- +-This release is largely a stablising release for the 3.2 series. +-Many of the changes just fix bugs introduces in 3.2 or 3.2.1. +- +-There are some new features. They are: +- - reshaping IMSM (Intel metadata) arrays is no longer 'experimental', +- it should work properly and be largely compatible with IMSM drivers in +- other platforms. +- - --assume-clean can be used with --grow --size to avoid resyncing the +- new part of the array. This is only support with very new kernels. +- - RAID0 arrays can have chunksize which is not a power of 2. This has been +- supported in the kernel for a while but is only now supprted by +- mdadm. +- +- - A new tool 'raid6check' is available which can check a RAID6 array, +- or part of it, and report which device is most inconsistent with the +- others if any stripe is inconsistent. This is still under development +- and does not have a man page yet. If anyone tries it out and has any +- questions or experience to report, they would be most welcome on +- linux-raid@vger.kernel.org. +- +-Future releases in the 3.2 series will only be made if bugfixes are needed. +-The next release to add features is expected to be 3.3. +- +-NeilBrown 17th June 2011 +diff --git a/ANNOUNCE-3.2.3 b/ANNOUNCE-3.2.3 +deleted file mode 100644 +index 8a8dba46..00000000 +--- a/ANNOUNCE-3.2.3 ++++ /dev/null +@@ -1,24 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.2.3 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.2.3 +- +-It is available at the usual places: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://neil.brown.name/mdadm +- http://neil.brown.name/git/mdadm +- +-This release is largely a bugfix release for the 3.2 series with many +-minor fixes with little or no impact. +- +-The largest single area of change is support for reshape of Intel +-IMSM arrays (OnLine Capacity Explansion and Level Migtration). +-Among other fixes, this now has a better chance of surviving if a +-device fails during reshape. +- +-Upgrading is recommended - particularly if you use mdadm for IMSM +-arrays - but not essential. +- +-NeilBrown 23rd December 2011 +diff --git a/ANNOUNCE-3.2.4 b/ANNOUNCE-3.2.4 +deleted file mode 100644 +index e3216786..00000000 +--- a/ANNOUNCE-3.2.4 ++++ /dev/null +@@ -1,144 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.2.4 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.2.4 +- +-It is available at the usual places, now including github: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://neil.brown.name/git/mdadm +- +-This release is largely a bugfix release for the 3.2 series with many +-minor fixes with little or no impact. +- +-"--oneline" log of changes is below. Some notable ones are: +- +- - --offroot argument to improve interactions between mdmon and initrd +- - --prefer argument to select which /dev names to display in some +- circumstances. +- - relax restructions on when "--add" will be allowed +- - Fix bug with adding write-intent-bitmap to active array +- - Now defaults to "/run/mdadm" for storing run-time files. +- +-Upgrading is encouraged. +- +-The next mdadm release is expected to be 3.3 with a number of new +-features. +- +-NeilBrown 9th May 2012 +- +-77b3ac8 monitor: make return from read_and_act more symbolic. +-68226a8 monitor: ensure we retry soon when 'remove' fails. +-8453f8d fix: Monitor sometimes crashes +-90fa1a2 Work around gcc-4.7's strict aliasing checks +-0c4304c fix: container creation with --incremental used. +-5d1c7cd FIX: External metadata sometimes is not updated +-3c20f98 FIX: mdmon check in reshape_container() can cause a problem +-59ab9f5 FIX: Typo error in fprint command +-9587c37 imsm: load_super_imsm_all function refactoring +-ec50f7b imsm: load_imsm_super_all supports loading metadata from the device list +-ca9de18 imsm: validate the number of imsm volumes per controller +-30602f5 imsm: display fd in error trace when when store_imsm_mpb failes +-eb155f6 mdmon: Use getopt_long() to parse command line options +-08ca2ad Add --offroot argument to mdadm +-da82751 Add --offroot argument to mdmon +-a0963a8 Spawn mdmon with --offroot if mdadm was launched with --offroot +-f878b24 imsm: fix, the second array need to have the whole available space on devices +-d597705 getinfo_super1: Use MaxSector in place of sb->size +-6ef8905 super1: make aread/awrite always use an aligned buffer. +-de5a472 Remove avail_disks arg from 'enough'. +-da8fe5a Assemble: fix --force assemble during reshape. +-b10c663 config: fix handing of 'homehost' in AUTO line. +-92d49ec FIX: NULL pointer to strdup() can be passed +-d2bde6d imsm: FIX: No new missing disks are allowed during general migration +-111e9fd FIX: Array is not run when expansion disks are added +-bf5cf7c imsm: FIX: imsm_get_allowed_degradation() doesn't count degradation for raid1 +-50927b1 Fix: Sometimes mdmon throws core dump during reshape +-78340e2 Flush mdmon before next reshape step during container operation +-e174219 imsm: FIX: Chunk size migration problem +-f93346e FIX: use md position to reshape restart +-6a75c8c imsm: FIX: use md position to reshape restart +-51d83f5 imsm: FIX: Clear migration record when migration switches to next volume. +-e1dd332 FIX: restart reshape when reshape process is stopped just between 2 reshapes +-1ca90aa FIX: Do not try to (continue) reshape using inactive array +-9f1b0f0 config: conf_match should ignore devname when not set. +-d669228 Use posix_memalign() for memory used to write bitmaps +-178950e FIX: Changes in '0' case for reshape position verification +-9200d41 avoid double-free upon "old buggy kernel" sysfs_read failure +-4011421 Print error message if failing to write super for 1.x metadata +-0011874 Use MDMON_DIR for pid files created in Monitor.c +-56d1885 Assemble: don't use O_EXCL until we have checked device content. +-b720636 Assemble: support assembling of a RAID0 being reshaped. +-c69ffac Manage: allow --re-add to failed array. +-52f07f5 Reset bad flag on map update +-911cead super1: support superblocks up to 4K. +-ad6db3c Create: reduce the verbosity of 'default_layout'. +-b2bfdfa super1.c don't keep recalculating bitmap pointer +-4122675 Define and use SUPER1_SIZE for allocations +-1afa930 init_super1() memset full buffer allocated for superblock +-2de0b8a match_metadata_desc1(): Use calloc instead of malloc+memset +-3c0bcd4 Use 4K buffer alignment for superblock allocations +-308340a Use struct align_fd to cache fd's block size for aligned reads/writes +-65ed615 match_metadata_desc0(): Use calloc instead of malloc+memset +-de89706 Generalize ROUND_UP() macro and introduce matching ROUND_UP_PTR() +-0a2f189 super1.c: use ROUND_UP/ROUND_UP_PTR +-654a381 super-intel.c: Use ROUND_UP() instead of manually coding it +-42d5dfd __write_init_super_ddf(): Use posix_memalign() instead of static aligned buffer +-d4633e0 Examine: fix array size calculation for RAID10. +-e62b778 Assemble: improve verbose logging when including old devices. +-0073a6e Remove possible crash during RAID6 -> RAID5 reshape. +-69fe207 Incremental: fix adding devices with --incremental +-bcbb311 Manage: replace 'return 1' with 'goto abort'. +-9f58469 Manage: freeze recovery while adding multiple devices. +-ae6c05a Create: round off size for RAID1 arrays. +-5ca3a90 Grow: print useful error when converting RAID1->RAID5 will fail. +-c07d640 Fix tests/05r1-re-add-nosupper +-2d762ad Fix the new ROUND_UP macro. +-fd324b0 sysfs: fixed sysfs_freeze_array array to work properly with Manage_subdevs. +-5551b11 imsm: avoid overflows for disks over 1TB +-97f81ee clear hi bits if not used after loading metadata from disk +-e03640b simplify calculating array_blocks +-29cd082 show 2TB volumes/disks support in --detail-platform +-2cc699a check volume size in validate_geometry_imsm_orom +-9126b9a check that no disk over 2TB is used to create container when no support +-027c374 imsm: set 2tb disk attribute for spare +-3556c2f Fix typo: wan -> want +-15632a9 parse_size: distinguish between 0 and error. +-fbdef49 Bitmap_offset is a signed number +-508a7f1 super1: leave more space in front of data by default. +-40110b9 Fix two typos in fprintf messages +-342460c mdadm man page: fix typo +-0e7f69a imsm: display maximum volumes per controller and array +-36fd8cc imsm: FIX: Update function imsm_num_data_members() for Raid1/10 +-7abc987 imsm: FIX: Add volume size expand support to imsm_analyze_change() +-f3871fd imsm: Add new metadata update for volume size expansion +-54397ed imsm: Execute size change for external metatdata +-016e00f FIX: Support metadata changes rollback +-fbf3d20 imsm: FIX: Support metadata changes rollback +-44f6f18 FIX: Extend size of raid0 array +-7e7e9a4 FIX: Respect metadata size limitations +-65a9798 FIX: Detect error and rollback metadata +-13bcac9 imsm: Add function imsm_get_free_size() +-b130333 imsm: Support setting max size for size change operation +-c41e00b imsm: FIX: Component size alignment check +-58d26a2 FIX: Size change is possible as standalone change only +-4aecb54 FIX: Assembled second array is in read only state during reshape +-ae2416e FIX: resolve make everything compilation error +-480f356 Raid limit of 1024 when scanning for devices. +-c2ecf5f Add --prefer option for --detail and --monitor +-0a99975 Relax restrictions on when --add is permitted. +-7ce0570 imsm: fix: rebuild does not continue after reboot +-b51702b fix: correct extending size of raid0 array +-34a1395 Fix sign extension of bitmap_offset in super1.c +-012a864 Introduce sysfs_set_num_signed() and use it to set bitmap/offset +-5d7b407 imsm: fix: thunderdome may drop 2tb attribute +-5ffdc2d Update test for "is udev active". +-96fd06e Adjust to new standard of /run +-974e039 test: don't worry too much about array size. +-b0a658f Grow: failing the set the per-device size is not an error. +-36614e9 super-intel.c: Don't try to close negative fd +-562aa10 super-intel.c: Fix resource leak from opendir() +- +diff --git a/ANNOUNCE-3.2.5 b/ANNOUNCE-3.2.5 +deleted file mode 100644 +index 396da12a..00000000 +--- a/ANNOUNCE-3.2.5 ++++ /dev/null +@@ -1,31 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.2.5 - A tool for managing Soft RAID under Linux +- +-I am somewhat disappointed to have to announce the availability of +- mdadm version 3.2.5 +- +-It is available at the usual places, now including github: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://neil.brown.name/git/mdadm +- +-This release primarily fixes a serious regression in 3.2.4. +-This regression does *not* cause any risk to data. It simply +-means that adding a device with "--add" would sometime fail +-when it should not. +- +-The fix also includes a couple of minor fixes such as making +-the "--layout=preserve" option to "--grow" work again. +- +-A reminder that the default location for runtime files is now +-"/run/mdadm". If you compile this for a distro that does not +-have "/run", you will need to compile with an alternate setting for +-MAP_DIR. e.g. +- make MAP_DIR=/var/run/mdadm +-or +- make MAP_DIR=/dev/.mdadm +- +-NeilBrown 18th May 2012 +- +diff --git a/ANNOUNCE-3.2.6 b/ANNOUNCE-3.2.6 +deleted file mode 100644 +index f5cfd492..00000000 +--- a/ANNOUNCE-3.2.6 ++++ /dev/null +@@ -1,57 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.2.6 - A tool for managing Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.2.6 +- +-It is available at the usual places, now including github: +- countrycode=xx. +- http://www.${countrycode}kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://neil.brown.name/git/mdadm +- +-This is a stablity release which adds a number of bugfixs to 3.2.5. +-There are no real stand-out fixes, just lots of little bits and pieces. +- +-Below is the "git log --oneline --reverse" list of changes since +-3.2.5. +- +-NeilBrown 25th October 2012 +- +-b7e05d2 udev-rules: prevent systemd from mount devices before they are ready. +-0d478e2 mdadm: Fix Segmentation fault. +-42f0ca1 imsm: fix: correct checking volume's degradation +-fcf2195 Monitor: fix inconsistencies in values for ->percent +-5f862fb Monitor: Report NewArray when an array the disappeared, reappears. +-6f51b1c Monitor: fix reporting for Fail vs FailSpare etc. +-68ad53b mdmon: fix arg parsing. +-517f135 Assemble: don't leak memory with fdlist. +-090900c udev-rules: prevent systemd from mount devices before they are ready. +-446e000 sha1.h: remove ansidecl.h header inclusion +-ec894f5 Manage: zero metadata before adding to 'external' array. +-3a84db5 ddf: allow a non-spare to be used to recovery a missing device. +-c5d61ca ddf: hack to fix container recognition. +-23084aa mdmon: fix arg processing for -a +-c4e96a3 mdmon: allow --takeover when original was started with --offroot +-80841df find_free_devnum: avoid auto-using names in /etc/mdadm.conf +-c5c56d6 mapfile: fix mapfile rebuild for containers +-aec89f6 fix segfaults in Detail() +-2117ad1 Fix 'enough' function for RAID10. +-0bc300d Use --offroot flag when assembling md arrays via --incrmental +-ac78f24 Grow: make warning about old metadata more explicit. +-14026ab Replace sha1.h with slightly older version. +-6f6809f Add zlib license to crc32.c +-5267ba0 Handles spaces in array names better. +-c51f288 imsm: allow --assume-clean to work. +-acf7076 Grow: allow --grow --continue to work for native metadata. +-335d2a6 Grow: fix a couple of typos with --assume-clean usage +-9ff1427 Fix open_container +-3713633 mdadm: super0: do not override uuid with homehost +-31bff58 Trivial bugfix and spelling fixes. +-e1e539f Detail: don't report a faulty device as 'spare' or 'rebuilding'. +-22a6461 super0: allow creation of array on 2TB+ devices. +-a5d47a2 Create new md devices consistently +-eb48676 Monitor: don't complain about non-monitorable arrays in mdadm.conf +-ecdf2d7 Query: don't be confused by partition tables. +-f7b75c1 Query: allow member of non-0.90 arrays to be better reported. +diff --git a/ANNOUNCE-3.3 b/ANNOUNCE-3.3 +deleted file mode 100644 +index f770aa13..00000000 +--- a/ANNOUNCE-3.3 ++++ /dev/null +@@ -1,63 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.3 - A tools for managing md Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.3 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://git.neil.brown.name/git/mdadm +- +-This is a major new release so don't be too surprised if there are a +-few issues. If I hear about them they will be fixed in 3.3.1. +-git log reports nearly 500 changes since 3.2.6 so I won't list them +-all. +- +-Some highlights are: +- +-- Some array reshapes can proceed without needing backup file. +- This is done by changing the 'data_offset' so we never need to write +- any data back over where it was before. If there is no "head space" +- or "tail space" to allow data_offset to change, the old mechanism +- with a backup file can still be used. +-- RAID10 arrays can be reshaped to change the number of devices, +- change the chunk size, or change the layout between 'near' +- and 'offset'. +- This will always change data_offset, and will fail if there is no +- room for data_offset to be moved. +-- "--assemble --update=metadata" can convert a 0.90 array to a 1.0 array. +-- bad-block-logs are supported (but not heavily tested yet) +-- "--assemble --update=revert-reshape" can be used to undo a reshape +- that has just been started but isn't really wanted. This is very +- new and while it passes basic tests it cannot be guaranteed. +-- improved locking between --incremental and --assemble +-- uses systemd to run "mdmon" if systemd is configured to do that. +-- kernel names of md devices can be non-numeric. e.g. "md_home" rather than +- "md0". This will probably confuse lots of other tools, so you need to +- echo CREATE names=yes >> /etc/mdadm.conf +- or the feature will not be used. (you also need a reasonably new kernel). +-- "--stop" can be given a kernel name instead of a device name. i.e +- mdadm --stop md4 +- will work even if /dev/md4 doesn't exist. +-- "--detail --export" has some information about the devices in the array +-- --dump and --restore can be used to backup and restore the metadata on an +- array. +-- Hot-replace is supported with +- mdadm /dev/mdX --replace /dev/foo +- and +- mdadm /dev/mdX --replace /dev/foo --with /dev/bar +-- Config file can be a directory in which case all "*.conf" files are +- read in lexical order. +- Default is to read /etc/mdadm.conf and then /etc/mdadm.conf.d +- Thus +- echo CREATE name=yes > /etc/mdadm.conf.d/names.conf +- will also enable the use of named md devices. +- +-- Lots of improvements to DDF support including adding support for +- RAID10 (thanks Martin Wilck). +- +-and lots of bugfixes and other little changes. +- +-NeilBrown 3rd September 2013 +diff --git a/ANNOUNCE-3.3.1 b/ANNOUNCE-3.3.1 +deleted file mode 100644 +index 7d5e666e..00000000 +--- a/ANNOUNCE-3.3.1 ++++ /dev/null +@@ -1,23 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.3.1 - A tool for managing md Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.3.1 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://git.neil.brown.name/git/mdadm.git +- +-The main changes are: +- - lots of work on "DDF" support. Hopefully it will be more stable +- now. Bug reports are always welcome. +- - improved interactions with 'systemd'. Where possible, background +- tasks are run from systemd (if it is present) rather then forking +- disassociationg from the session. This is important because udev +- doesn't really let you disassociate. +- +-though there are a number of other little bug fixes too. +- +-NeilBrown 5th June 2014 +diff --git a/ANNOUNCE-3.3.2 b/ANNOUNCE-3.3.2 +deleted file mode 100644 +index 6b549611..00000000 +--- a/ANNOUNCE-3.3.2 ++++ /dev/null +@@ -1,16 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.3.2 - A tool for managing md Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.3.2 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://git.neil.brown.name/git/mdadm.git +- +-Changes since 3.3.1 are mostly little bugfixes and some man-page +-updates. +- +-NeilBrown 21st August 2014 +diff --git a/ANNOUNCE-3.3.3 b/ANNOUNCE-3.3.3 +deleted file mode 100644 +index ac1b2173..00000000 +--- a/ANNOUNCE-3.3.3 ++++ /dev/null +@@ -1,18 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.3.3 - A tool for managing md Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.3.3 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://git.neil.brown.name/git/mdadm.git +- +-The 100 changes since 3.3.3 are mostly little bugfixes and some improvements +-to the selftests. +-raid6check now handle all RAID6 layouts including DDF correctly. +-See git log for the rest. +- +-NeilBrown 24th July 2015 +diff --git a/ANNOUNCE-3.3.4 b/ANNOUNCE-3.3.4 +deleted file mode 100644 +index 52b94562..00000000 +--- a/ANNOUNCE-3.3.4 ++++ /dev/null +@@ -1,37 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.3.4 - A tool for managing md Soft RAID under Linux +- +-I am somewhat disappointed to have to announce the availability of +- mdadm version 3.3.4 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://git.neil.brown.name/git/mdadm.git +- +-In mdadm-3.3 a change was made to how IMSM (Intel Matrix Storage +-Manager) metadata was handled. Previously an IMSM array would only +-be assembled if it was attached to an IMSM controller. +- +-In 3.3 this was relaxed as there are circumstances where the +-controller is not properly detected. Unfortunately this has negative +-consequences which have only just come to light. +- +-If you have an IMSM RAID1 configured and then disable RAID in the +-BIOS, the metadata will remain on the devices. If you then install +-some other OS on one device and then install Linux on the other, Linux +-might eventually start noticing the IMSM metadata (depending a bit on whether +-mdadm is included in the initramfs) and might start up the RAID1. This could +-copy one device over the other, thus trashing one of the installations. +- +-Not good. +- +-So with this release IMSM arrays will only be assembled if attached to +-an IMSM controller, or if "--force" is given to --assemble, or if the +-environment variable IMSM_NO_PLATFORM is set (used primarily for +-testing). +- +-I strongly recommend upgrading to 3.3.4 if you are using 3.3 or later. +- +-NeilBrown 3rd August 2015. +diff --git a/ANNOUNCE-3.4 b/ANNOUNCE-3.4 +deleted file mode 100644 +index 2689732d..00000000 +--- a/ANNOUNCE-3.4 ++++ /dev/null +@@ -1,24 +0,0 @@ +-Subject: ANNOUNCE: mdadm 3.4 - A tool for managing md Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 3.4 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://github.com/neilbrown/mdadm +- git://neil.brown.name/mdadm +- http://git.neil.brown.name/git/mdadm +- +-The new second-level version number reflects significant new +-functionality, particular support for journalled RAID5/6 and clustered +-RAID1. This new support is probably still buggy. Please report bugs. +- +-There are also a number of fixes for Intel's IMSM metadata support, +-and an assortment of minor bug fixes. +- +-I plan for this to be the last release of mdadm that I provide as I am +-retiring from MD and mdadm maintenance. Jes Sorensen has volunteered +-to oversee mdadm for the next while. Thanks Jes! +- +-NeilBrown 28th January 2016 +diff --git a/ANNOUNCE-4.0 b/ANNOUNCE-4.0 +deleted file mode 100644 +index f79c5408..00000000 +--- a/ANNOUNCE-4.0 ++++ /dev/null +@@ -1,22 +0,0 @@ +-Subject: ANNOUNCE: mdadm 4.0 - A tool for managing md Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 4.0 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://git.kernel.org/pub/scm/utils/mdadm/mdadm.git +- http://git.kernel.org/cgit/utils/mdadm/ +- +-The update in major version number primarily indicates this is a +-release by it's new maintainer. In addition it contains a large number +-of fixes in particular for IMSM RAID and clustered RAID support. In +-addition this release includes support for IMSM 4k sector drives, +-failfast and better documentation for journaled RAID. +- +-This is my first release of mdadm. Please thank Neil Brown for his +-previous work as maintainer and blame me for all the bugs I caused +-since taking over. +- +-Jes Sorensen, 2017-01-09 +diff --git a/ANNOUNCE-4.1 b/ANNOUNCE-4.1 +deleted file mode 100644 +index a273b9a0..00000000 +--- a/ANNOUNCE-4.1 ++++ /dev/null +@@ -1,16 +0,0 @@ +-Subject: ANNOUNCE: mdadm 4.1 - A tool for managing md Soft RAID under Linux +- +-I am pleased to announce the availability of +- mdadm version 4.1 +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://git.kernel.org/pub/scm/utils/mdadm/mdadm.git +- http://git.kernel.org/cgit/utils/mdadm/ +- +-The update constitutes more than one year of enhancements and bug fixes +-including for IMSM RAID, Partial Parity Log, clustered RAID support, +-improved testing, and gcc-8 support. +- +-Jes Sorensen, 2018-10-01 +diff --git a/ANNOUNCE-4.2 b/ANNOUNCE-4.2 +deleted file mode 100644 +index 8b22d09f..00000000 +--- a/ANNOUNCE-4.2 ++++ /dev/null +@@ -1,19 +0,0 @@ +-Subject: ANNOUNCE: mdadm 4.2 - A tool for managing md Soft RAID under Linux +- +-I am pleased to finally announce the availability of mdadm-4.2. +-get 4.2 out the door soon. +- +-It is available at the usual places: +- http://www.kernel.org/pub/linux/utils/raid/mdadm/ +-and via git at +- git://git.kernel.org/pub/scm/utils/mdadm/mdadm.git +- http://git.kernel.org/cgit/utils/mdadm/ +- +-The release includes more than two years of development and bugfixes, +-so it is difficult to remember everything. Highlights include +-enhancements and bug fixes including for IMSM RAID, Partial Parity +-Log, clustered RAID support, improved testing, and gcc-9 support. +- +-Thank you everyone who contributed to this release! +- +-Jes Sorensen, 2021-12-30 +diff --git a/CHANGELOG.md b/CHANGELOG.md +new file mode 100644 +index 00000000..c1997ba7 +--- /dev/null ++++ b/CHANGELOG.md +@@ -0,0 +1,368 @@ ++# Release [mdadm-4.3](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-4.3) ++ ++Features: ++- **IMSM_NO_PLATFORM** boot parameter support from Neil Brown. ++- **--write-zeros** option support by Logan Gunthorpe. ++- **IMSM** monetization by VMD register from Mateusz Grzonka. ++- RST SATA under VMD support from Kevin Friedberg. ++- Strong name rules from Mariusz Tkaczyk. ++ ++Fixes: ++- Unify failed raid behavior from Coly Li. ++- Rework of **--update** options from Mateusz Kusiak. ++- **mdmon-initrd** service from Neil Brown. ++- **IMSM** expand functionality rework from Mariusz Tkaczyk. ++- Mdmonitor improvements from Mateusz Grzonka. ++- Failed state verification from Mateusz Kusiak and Kinga Tanska. ++ ++# Release [mdadm-4.2](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-4.2) ++ ++The release includes more than two years of development and bugfixes, so it is difficult to ++remember everything. Highlights include enhancements and bug fixes including for **IMSM** RAID, ++Partial Parity Log, clustered RAID support, improved testing, and gcc-9 support. ++ ++# Release [mdadm-4.1](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-4.1) ++ ++The update constitutes more than one year of enhancements and bug fixes including for **IMSM** ++RAID, Partial Parity Log, clustered RAID support, improved testing, and gcc-8 support. ++ ++# Release [mdadm-4.0](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-4.0) ++ ++The update in major version number primarily indicates this is a release by it's new maintainer. ++In addition it contains a large number of fixes in particular for IMSM RAID and clustered RAID ++support. In addition, this release includes support for IMSM 4k sector drives, failfast and better ++documentation for journaled RAID. ++ ++This is my first release of mdadm. Please thank Neil Brown for his previous work as maintainer and ++blame me for all the bugs I caused since taking over. ++ ++# Release [mdadm-3.4](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.4) ++ ++- Support for journalled RAID5/6 and clustered RAID1. This new support is probably still buggy. ++ Please report bugs. ++ ++- There are also a number of fixes for **IMSM** support and an assortment of minor bug fixes. ++ ++- I plan for this to be the last release of mdadm that I provide as I am retiring from MD and mdadm ++ maintenance. Jes Sorensen has volunteered to oversee mdadm for the next while. Thanks Jes! ++ ++# Release [mdadm-3.3.4](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.3.4) ++ ++**I strongly recommend upgrading to 3.3.4 if you are using 3.3 or later with IMSM.** ++ ++- **IMSM** metadata assemble fixes. ++ ++ In mdadm-3.3 a change was made to how **IMSM** metadata was handled. Previously an **IMSM** array ++ would only be assembled if it was attached to an **IMSM** controller. In 3.3 this was relaxed as ++ there are circumstances where the controller is not properly detected. Unfortunately, this has ++ negative consequences which have only just come to light. ++ ++ If you have an IMSM RAID1 configured and then disable RAID in the BIOS, the metadata will remain ++ on the devices. If you then install some other OS on one device and then install Linux on the ++ other, Linux might eventually start noticing the IMSM metadata (depending a bit on whether ++ mdadm is included in the initramfs) and might start up the RAID1. This could copy one device over ++ the other, thus trashing one of the installations. ++ ++ So, with this release IMSM arrays will only be assembled if attached to an **IMSM** controller, ++ or if **--force** is given to **--assemble**, or if the environment variable ++ **IMSM_NO_PLATFORM=1** is set (used primarily for testing). ++ ++# Release [mdadm-3.3.3](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.3.3) ++ ++- The 100 changes since 3.3.3 are mostly little bugfixes and some improvements to the self-tests. ++- raid6check now handle all RAID6 layouts including **DDF** correctly. See git log for the rest. ++ ++# Release [mdadm-3.3.2](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.3.2) ++ ++- Little bugfixes and some man-page updates. ++ ++# Release [mdadm-3.3.1](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.3.1) ++ ++- lots of work on **DDF** support. ++- Improved interactions with **systemd**. Where possible, background tasks are run from systemd ++ rather than forking. ++- Number of other little bug fixes too. ++ ++# Release [mdadm-3.3](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.3) ++ ++- Some array reshapes can proceed without needing backup file. This is done by changing the ++ data_offset* so we never need to write any data back over where it was before. If there is no ++ 'head space' or 'tail space' to allow *data_offset* to change, the old mechanism with a backup ++ file can still be used. ++ ++- RAID10 arrays can be reshaped to change the number of devices, change the chunk size, or change ++ the layout between *near* and *offset*. ++ This will always change *data_offset*, and will fail if there is no room for *data_offset* to be ++ moved. ++ ++- **--assemble --update=metadata** can convert a **0.90** array to a **1.0** array. ++ ++- **bad-block-logs** are supported (but not heavily tested yet). ++ ++- **--assemble --update=revert-reshape** can be used to undo a reshape that has just been started ++ but isn't really wanted. This is very new and while it passes basic tests it cannot be ++ guaranteed. ++ ++- improved locking between **--incremental** and **--assemble**. ++ ++- uses systemd to run **mdmon** if systemd is configured to do that. ++- kernel names of md devices can be non-numeric. e.g. "md_home" rather than ++ "md0". This will probably confuse lots of other tools, so you need to ++ **echo CREATE names=yes >> /etc/mdadm.conf** or the feature will not be used (you also need a ++ reasonably new kernel). ++ ++- **--stop** can be given a kernel name instead of a device name. i.e. **mdadm --stop md4** will ++ work even if /dev/md4 doesn't exist. ++ ++- **--detail --export** has some information about the devices in the array. ++- **--dump** and **--restore** can be used to backup and restore the metadata on an array. ++- Hot-replace is supported with **mdadm /dev/mdX --replace /dev/foo** and ++ **mdadm /dev/mdX --replace /dev/foo --with /dev/bar**. ++ ++- Config file can be a directory in which case all "*.conf" files are read in lexical order. ++ Default is to read **/etc/mdadm.conf** and then **/etc/mdadm.conf.d**. Thus ++ **echo CREATE name=yes > /etc/mdadm.conf.d/names.conf** will also enable the use of named md ++ devices. ++ ++- Lots of improvements to **DDF** support including adding support for RAID10 (thanks Martin Wilck). ++ ++# Release [mdadm-3.2.6](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.2.6) ++ ++- There are no real stand-out fixes, just lots of little bits and pieces. ++ ++# Release [mdadm-3.2.5](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.2.5) ++ ++- This release primarily fixes a serious regression in 3.2.4. This regression does *not* cause ++ any risk to data. It simply means that adding a device with **--add** would sometime fail ++ when it should not. ++- The fix also includes a couple of minor fixes such as making the **--layout=preserve** option to ++ **--grow** work again. ++ ++# Release [mdadm-3.2.4](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.2.4) ++ ++ - **--offroot** argument to improve interactions between mdmon and initrd. ++ - **--prefer** argument to select which */dev* names to display in some circumstances. ++ - relax restrictions on when **--add** will be allowed. ++ - Fix bug with adding write-intent-bitmap to active array. ++ - Now defaults to */run/mdadm* for storing run-time files. ++ ++# Release [mdadm-3.2.3](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.2.3) ++ ++- The largest single area of change is support for reshape of Intel IMSM arrays (OnLine Capacity ++ Expansion and Level Migration). ++- Among other fixes, this now has a better chance of surviving if a device fails during reshape. ++ ++# Release [mdadm-3.2.2](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.2.2) ++ ++- reshaping IMSM (Intel metadata) arrays is no longer 'experimental', it should work properly and be ++ largely compatible with IMSM drivers in other platforms. ++- **--assume-clean** can be used with **--grow --size** to avoid resyncing the new part of the ++ array. This is only support with very new kernels. ++- RAID0 arrays can have chunksize which is not a power of 2. This has been supported in the kernel ++ for a while but is only now supported by mdadm. ++ ++- A new tool **raid6check** is available, which can check a RAID6 array, or part of it and report ++ which device is most inconsistent with the others if any stripe is inconsistent. This is still ++ under development and does not have a man page yet. If anyone tries it out and has any questions ++ or experience to report, they would be most welcome on linux-raid@vger.kernel.org. ++ ++# Release [mdadm-3.2.1](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.2.1) ++ ++- Policy framework ++ ++ Policy can be expressed for moving spare devices between arrays, and for how to handle hot-plugged ++ devices. This policy can be different for devices plugged in to different controllers etc. This, ++ for example, allows a configuration where when a device is plugged in it is immediately included ++ in an md array as a hot spare and possibly starts recovery immediately if an array is degraded. ++ ++- Some understanding of mbr and gpt paritition tables. This is primarily to support the new ++ hot-plug support. If a device is plugged in and policy suggests it should have a partition table, ++ the partition table will be copied from a suitably similar device, and then the partitions will ++ hot-plug and can then be added to md arrays. ++ ++- **--incremental --remove** can remember where a device was removed from so if a device gets ++ plugged back in the same place, special policy applies to it, allowing it to be included in an ++ array even if a general hotplug will not be included. ++ ++- Enhanced reshape options, including growing a RAID0 by converting to RAID4, restriping, and ++ converting back. Also convertions between RAID0 and RAID10 and between RAID1 and RAID10 are ++ possible (with a suitably recent kernel). ++ ++- Spare migration for IMSM arrays. Spare migration can now work across 'containers' using ++ non-native metadata and specifically Intel's IMSM arrays support spare migrations. ++ ++- OLCE and level migration for Intel IMSM arrays. OnLine Capacity Expansion and level migration ++ (e.g. RAID0 -> RAID5) is supported for Intel Matrix Storage Manager arrays. This support is ++ currently *experimental* for technical reasons. It can be enabled with ++ **export MDADM_EXPERIMENTAL=1**. ++ ++- avoid including wayward devices. ++ ++ If you split a RAID1, mount the two halves as two separate degraded RAID1s, and then later bring ++ the two back together, it is possible that the md metadata won't properly show that one must ++ over-ride the other. Mdadm now does extra checking to detect this possibility and avoid ++ potentially corrupting data. ++ ++- Remove any possible confusion between similar options. e.g. **--brief** and **--bitmap** were ++ mapped to 'b' and mdadm wouldn't notice if one was used where the other was expected. ++ ++- Allow K,M,G suffixes on chunk sizes. ++ ++# Release [mdadm-3.2](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.2) ++ ++- By far the most significant change in this release related to the management of reshaping arrays. ++ This code has been substantially re-written so that it can work with **externally managed ++ metadata** -Intel's IMSM in particular. We now support level migration and OnLine Capacity ++ Expansion on these arrays. ++ ++- Various policy statements can be made in the *mdadm.conf* to guide the behavior of mdadm, ++ particular with regards to how new devices are treated by **--incremental**. Depending on the ++ *action* associated with a device (identified by its *path*) such need devices can be ++ automatically re-added to and existing array that they previously fell out off, or automatically ++ added as a spare if they appear to contain no data. ++ ++- mdadm now has a limited understanding of partition tables. This allows the policy framework to ++ make decisions about partitioned devices as well. ++ ++- **--incremental --remove** can be told what **--path** the device was on, and this info will be ++ recorded so that another device appearing at the same physical location can be preferentially ++ added to the same array (provides the spare-same-slot action policy applied to the path). ++ ++- A new flags **--invalid-backup** flag is available in **--assemble** mode. This can be used to ++ re-assemble an array which was stopping in the middle of a reshape, and for which the ++ *backup file* is no longer available or is corrupted. The array may have some corruption in it ++ at the point where reshape was up to, but at least the rest of the array will become available. ++ ++- Policy framework. ++- Various internal restructuring - more is needed. ++ ++# Release [mdadm-3.1.5](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.1.5) ++ ++- Fixes for **v1.x** metadata on big-endian machines. ++- man page improvements. ++- Improve **--detail --export** when run on partitions of an md array. ++- Fix regression with removing *failed* or *detached* devices. ++- Fixes for **--assemble --force** in various unusual cases. ++- Allow **-Y** to mean **--export**. This was documented but not implemented. ++- Various fixes for handling **ddf** metadata. This is now more reliable but could benefit from ++ more interoperability testing. ++- Correctly list subarrays of a container in **--detail** output. ++- Improve checks on whether the requested number of devices is supported by the metadata, both for ++ **--create** and **--grow**. ++- Don't remove partitions from a device that is being included in an array until we are fully ++ committed to including it. ++- Allow **--assemble --update=no-bitmap** so an array with a corrupt bitmap can still be assembled. ++- Don't allow **--add** to succeed if it looks like a **--re-add** is probably wanted, but cannot ++ succeed. This avoids inadvertently turning devices into spares when an array is failed. ++ ++# Release [mdadm-3.1.4](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.1.4) ++ ++Two fixes related to configs that aren't using udev: ++- Don't remove md devices which 'standard' names on **--stop**. ++- Allow dev_open to work on read-only */dev*. ++ ++And fixed regressions: ++- Allow **--incremental** to add spares to an array. ++- Accept **--no-degraded** as a deprecated option rather than throwing an error. ++- Return correct success status when **--incremental** assembling a container which does not yet ++ have enough devices. ++- Don't link mdadm with pthreads, only mdmon needs it. ++- Fix compiler warning due to bad use of snprintf. ++ ++# Release [mdadm-3.1.3](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.1.3) ++ ++- mapfile now lives in a fixed location which default to */dev/.mdadm/map*, but can be changed at ++ compile time. This location is chosen and most distros provide it during early boot and preserve ++ it through. As long a */dev* exists and is writable, */dev/.mdadm* will be created. Other files ++ communication with mdmon live here too. This fixes a bug reported by Debian and Gentoo users where ++ udev would spin in early-boot. ++ ++- IMSM and DDF metadata will not be recognized on partitions as they should only be used on ++ whole-disks. ++ ++- Various overflows causes by 2G drives have been addressed. ++ ++- A subarray of an IMSM contain can now be killed with **--kill-subarray**. Also, subarrays can be ++ renamed with **--update-subarray --update=name**. ++ ++- **-If** (or **--incremental --fail**) can be used from udev to fail and remove from all arrays ++ a device which has been unplugged from the system i.e. hot-unplug-support. ++ ++- **/dev/mdX --re-add missing** will look for any device that looks like it should be a member of ++ */dev/mdX* but isn't and will automatically **--re-add** it. ++ ++- Now compile with *-Wextra* to get extra warnings. ++- Lots of minor bug fixes, documentation improvements, etc. ++ ++# Release [mdadm-3.1.2](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.1.2) ++ ++- The default metadata has change again (sorry about that). It is now **v1.2** and will hopefully ++ stay that way. It turned out there with boot-block issues with **v1.1** which make it unsuitable ++ for a default, though in many cases it is still suitable to use. ++ ++- Add *homehost* to the valid words for the **AUTO** config file line. When followed by *-all*, ++ this causes mdadm to auto-assemble any array belonging to this host, but not auto-assemble ++ anything else. ++ ++- VAR_RUN can be easily changed at compile time just like ALT_RUN. This gives distros more ++ flexibility in how to manage the pid and sock files that mdmon needs. ++ ++- If mdadm.conf lists arrays which have inter-dependencies, the previously had to be listed in the ++ "right" order. Now, any order should work. ++ ++- Fix some bugs with **--grow --chunksize=**. ++- Stopping a container is not permitted when members are still active. ++- Various mdmon fixes. ++- Alway make bitmap 4K-aligned if at all possible. ++- Fix **--force** assembly of **v1.x** arrays which are in the process of recovering. ++- Add section on 'scrubbing' to 'md' man page. ++- Various command-line-option parsing improvements. ++- ... and lots of other bug fixes. ++ ++# Release [mdadm-3.1.1](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.1.1) ++ ++- Multiple fixes for new **--grow** levels including fixes for serious data corruption ++ problems. ++- Change default metadata to **v1.1**. ++- Change default chunk size to 512K. ++- Change default bitmap chunk size to 64MB. ++- When **--re-add** is used, don't fall back to **--add** as this can destroy data. ++ ++# Release [mdadm-3.1](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.1) ++ ++- Support **--grow** to change the layout of RAID 4/5/6. ++- Support **--grow** to change the chunk size of RAID 4/5/6. ++- Support **--grow** to change level from RAID1 -> RAID5 -> RAID6 and back. ++- Support **--grow** to reduce the number of devices in RAID 4/5/6. ++- Support restart of these grow options which assembling an array which is partially grown. ++- Assorted tests of this code, and of different RAID6 layouts. ++ ++# Release [mdadm-3.0.3](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.0.3) ++ ++- Improvements for creating arrays giving just a name, like *foo*, rather than the full ++ */dev/md/foo*. ++- Improvements for assembling member arrays of containers. ++- Improvements to test suite. ++- Add option to change increment for *RebuildNN* messages reported by **--monitor**. ++- Improvements to **mdmon** hand-over from initrd to final root. ++- Handle merging of devices that have left an IMSM array and are being re-incorporated. ++- Add missing space in **--detail --brief** output. ++ ++# Release [mdadm-3.0.2](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.0.2) ++ ++- Fix crash when **homehost** is not set, as often happens in early boot. ++ ++# Release [mdadm-3.0.1](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.0.1) ++ ++- Fix various segfaults. ++- Fixed for **--examine** with containers. ++- Lots of other little fixes. ++ ++# Release [mdadm-3.0](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git/log/?h=mdadm-3.0) ++ ++- Support for **externally managed metadata**, specifically DDF and IMSM. ++- Depend on udev to create entries in */dev*, rather than creating them ourselves. ++- Remove **--auto-update-home-hosts**. ++- New config file line **auto**. ++- New *ignore* and *any* options for **homehost**. ++- Numerous bug fixes and minor enhancements. +diff --git a/ChangeLog b/ChangeLog +deleted file mode 100644 +index a3bf7007..00000000 +--- a/ChangeLog ++++ /dev/null +@@ -1,306 +0,0 @@ +-Please see git logs for detailed change log. +-This file just contains highlight. +- +-Changes Prior to release 3.3 +-- Some array reshapes can proceed without needing backup file. +- This is done by changing the 'data_offset' so we never need to write +- any data back over where it was before. If there is no "head space" +- or "tail space" to allow data_offset to change, the old mechanism +- with a backup file can still be used. +-- RAID10 arrays can be reshaped to change the number of devices, +- change the chunk size, or change the layout between 'near' +- and 'offset'. +- This will always change data_offset, and will fail if there is no +- room for data_offset to be moved. +-- "--assemble --update=metadata" can convert a 0.90 array to a 1.0 array. +-- bad-block-logs are supported (but not heavily tested yet) +-- "--assemble --update=revert-reshape" can be used to undo a reshape +- that has just been started but isn't really wanted. This is very +- new and while it passes basic tests it cannot be guaranteed. +-- improved locking between --incremental and --assemble +-- uses systemd to run "mdmon" if systemd is configured to do that. +-- kernel names of md devices can be non-numeric. e.g. "md_home" rather than +- "md0". This will probably confuse lots of other tools, so you need to +- echo CREATE names=yes >> /etc/mdadm.conf +- or the feature will not be used. (you also need a reasonably new kernel). +-- "--stop" can be given a kernel name instead of a device name. i.e +- mdadm --stop md4 +- will work even if /dev/md4 doesn't exist. +-- "--detail --export" has some information about the devices in the array +-- --dump and --restore can be used to backup and restore the metadata on an +- array. +-- Hot-replace is supported with +- mdadm /dev/mdX --replace /dev/foo +- and +- mdadm /dev/mdX --replace /dev/foo --with /dev/bar +-- Config file can be a directory in which case all "*.conf" files are +- read in lexical order. +- Default is to read /etc/mdadm.conf and then /etc/mdadm.conf.d +- Thus +- echo CREATE name=yes > /etc/mdadm.conf.d/names.conf +- will also enable the use of named md devices. +- +-- Lots of improvements to DDF support including adding support for +- RAID10 (thanks Martin Wilck). +- +-Changes Prior to release 3.2.6 +- - There are no real stand-out fixes, just lots of little bits and pieces. +- +-Changes Prior to release 3.2.5 +- - This release primarily fixes a serious regression in 3.2.4. +- This regression does *not* cause any risk to data. It simply +- means that adding a device with "--add" would sometime fail +- when it should not. +- +- - The fix also includes a couple of minor fixes such as making +- the "--layout=preserve" option to "--grow" work again. +- +- +-Changes Prior to release 3.2.4 +-"--oneline" log of changes is below. Some notable ones are: +- +- - --offroot argument to improve interactions between mdmon and initrd +- - --prefer argument to select which /dev names to display in some +- circumstances. +- - relax restructions on when "--add" will be allowed +- - Fix bug with adding write-intent-bitmap to active array +- - Now defaults to "/run/mdadm" for storing run-time files. +- +-Changes Prior to release 3.2.3 +- - The largest single area of change is support for reshape of Intel +- IMSM arrays (OnLine Capacity Explansion and Level Migration). +- - Among other fixes, this now has a better chance of surviving if a +- device fails during reshape. +- +-Changes Prior to release 3.2.2 +- - reshaping IMSM (Intel metadata) arrays is no longer 'experimental', +- it should work properly and be largely compatible with IMSM drivers in +- other platforms. +- - --assume-clean can be used with --grow --size to avoid resyncing the +- new part of the array. This is only support with very new kernels. +- - RAID0 arrays can have chunksize which is not a power of 2. This has been +- supported in the kernel for a while but is only now supprted by +- mdadm. +- +- - A new tool 'raid6check' is available which can check a RAID6 array, +- or part of it, and report which device is most inconsistent with the +- others if any stripe is inconsistent. This is still under development +- and does not have a man page yet. If anyone tries it out and has any +- questions or experience to report, they would be most welcome on +- linux-raid@vger.kernel.org. +- +-Changes Prior to release 3.2.1 +- - policy framework +- Policy can be expressed for moving spare devices between arrays, and +- for how to handle hot-plugged devices. This policy can be different +- for devices plugged in to different controllers etc. +- This, for example, allows a configuration where when a device is plugged +- in it is immediately included in an md array as a hot spare and +- possibly starts recovery immediately if an array is degraded. +- +- - some understanding of mbr and gpt paritition tables +- This is primarly to support the new hot-plug support. If a +- device is plugged in and policy suggests it should have a partition table, +- the partition table will be copied from a suitably similar device, and +- then the partitions will hot-plug and can then be added to md arrays. +- +- - "--incremental --remove" can remember where a device was removed from +- so if a device gets plugged back in the same place, special policy applies +- to it, allowing it to be included in an array even if a general hotplug +- will not be included. +- +- - enhanced reshape options, including growing a RAID0 by converting to RAID4, +- restriping, and converting back. Also convertions between RAID0 and +- RAID10 and between RAID1 and RAID10 are possible (with a suitably recent +- kernel). +- +- - spare migration for IMSM arrays. +- Spare migration can now work across 'containers' using non-native metadata +- and specifically Intel's IMSM arrays support spare migrations. +- +- - OLCE and level migration for Intel IMSM arrays. +- OnLine Capacity Expansion and level migration (e.g. RAID0 -> RAID5) is +- supported for Intel Matrix Storage Manager arrays. +- This support is currently 'experimental' for technical reasons. It can +- be enabled with "export MDADM_EXPERIMENTAL=1" +- +- - avoid including wayward devices +- If you split a RAID1, mount the two halves as two separate degraded RAID1s, +- and then later bring the two back together, it is possible that the md +- metadata won't properly show that one must over-ride the other. +- mdadm now does extra checking to detect this possibilty and avoid +- potentially corrupting data. +- +- - remove any possible confusion between similar options. +- e.g. --brief and --bitmap were mapped to 'b' and mdadm wouldn't +- notice if one was used where the other was expected. +- +- - allow K,M,G suffixes on chunk sizes +- +-Changes Prior to release 3.2 +- - By far the most significant change in this release related to the +- management of reshaping arrays. This code has been substantially +- re-written so that it can work with 'externally managed metadata' - +- Intel's IMSM in particular. We now support level migration and +- OnLine Capacity Expansion on these arrays. +- - Policy framework. +- Various policy statements can be made in the mdadm.conf to guide +- the behaviour of mdadm, particular with regards to how new devices +- are treated by "mdadm -I". +- Depending on the 'action' associated with a device (identified by +- its 'path') such need devices can be automatically re-added to and +- existing array that they previously fell out off, or automatically +- added as a spare if they appear to contain no data. +- +- - mdadm now has a limited understanding of partition tables. This +- allows the policy framework to make decisions about partitioned +- devices as well. +- +- - --incremental --remove can be told what --path the device was on, +- and this info will be recorded so that another device appearing at +- the same physical location can be preferentially added to the same +- array (provides the spare-same-slot action policy applied to the +- path). +- +- - A new flags "--invalid-backup" flag is available in --assemble +- mode. This can be used to re-assemble an array which was stopping +- in the middle of a reshape, and for which the 'backup file' is no +- longer available or is corrupted. The array may have some +- corruption in it at the point where reshape was up to, but at least +- the rest of the array will become available. +- +- +- - Various internal restructuring - more is needed. +- +-Changes Prior to release 3.1.5 +- - Fixes for v1.x metadata on big-endian machines. +- - man page improvements +- - Improve '--detail --export' when run on partitions of an md array. +- - Fix regression with removing 'failed' or 'detached' devices. +- - Fixes for "--assemble --force" in various unusual cases. +- - Allow '-Y' to mean --export. This was documented but not implemented. +- - Various fixed for handling 'ddf' metadata. This is now more reliable +- but could benefit from more interoperability testing. +- - Correctly list subarrays of a container in "--detail" output. +- - Improve checks on whether the requested number of devices is supported +- by the metadata - both for --create and --grow. +- - Don't remove partitions from a device that is being included in an +- array until we are fully committed to including it. +- - Allow "--assemble --update=no-bitmap" so an array with a corrupt +- bitmap can still be assembled. +- - Don't allow --add to succeed if it looks like a "--re-add" is probably +- wanted, but cannot succeed. This avoids inadvertently turning +- devices into spares when an array is failed. +- +-Changes Prior to release 3.1.4 +- Two fixes related to configs that aren't using udev: +- - Don't remove md devices which 'standard' names on --stop +- - Allow dev_open to work on read-only /dev +- And fixed regressions: +- - Allow --incremental to add spares to an array +- - Accept --no-degraded as a deprecated option rather than +- throwing an error +- - Return correct success status when --incrmental assembling +- a container which does not yet have enough devices. +- - Don't link mdadm with pthreads, only mdmon needs it. +- - Fix compiler warning due to bad use of snprintf +- +-Changes Prior to release 3.1.3 +- - mapfile now lives in a fixed location which default to +- /dev/.mdadm/map but can be changed at compile time. This +- location is choses and most distros provide it during early +- boot and preserve it through. As long a /dev exists and is +- writable, /dev/.mdadm will be created. +- Other files file communication with mdmon live here too. +- This fixes a bug reported by Debian and Gentoo users where +- udev would spin in early-boot. +- - IMSM and DDF metadata will not be recognised on partitions +- as they should only be used on whole-disks. +- - Various overflows causes by 2G drives have been addressed. +- - A subarray of an IMSM contain can now be killed with +- --kill-subarray. Also subarrays can be renamed with +- --update-subarray +- - -If (or --incremental --fail) can be used from udev to +- fail and remove from all arrays a device which has been +- unplugged from the system. i.e. hot-unplug-support. +- - "mdadm /dev/mdX --re-add missing" will look for any device +- that looks like it should be a member of /dev/mdX but isn't +- and will automatically --re-add it +- - Now compile with -Wextra to get extra warnings. +- - Lots of minor bug fixes, documentation improvements, etcc +- +-Changes Prior to release 3.1.2 +- - The default metadata has change again (sorry about that). +- It is now v1.2 and will hopefully stay that way. It turned +- out there with boot-block issues with v1.1 which make it +- unsuitable for a default, though in many cases it is still +- suitable to use. +- - Stopping a container is not permitted when members are still +- active +- - Add 'homehost' to the valid words for the "AUTO" config file +- line. When followed by "-all", this causes mdadm to +- auto-assemble any array belonging to this host, but not +- auto-assemble anything else. +- - Fix some bugs with "--grow --chunksize=" for changing chunksize. +- - VAR_RUN can be easily changed at compile time just like ALT_RUN. +- This gives distros more flexability in how to manage the +- pid and sock files that mdmon needs. +- - Various mdmon fixes +- - Alway make bitmap 4K-aligned if at all possible. +- - If mdadm.conf lists arrays which have inter-dependencies, +- the previously had to be listed in the "right" order. Now +- any order should work. +- - Fix --force assembly of v1.x arrays which are in the process +- of recovering. +- - Add section on 'scrubbing' to 'md' man page. +- - Various command-line-option parsing improvements. +- - ... and lots of other bug fixes. +- +-Changes Prior to release 3.1.1 +- - Multiple fixes for new --grow levels including fixes for +- serious data corruption problems. +- - Change default metadata to v1.1 +- - Change default chunk size to 512K +- - Change default bitmap chunk size to 64Meg +- - When --re-add is used, don't fall back to +- --add if --re-add fails as this can destroy data. +- +-Changes Prior to release 3.1 +- - Support --grow to change the layout of RAID4/5/6 +- - Support --grow to change the chunksize of raid 4/5/6 +- - Support --grow to change level from RAID1 -> RAID5 -> RAID6 and +- back. +- - Support --grow to reduce the number of devices in RAID4/5/6. +- - Support restart of these grow options which assembling an array +- which is partially grown. +- - Assorted tests of this code, and of different RAID6 layouts. +- +-Changes Prior to release 3.0.3 +- - Improvements for creating arrays giving just a name, like 'foo', +- rather than the full '/dev/md/foo'. +- - Improvements for assembling member arrays of containers. +- - Improvements to test suite +- - Add option to change increment for RebuildNN messages reported +- by "mdadm --monitor" +- - Improvements to mdmon 'hand-over' from initrd to final root. +- - Handle merging of devices that have left an IMSM array and are +- being re-incorporated. +- - Add missing space in "--detail --brief" output. +- +-Changes Prior to release 3.0.2 +- - Fix crash when hosthost is not set, as often happens in +- early boot. +- +-Changes Prior to release 3.0.1 +- - Fix various segfaults +- - Fixed for --examine with containers +- - Lots of other little fixes. +- +-Changes Prior to release 3.0 +- - Support for externally managed metadata, specifically DDF and IMSM. +- - Depend on udev to create entries in /dev, rather than creating them +- ourselves. +- - remove --auto-update-home-hosts +- - new config file line "auto" +- - new "" and "any" options for "homehost" +- - numerous bug fixes and minor enhancements. +-- +2.41.0 + diff --git a/0049-mdadm-Add-MAINTAINERS.md.patch b/0049-mdadm-Add-MAINTAINERS.md.patch new file mode 100644 index 0000000..ac846f5 --- /dev/null +++ b/0049-mdadm-Add-MAINTAINERS.md.patch @@ -0,0 +1,66 @@ +From 21d6c5d96a5a467b5877ba1d38106b3746005bcc Mon Sep 17 00:00:00 2001 +From: Mariusz Tkaczyk +Date: Tue, 26 Mar 2024 13:21:11 +0100 +Subject: [PATCH 49/69] mdadm: Add MAINTAINERS.md + +Describe rules maintainer should follow. + +Signed-off-by: Mariusz Tkaczyk +--- + MAINTAINERS.md | 44 ++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 44 insertions(+) + create mode 100644 MAINTAINERS.md + +diff --git a/MAINTAINERS.md b/MAINTAINERS.md +new file mode 100644 +index 00000000..9c79ba87 +--- /dev/null ++++ b/MAINTAINERS.md +@@ -0,0 +1,44 @@ ++# Maintainer tools ++ ++Useful tools used in daily routines: ++- [checkpatch](https://docs.kernel.org/dev-tools/checkpatch.html) ++- [kup](https://korg.docs.kernel.org/kup.html) ++- [Auto-publishing](https://korg.docs.kernel.org/kup.html#auto-publishing-with-git-archive-signer) ++- [b4](https://b4.docs.kernel.org/en/latest/) ++ ++# Checklist before applying patch ++ ++We don't have CI testing yet, so all those steps must be performed manually: ++- Style check with [checkpatch](https://docs.kernel.org/dev-tools/checkpatch.html): ++ ++ This is the current code style follows. We are not strict to all rules. It must be run ++ by **checkpatch --no-tree**, see README.md. ++ ++- [Commit style](https://www.kernel.org/doc/html/v4.10/process/submitting-patches.html): ++ ++ It doesn't need to be followed as strictly as is in kernel but changes should be logically ++ separated. Submitter should care at least to mention "It is used in next patches" if unused ++ externs/files are added in patch. We love: *Reported-by:*, *Suggested-by:*, *Fixes:* tags. ++ ++- Compilation, ideally on various gcc versions. ++- Mdadm test suite execution. ++- Consider requesting new tests from submitter, especially for new functionalities. ++- Ensure that maintainer *sign-off* is added, before pushing. ++ ++# Making a release ++ ++Assuming that maintainer is certain that release is safe, following steps must be done: ++ ++- Update versions strings in release commit, please refer to previous releases for examples. ++ ++- Create GPG signed tag and push it to repo. Use same format as was used previously, prefixed by ++ **mdadm-**, e.g. **mdadm-3.1.2**, **mdadm-4.1**. ++ ++- [Auto-publishing](https://korg.docs.kernel.org/kup.html#auto-publishing-with-git-archive-signer): ++ ++ Adopt script to our release tag model. When ready, push signed note to repository. If it is done ++ correctly, then *(sig)* is added to the package automatically generated by kernel.org automation. ++ There is no need to upload archive manually. ++ ++- Update CHANGELOG.md. ++- Write "ANNOUNCE" mail to linux-raid@kernel.org to notify community. +-- +2.41.0 + diff --git a/0050-mdadm-Add-README.md.patch b/0050-mdadm-Add-README.md.patch new file mode 100644 index 0000000..aabbbf4 --- /dev/null +++ b/0050-mdadm-Add-README.md.patch @@ -0,0 +1,106 @@ +From 256edaef3d43a112356762aaea4a48f021f45aec Mon Sep 17 00:00:00 2001 +From: Mariusz Tkaczyk +Date: Tue, 26 Mar 2024 13:21:12 +0100 +Subject: [PATCH 50/69] mdadm: Add README.md + +Describe supported metadata types, add step-by-step patch sending +instruction, mention minimally supported kernel version and licensing. + +Signed-off-by: Mariusz Tkaczyk +--- + README.md | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 83 insertions(+) + create mode 100644 README.md + +diff --git a/README.md b/README.md +new file mode 100644 +index 00000000..64f2ecec +--- /dev/null ++++ b/README.md +@@ -0,0 +1,83 @@ ++**mdadm** is a utility used to create and manage **software RAID** devices implemented through ++**Multiple devices driver (MD)** in kernel. It supports following RAID metadata formats: ++ ++* [Linux native RAID](https://raid.wiki.kernel.org/index.php/RAID_superblock_formats): ++ ++ Known as **native** or **native RAID**. First and default metadata format. Metadata management ++ is implemented in **MD driver**. ++ ++* Matrix Storage Manager Support (no reference, metadata format documentation is proprietary). ++ ++ Known as **IMSM**. Metadata format developed and maintained by **Intel®** as a part of **VROC** ++ solution. There are some functional differences between **native** and **imsm**. The most ++ important difference is that the metadata is managed from userspace. ++ ++ **CAUTION:** **imsm** is compatible with **Intel RST**, however it is not officially supported. ++ You are using it on your own risk. ++ ++* [Common RAID DDF Specification Revision](https://www.snia.org/sites/default/files/SNIA_DDF_Technical_Position_v2.0.pdf) ++ ++ **IMPORTANT:** DDF is in **maintenance only** mode. There is no active development around it. ++ Please do not use it in new solutions. ++ ++# How to Contribute ++ ++ **mdadm** is hosted on [kernel.org](https://kernel.org/). You can access repository ++[here](https://git.kernel.org/pub/scm/utils/mdadm/mdadm.git). ++ ++It is maintained similarly to kernel, using *mailing list*. Patches must be send through email. ++Please familiarize with general kernel ++[submitting patches](https://www.kernel.org/doc/html/v4.17/process/submitting-patches.html) ++documentation. Formatting, tags and commit message guidelines applies to **mdadm**. ++ ++## Sending patches step-by-step ++ ++To maximize change of patches being taken, follow this instruction when submitting: ++ ++1. Create possibly logically separated commits and generate patches: ++ ++ Use ``git format-patch --cover-letter --signoff -v `` to create patches: ++ * ``--cover-letter`` can be skipped if it is only one patch; ++ * ``--signoff`` adds sign-off tag; ++ * ``-v `` indicates review revision number, sender should increment it before resending. ++ ++2. Check style of every patch with kernel ++ [checkpatch](https://docs.kernel.org/dev-tools/checkpatch.html) script: ++ ++ It is important to keep same coding style that is why in **mdadm** ++ [kernel coding style](https://www.kernel.org/doc/html/v4.10/process/coding-style.html) ++ is preferred. ``checkpath --no-tree `` can be used to verify patches. ++ Following checkpatch issues can be ignored: ++ - New typedefs. ++ - comparing with *True/False*. ++ - kernel *MAINTAINERS* file warning. ++ - *extern* keyword in headers. ++ ++3. Send patches using ``git send-mail --to=linux-raid@vger.kernel.org (...)`` ++ ++# Maintainers ++ ++It is good practice to add **mdadm maintainers** to recipients for patches: ++ ++- Jes Sorensen ; ++- Mariusz Tkaczyk ; ++ ++Adding **MD maintainers** could be reasonable, especially if patches may affect MD driver: ++ ++- Song Liu ; ++- Yu Kuai ; ++ ++# Reviewers ++ ++**mdadm** utility is not part of kernel tree, so there is no certificated *Reviewers* list. Everyone ++can comment on mailing list, last decision (and merging) belongs to maintainers. ++ ++# Minimal supported kernel version ++ ++We do not support kernel versions below **v3.10**. Please be aware that maintainers may remove ++workarounds and fixes for legacy issues. ++ ++# License ++ ++It is released under the terms of the **GNU General Public License version 2** as published ++by the **Free Software Foundation**. +-- +2.41.0 + diff --git a/0051-Create.c-fix-uclibc-build.patch b/0051-Create.c-fix-uclibc-build.patch new file mode 100644 index 0000000..8e38a6a --- /dev/null +++ b/0051-Create.c-fix-uclibc-build.patch @@ -0,0 +1,41 @@ +From 52bead95d2957437c691891fcdc49bd6afccdd49 Mon Sep 17 00:00:00 2001 +From: Fabrice Fontaine +Date: Fri, 12 Apr 2024 18:45:13 +0200 +Subject: [PATCH 51/69] Create.c: fix uclibc build + +Define FALLOC_FL_ZERO_RANGE if needed as FALLOC_FL_ZERO_RANGE is only +defined for aarch64 on uclibc-ng resulting in the following or1k build +failure since commit 577fd10486d8d1472a6b559066f344ac30a3a391: + +Create.c: In function 'write_zeroes_fork': +Create.c:155:35: error: 'FALLOC_FL_ZERO_RANGE' undeclared (first use in this function) + 155 | if (fallocate(fd, FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE, + | ^~~~~~~~~~~~~~~~~~~~ + +Fixes: + - http://autobuild.buildroot.org/results/0e04bcdb591ca5642053e1f7e31384f06581e989 + +Signed-off-by: Fabrice Fontaine +Signed-off-by: Mariusz Tkaczyk +--- + Create.c | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/Create.c b/Create.c +index 4397ff49..d94253b1 100644 +--- a/Create.c ++++ b/Create.c +@@ -32,6 +32,10 @@ + #include + #include + ++#ifndef FALLOC_FL_ZERO_RANGE ++#define FALLOC_FL_ZERO_RANGE 16 ++#endif ++ + static int round_size_and_verify(unsigned long long *size, int chunk) + { + if (*size == 0) +-- +2.41.0 + diff --git a/0052-mdadm-pass-struct-context-for-external-reshapes.patch b/0052-mdadm-pass-struct-context-for-external-reshapes.patch new file mode 100644 index 0000000..68368e4 --- /dev/null +++ b/0052-mdadm-pass-struct-context-for-external-reshapes.patch @@ -0,0 +1,309 @@ +From bdc2c56998abf76141294b04facf20217cfd1911 Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:13 +0200 +Subject: [PATCH 52/69] mdadm: pass struct context for external reshapes + +This patch alters mutiple functions calls so the context is passed to +external reshape functions. + +There are two main reasons behind it: +- reduces number of arguments passed and unifies them, +- imsm code will make use of context in incoming patches. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + Assemble.c | 7 ++---- + Grow.c | 68 +++++++++++++++++++++------------------------------ + mdadm.c | 2 +- + mdadm.h | 11 +++------ + super-intel.c | 6 ++--- + 5 files changed, 37 insertions(+), 57 deletions(-) + +diff --git a/Assemble.c b/Assemble.c +index f6c5b99e..f5e9ab1f 100644 +--- a/Assemble.c ++++ b/Assemble.c +@@ -1197,9 +1197,7 @@ static int start_array(int mdfd, + rv = sysfs_set_str(content, NULL, + "array_state", "readonly"); + if (rv == 0) +- rv = Grow_continue(mdfd, st, content, +- c->backup_file, 0, +- c->freeze_reshape); ++ rv = Grow_continue(mdfd, st, content, 0, c); + } else if (c->readonly && + sysfs_attribute_available(content, NULL, + "array_state")) { +@@ -2180,8 +2178,7 @@ int assemble_container_content(struct supertype *st, int mdfd, + st->update_tail = &st->updates; + } + +- err = Grow_continue(mdfd, st, content, c->backup_file, +- 0, c->freeze_reshape); ++ err = Grow_continue(mdfd, st, content, 0, c); + } else switch(content->array.level) { + case LEVEL_LINEAR: + case LEVEL_MULTIPATH: +diff --git a/Grow.c b/Grow.c +index 074f1995..f477b438 100644 +--- a/Grow.c ++++ b/Grow.c +@@ -864,8 +864,7 @@ static void wait_reshape(struct mdinfo *sra) + + static int reshape_super(struct supertype *st, unsigned long long size, + int level, int layout, int chunksize, int raid_disks, +- int delta_disks, char *backup_file, char *dev, +- int direction, int verbose) ++ int delta_disks, char *dev, int direction, struct context *c) + { + /* nothing extra to check in the native case */ + if (!st->ss->external) +@@ -876,9 +875,8 @@ static int reshape_super(struct supertype *st, unsigned long long size, + return 1; + } + +- return st->ss->reshape_super(st, size, level, layout, chunksize, +- raid_disks, delta_disks, backup_file, dev, +- direction, verbose); ++ return st->ss->reshape_super(st, size, level, layout, chunksize, raid_disks, ++ delta_disks, dev, direction, c); + } + + static void sync_metadata(struct supertype *st) +@@ -1764,9 +1762,8 @@ static int reshape_container(char *container, char *devname, + int mdfd, + struct supertype *st, + struct mdinfo *info, +- int force, +- char *backup_file, int verbose, +- int forked, int restart, int freeze_reshape); ++ struct context *c, ++ int forked, int restart); + + /** + * prepare_external_reshape() - prepares update on external metadata if supported. +@@ -2004,9 +2001,8 @@ int Grow_reshape(char *devname, int fd, + goto release; + } + +- if (reshape_super(st, s->size, UnSet, UnSet, 0, 0, UnSet, NULL, +- devname, APPLY_METADATA_CHANGES, +- c->verbose > 0)) { ++ if (reshape_super(st, s->size, UnSet, UnSet, 0, 0, UnSet, ++ devname, APPLY_METADATA_CHANGES, c)) { + rv = 1; + goto release; + } +@@ -2124,10 +2120,8 @@ size_change_error: + int err = errno; + + /* restore metadata */ +- if (reshape_super(st, orig_size, UnSet, UnSet, 0, 0, +- UnSet, NULL, devname, +- ROLLBACK_METADATA_CHANGES, +- c->verbose) == 0) ++ if (reshape_super(st, orig_size, UnSet, UnSet, 0, 0, UnSet, ++ devname, ROLLBACK_METADATA_CHANGES, c) == 0) + sync_metadata(st); + pr_err("Cannot set device size for %s: %s\n", + devname, strerror(err)); +@@ -2338,8 +2332,7 @@ size_change_error: + */ + close_fd(&fd); + rv = reshape_container(container, devname, -1, st, &info, +- c->force, c->backup_file, c->verbose, +- 0, 0, 0); ++ c, 0, 0); + frozen = 0; + } else { + /* get spare devices from external metadata +@@ -2356,13 +2349,13 @@ size_change_error: + } + + /* Impose these changes on a single array. First +- * check that the metadata is OK with the change. */ ++ * check that the metadata is OK with the change. ++ */ + + if (reshape_super(st, 0, info.new_level, + info.new_layout, info.new_chunk, + info.array.raid_disks, info.delta_disks, +- c->backup_file, devname, +- APPLY_METADATA_CHANGES, c->verbose)) { ++ devname, APPLY_METADATA_CHANGES, c)) { + rv = 1; + goto release; + } +@@ -3668,9 +3661,8 @@ int reshape_container(char *container, char *devname, + int mdfd, + struct supertype *st, + struct mdinfo *info, +- int force, +- char *backup_file, int verbose, +- int forked, int restart, int freeze_reshape) ++ struct context *c, ++ int forked, int restart) + { + struct mdinfo *cc = NULL; + int rv = restart; +@@ -3683,8 +3675,7 @@ int reshape_container(char *container, char *devname, + reshape_super(st, 0, info->new_level, + info->new_layout, info->new_chunk, + info->array.raid_disks, info->delta_disks, +- backup_file, devname, APPLY_METADATA_CHANGES, +- verbose)) { ++ devname, APPLY_METADATA_CHANGES, c)) { + unfreeze(st); + return 1; + } +@@ -3695,7 +3686,7 @@ int reshape_container(char *container, char *devname, + */ + ping_monitor(container); + +- if (!forked && !freeze_reshape) ++ if (!forked && !c->freeze_reshape) + if (continue_via_systemd(container, GROW_SERVICE, NULL)) + return 0; + +@@ -3705,7 +3696,7 @@ int reshape_container(char *container, char *devname, + unfreeze(st); + return 1; + default: /* parent */ +- if (!freeze_reshape) ++ if (!c->freeze_reshape) + printf("%s: multi-array reshape continues in background\n", Name); + return 0; + case 0: /* child */ +@@ -3802,12 +3793,12 @@ int reshape_container(char *container, char *devname, + flush_mdmon(container); + + rv = reshape_array(container, fd, adev, st, +- content, force, NULL, INVALID_SECTORS, +- backup_file, verbose, 1, restart, +- freeze_reshape); ++ content, c->force, NULL, INVALID_SECTORS, ++ c->backup_file, c->verbose, 1, restart, ++ c->freeze_reshape); + close(fd); + +- if (freeze_reshape) { ++ if (c->freeze_reshape) { + sysfs_free(cc); + exit(0); + } +@@ -4970,8 +4961,7 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, + return 1; + } + +-int Grow_continue_command(char *devname, int fd, +- char *backup_file, int verbose) ++int Grow_continue_command(char *devname, int fd, struct context *c) + { + int ret_val = 0; + struct supertype *st = NULL; +@@ -5157,7 +5147,7 @@ int Grow_continue_command(char *devname, int fd, + + /* continue reshape + */ +- ret_val = Grow_continue(fd, st, content, backup_file, 1, 0); ++ ret_val = Grow_continue(fd, st, content, 1, c); + + Grow_continue_command_exit: + if (cfd > -1) +@@ -5171,7 +5161,7 @@ Grow_continue_command_exit: + } + + int Grow_continue(int mdfd, struct supertype *st, struct mdinfo *info, +- char *backup_file, int forked, int freeze_reshape) ++ int forked, struct context *c) + { + int ret_val = 2; + +@@ -5187,14 +5177,12 @@ int Grow_continue(int mdfd, struct supertype *st, struct mdinfo *info, + st->ss->load_container(st, cfd, st->container_devnm); + close(cfd); + ret_val = reshape_container(st->container_devnm, NULL, mdfd, +- st, info, 0, backup_file, 0, +- forked, 1 | info->reshape_active, +- freeze_reshape); ++ st, info, c, forked, 1 | info->reshape_active); + } else + ret_val = reshape_array(NULL, mdfd, "array", st, info, 1, +- NULL, INVALID_SECTORS, backup_file, ++ NULL, INVALID_SECTORS, c->backup_file, + 0, forked, 1 | info->reshape_active, +- freeze_reshape); ++ c->freeze_reshape); + + return ret_val; + } +diff --git a/mdadm.c b/mdadm.c +index 3f191288..d18619db 100644 +--- a/mdadm.c ++++ b/mdadm.c +@@ -1636,7 +1636,7 @@ int main(int argc, char *argv[]) + c.delay = DEFAULT_BITMAP_DELAY; + rv = Grow_addbitmap(ident.devname, mdfd, &c, &s); + } else if (grow_continue) +- rv = Grow_continue_command(ident.devname, mdfd, c.backup_file, c.verbose); ++ rv = Grow_continue_command(ident.devname, mdfd, &c); + else if (s.size > 0 || s.raiddisks || s.layout_str || + s.chunk != 0 || s.level != UnSet || + s.data_offset != INVALID_SECTORS) { +diff --git a/mdadm.h b/mdadm.h +index 2640b396..0ade4beb 100644 +--- a/mdadm.h ++++ b/mdadm.h +@@ -1235,9 +1235,8 @@ extern struct superswitch { + int (*reshape_super)(struct supertype *st, + unsigned long long size, int level, + int layout, int chunksize, int raid_disks, +- int delta_disks, char *backup, char *dev, +- int direction, +- int verbose); /* optional */ ++ int delta_disks, char *dev, int direction, ++ struct context *c); + int (*manage_reshape)( /* optional */ + int afd, struct mdinfo *sra, struct reshape *reshape, + struct supertype *st, unsigned long blocks, +@@ -1541,8 +1540,7 @@ extern int Grow_reshape(char *devname, int fd, + extern int Grow_restart(struct supertype *st, struct mdinfo *info, + int *fdlist, int cnt, char *backup_file, int verbose); + extern int Grow_continue(int mdfd, struct supertype *st, +- struct mdinfo *info, char *backup_file, +- int forked, int freeze_reshape); ++ struct mdinfo *info, int forked, struct context *c); + extern int Grow_consistency_policy(char *devname, int fd, + struct context *c, struct shape *s); + +@@ -1552,8 +1550,7 @@ extern int restore_backup(struct supertype *st, + int spares, + char **backup_filep, + int verbose); +-extern int Grow_continue_command(char *devname, int fd, +- char *backup_file, int verbose); ++extern int Grow_continue_command(char *devname, int fd, struct context *c); + + extern int Assemble(struct supertype *st, char *mddev, + struct mddev_ident *ident, +diff --git a/super-intel.c b/super-intel.c +index 1faab607..417da267 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -12153,10 +12153,8 @@ exit: + } + + static int imsm_reshape_super(struct supertype *st, unsigned long long size, +- int level, +- int layout, int chunksize, int raid_disks, +- int delta_disks, char *backup, char *dev, +- int direction, int verbose) ++ int level, int layout, int chunksize, int raid_disks, ++ int delta_disks, char *dev, int direction, struct context *c) + { + int ret_val = 1; + struct geo_params geo; +-- +2.41.0 + diff --git a/0053-mdadm-use-struct-context-in-reshape_super.patch b/0053-mdadm-use-struct-context-in-reshape_super.patch new file mode 100644 index 0000000..7fe21f2 --- /dev/null +++ b/0053-mdadm-use-struct-context-in-reshape_super.patch @@ -0,0 +1,296 @@ +From 0acda7053df653022e46fa3b7caf1f4d4ba31a66 Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:14 +0200 +Subject: [PATCH 53/69] mdadm: use struct context in reshape_super() + +reshape_super() takes too many arguments. Change passing params in +favor of single struct. + +Add devname pointer and change direction members to struct shape +and use it for reshape_super(). + +Create reshape_array_size() and reshape_array_non_size() to handle +reshape_super() calls. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + Grow.c | 93 +++++++++++++++++++++++++++++++++++++-------------- + mdadm.h | 18 +++++----- + super-intel.c | 43 +++++++++++++++--------- + 3 files changed, 105 insertions(+), 49 deletions(-) + +diff --git a/Grow.c b/Grow.c +index f477b438..87ed9214 100644 +--- a/Grow.c ++++ b/Grow.c +@@ -862,9 +862,7 @@ static void wait_reshape(struct mdinfo *sra) + close(fd); + } + +-static int reshape_super(struct supertype *st, unsigned long long size, +- int level, int layout, int chunksize, int raid_disks, +- int delta_disks, char *dev, int direction, struct context *c) ++static int reshape_super(struct supertype *st, struct shape *shape, struct context *c) + { + /* nothing extra to check in the native case */ + if (!st->ss->external) +@@ -875,8 +873,65 @@ static int reshape_super(struct supertype *st, unsigned long long size, + return 1; + } + +- return st->ss->reshape_super(st, size, level, layout, chunksize, raid_disks, +- delta_disks, dev, direction, c); ++ return st->ss->reshape_super(st, shape, c); ++} ++ ++/** ++ * reshape_super_size() - Reshape array, size only. ++ * ++ * @st: supertype. ++ * @devname: device name. ++ * @size: component size. ++ * @dir metadata changes direction ++ * Returns: 0 on success, 1 otherwise. ++ * ++ * This function is solely used to change size of the volume. ++ * Setting size is not valid for container. ++ * Size is only change that can be rolled back, thus the @dir param. ++ */ ++static int reshape_super_size(struct supertype *st, char *devname, ++ unsigned long long size, change_dir_t direction, ++ struct context *c) ++{ ++ struct shape shape = {0}; ++ ++ shape.level = UnSet; ++ shape.layout = UnSet; ++ shape.delta_disks = UnSet; ++ shape.dev = devname; ++ shape.size = size; ++ shape.direction = direction; ++ ++ return reshape_super(st, &shape, c); ++} ++ ++/** ++ * reshape_super_non_size() - Reshape array, non size changes. ++ * ++ * @st: supertype. ++ * @devname: device name. ++ * @info: superblock info. ++ * Returns: 0 on success, 1 otherwise. ++ * ++ * This function is used for any external array changes but size. ++ * It handles both volumes and containers. ++ * For changes other than size, rollback is not possible. ++ */ ++static int reshape_super_non_size(struct supertype *st, char *devname, ++ struct mdinfo *info, struct context *c) ++{ ++ struct shape shape = {0}; ++ /* Size already set to zero, not updating size */ ++ shape.level = info->new_level; ++ shape.layout = info->new_layout; ++ shape.chunk = info->new_chunk; ++ shape.raiddisks = info->array.raid_disks; ++ shape.delta_disks = info->delta_disks; ++ shape.dev = devname; ++ /* Rollback not possible for non size changes */ ++ shape.direction = APPLY_METADATA_CHANGES; ++ ++ return reshape_super(st, &shape, c); + } + + static void sync_metadata(struct supertype *st) +@@ -1979,9 +2034,8 @@ int Grow_reshape(char *devname, int fd, + } + + /* ========= set size =============== */ +- if (s->size > 0 && +- (s->size == MAX_SIZE || s->size != (unsigned)array.size)) { +- unsigned long long orig_size = get_component_size(fd)/2; ++ if (s->size > 0 && (s->size == MAX_SIZE || s->size != (unsigned)array.size)) { ++ unsigned long long orig_size = get_component_size(fd) / 2; + unsigned long long min_csize; + struct mdinfo *mdi; + int raid0_takeover = 0; +@@ -2001,8 +2055,7 @@ int Grow_reshape(char *devname, int fd, + goto release; + } + +- if (reshape_super(st, s->size, UnSet, UnSet, 0, 0, UnSet, +- devname, APPLY_METADATA_CHANGES, c)) { ++ if (reshape_super_size(st, devname, s->size, APPLY_METADATA_CHANGES, c)) { + rv = 1; + goto release; + } +@@ -2120,8 +2173,8 @@ size_change_error: + int err = errno; + + /* restore metadata */ +- if (reshape_super(st, orig_size, UnSet, UnSet, 0, 0, UnSet, +- devname, ROLLBACK_METADATA_CHANGES, c) == 0) ++ if (reshape_super_size(st, devname, orig_size, ++ ROLLBACK_METADATA_CHANGES, c) == 0) + sync_metadata(st); + pr_err("Cannot set device size for %s: %s\n", + devname, strerror(err)); +@@ -2351,11 +2404,7 @@ size_change_error: + /* Impose these changes on a single array. First + * check that the metadata is OK with the change. + */ +- +- if (reshape_super(st, 0, info.new_level, +- info.new_layout, info.new_chunk, +- info.array.raid_disks, info.delta_disks, +- devname, APPLY_METADATA_CHANGES, c)) { ++ if (reshape_super_non_size(st, devname, &info, c)) { + rv = 1; + goto release; + } +@@ -3668,14 +3717,8 @@ int reshape_container(char *container, char *devname, + int rv = restart; + char last_devnm[32] = ""; + +- /* component_size is not meaningful for a container, +- * so pass '0' meaning 'no change' +- */ +- if (!restart && +- reshape_super(st, 0, info->new_level, +- info->new_layout, info->new_chunk, +- info->array.raid_disks, info->delta_disks, +- devname, APPLY_METADATA_CHANGES, c)) { ++ /* component_size is not meaningful for a container */ ++ if (!restart && reshape_super_non_size(st, devname, info, c)) { + unfreeze(st); + return 1; + } +diff --git a/mdadm.h b/mdadm.h +index 0ade4beb..2ff3e463 100644 +--- a/mdadm.h ++++ b/mdadm.h +@@ -594,6 +594,11 @@ enum flag_mode { + FlagDefault, FlagSet, FlagClear, + }; + ++typedef enum { ++ ROLLBACK_METADATA_CHANGES, ++ APPLY_METADATA_CHANGES ++} change_dir_t; ++ + /* structures read from config file */ + /* List of mddevice names and identifiers + * Identifiers can be: +@@ -667,7 +672,9 @@ struct context { + }; + + struct shape { ++ char *dev; + int raiddisks; ++ int delta_disks; + int sparedisks; + int journaldisks; + int level; +@@ -682,6 +689,7 @@ struct shape { + unsigned long long size; + unsigned long long data_offset; + int consistency_policy; ++ change_dir_t direction; + }; + + /* List of device names - wildcards expanded */ +@@ -1229,14 +1237,8 @@ extern struct superswitch { + * initialized to indicate if reshape is being performed at the + * container or subarray level + */ +-#define APPLY_METADATA_CHANGES 1 +-#define ROLLBACK_METADATA_CHANGES 0 +- +- int (*reshape_super)(struct supertype *st, +- unsigned long long size, int level, +- int layout, int chunksize, int raid_disks, +- int delta_disks, char *dev, int direction, +- struct context *c); ++ ++ int (*reshape_super)(struct supertype *st, struct shape *shape, struct context *c); + int (*manage_reshape)( /* optional */ + int afd, struct mdinfo *sra, struct reshape *reshape, + struct supertype *st, unsigned long blocks, +diff --git a/super-intel.c b/super-intel.c +index 417da267..1a8a7b12 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -12152,26 +12152,37 @@ exit: + return ret_val; + } + +-static int imsm_reshape_super(struct supertype *st, unsigned long long size, +- int level, int layout, int chunksize, int raid_disks, +- int delta_disks, char *dev, int direction, struct context *c) ++/** ++ * shape_to_geo() - fill geo_params from shape. ++ * ++ * @shape: array details. ++ * @geo: new geometry params. ++ * Returns: 0 on success, 1 otherwise. ++ */ ++static void shape_to_geo(struct shape *shape, struct geo_params *geo) ++{ ++ assert(shape); ++ assert(geo); ++ ++ geo->dev_name = shape->dev; ++ geo->size = shape->size; ++ geo->level = shape->level; ++ geo->layout = shape->layout; ++ geo->chunksize = shape->chunk; ++ geo->raid_disks = shape->raiddisks; ++} ++ ++static int imsm_reshape_super(struct supertype *st, struct shape *shape, struct context *c) + { + int ret_val = 1; +- struct geo_params geo; ++ struct geo_params geo = {0}; + + dprintf("(enter)\n"); + +- memset(&geo, 0, sizeof(struct geo_params)); +- +- geo.dev_name = dev; ++ shape_to_geo(shape, &geo); + strcpy(geo.devnm, st->devnm); +- geo.size = size; +- geo.level = level; +- geo.layout = layout; +- geo.chunksize = chunksize; +- geo.raid_disks = raid_disks; +- if (delta_disks != UnSet) +- geo.raid_disks += delta_disks; ++ if (shape->delta_disks != UnSet) ++ geo.raid_disks += shape->delta_disks; + + dprintf("for level : %i\n", geo.level); + dprintf("for raid_disks : %i\n", geo.raid_disks); +@@ -12182,7 +12193,7 @@ static int imsm_reshape_super(struct supertype *st, unsigned long long size, + int old_raid_disks = 0; + + if (imsm_reshape_is_allowed_on_container( +- st, &geo, &old_raid_disks, direction)) { ++ st, &geo, &old_raid_disks, shape->direction)) { + struct imsm_update_reshape *u = NULL; + int len; + +@@ -12236,7 +12247,7 @@ static int imsm_reshape_super(struct supertype *st, unsigned long long size, + goto exit_imsm_reshape_super; + } + super->current_vol = dev->index; +- change = imsm_analyze_change(st, &geo, direction); ++ change = imsm_analyze_change(st, &geo, shape->direction); + switch (change) { + case CH_TAKEOVER: + ret_val = imsm_takeover(st, &geo); +-- +2.41.0 + diff --git a/0054-imsm-add-support-for-literal-RAID-10.patch b/0054-imsm-add-support-for-literal-RAID-10.patch new file mode 100644 index 0000000..c90bf87 --- /dev/null +++ b/0054-imsm-add-support-for-literal-RAID-10.patch @@ -0,0 +1,184 @@ +From 27550b13297adbdefe42fe4eb785b7fde1c0ed91 Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:15 +0200 +Subject: [PATCH 54/69] imsm: add support for literal RAID 10 + +As for now, IMSM supports only 4 drive RAID 1+0. This patch is first in +series to add support for literal RAID 10 (with more than 4 drives) to +imsm. + +Allow setting RAID 10 as raid level for imsm arrays. + +Add update_imsm_raid_level() to handle raid level updates. Set RAID10 as +default level for imsm R0 to R10 migrations. Replace magic numbers with +defined values for RAID level checks/assigns. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + super-intel.c | 67 ++++++++++++++++++++++++++++++++++++--------------- + 1 file changed, 48 insertions(+), 19 deletions(-) + +diff --git a/super-intel.c b/super-intel.c +index 1a8a7b12..a7efc8df 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -166,7 +166,8 @@ struct imsm_map { + __u8 raid_level; + #define IMSM_T_RAID0 0 + #define IMSM_T_RAID1 1 +-#define IMSM_T_RAID5 5 /* since metadata version 1.2.02 ? */ ++#define IMSM_T_RAID5 5 ++#define IMSM_T_RAID10 10 + __u8 num_members; /* number of member disks */ + __u8 num_domains; /* number of parity domains */ + __u8 failed_disk_num; /* valid only when state is degraded */ +@@ -1259,14 +1260,42 @@ static int get_imsm_disk_slot(struct imsm_map *map, const unsigned int idx) + + return IMSM_STATUS_ERROR; + } ++/** ++ * update_imsm_raid_level() - update raid level appropriately in &imsm_map. ++ * @map: &imsm_map pointer. ++ * @new_level: MD style level. ++ * ++ * For backward compatibility reasons we need to differentiate RAID10. ++ * In the past IMSM RAID10 was presented as RAID1. ++ * Keep compatibility unless it is not explicitly updated by UEFI driver. ++ * ++ * Routine needs num_members to be set and (optionally) raid_level. ++ */ ++static void update_imsm_raid_level(struct imsm_map *map, int new_level) ++{ ++ if (new_level != IMSM_T_RAID10) { ++ map->raid_level = new_level; ++ return; ++ } ++ ++ if (map->num_members == 4) { ++ if (map->raid_level == IMSM_T_RAID10 || map->raid_level == IMSM_T_RAID1) ++ return; ++ ++ map->raid_level = IMSM_T_RAID1; ++ return; ++ } ++ ++ map->raid_level = IMSM_T_RAID10; ++} + + static int get_imsm_raid_level(struct imsm_map *map) + { +- if (map->raid_level == 1) { ++ if (map->raid_level == IMSM_T_RAID1) { + if (map->num_members == 2) +- return 1; ++ return IMSM_T_RAID1; + else +- return 10; ++ return IMSM_T_RAID10; + } + + return map->raid_level; +@@ -5678,7 +5707,7 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info, + set_pba_of_lba0(map, super->create_offset); + map->blocks_per_strip = __cpu_to_le16(info_to_blocks_per_strip(info)); + map->failed_disk_num = ~0; +- if (info->level > 0) ++ if (info->level > IMSM_T_RAID0) + map->map_state = (info->state ? IMSM_T_STATE_NORMAL + : IMSM_T_STATE_UNINITIALIZED); + else +@@ -5686,16 +5715,15 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info, + IMSM_T_STATE_NORMAL; + map->ddf = 1; + +- if (info->level == 1 && info->raid_disks > 2) { ++ if (info->level == IMSM_T_RAID1 && info->raid_disks > 2) { + free(dev); + free(dv); +- pr_err("imsm does not support more than 2 disksin a raid1 volume\n"); ++ pr_err("imsm does not support more than 2 disks in a raid1 volume\n"); + return 0; + } ++ map->num_members = info->raid_disks; + +- map->raid_level = info->level; +- if (info->level == 10) +- map->raid_level = 1; ++ update_imsm_raid_level(map, info->level); + set_num_domains(map); + + size_per_member += NUM_BLOCKS_DIRTY_STRIPE_REGION; +@@ -5703,7 +5731,6 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info, + size_per_member / + BLOCKS_PER_KB)); + +- map->num_members = info->raid_disks; + update_num_data_stripes(map, array_blocks); + for (i = 0; i < map->num_members; i++) { + /* initialized in add_to_super */ +@@ -8275,7 +8302,7 @@ static struct mdinfo *container_content_imsm(struct supertype *st, char *subarra + info_d->data_offset = pba_of_lba0(map); + info_d->component_size = calc_component_size(map, dev); + +- if (map->raid_level == 5) { ++ if (map->raid_level == IMSM_T_RAID5) { + info_d->ppl_sector = this->ppl_sector; + info_d->ppl_size = this->ppl_size; + if (this->consistency_policy == CONSISTENCY_POLICY_PPL && +@@ -9533,7 +9560,7 @@ static int apply_reshape_migration_update(struct imsm_update_reshape_migration * + } + + to_state = map->map_state; +- if ((u->new_level == 5) && (map->raid_level == 0)) { ++ if ((u->new_level == IMSM_T_RAID5) && (map->raid_level == IMSM_T_RAID0)) { + map->num_members++; + /* this should not happen */ + if (u->new_disks[0] < 0) { +@@ -9544,11 +9571,13 @@ static int apply_reshape_migration_update(struct imsm_update_reshape_migration * + to_state = IMSM_T_STATE_NORMAL; + } + migrate(new_dev, super, to_state, MIGR_GEN_MIGR); ++ + if (u->new_level > -1) +- map->raid_level = u->new_level; ++ update_imsm_raid_level(map, u->new_level); ++ + migr_map = get_imsm_map(new_dev, MAP_1); +- if ((u->new_level == 5) && +- (migr_map->raid_level == 0)) { ++ if ((u->new_level == IMSM_T_RAID5) && ++ (migr_map->raid_level == IMSM_T_RAID0)) { + int ord = map->num_members - 1; + migr_map->num_members--; + if (u->new_disks[0] < 0) +@@ -9584,7 +9613,7 @@ static int apply_reshape_migration_update(struct imsm_update_reshape_migration * + + /* add disk + */ +- if (u->new_level != 5 || migr_map->raid_level != 0 || ++ if (u->new_level != IMSM_T_RAID5 || migr_map->raid_level != IMSM_T_RAID0 || + migr_map->raid_level == map->raid_level) + goto skip_disk_add; + +@@ -9963,7 +9992,7 @@ static int apply_takeover_update(struct imsm_update_takeover *u, + /* update map */ + map->num_members /= map->num_domains; + map->map_state = IMSM_T_STATE_NORMAL; +- map->raid_level = 0; ++ update_imsm_raid_level(map, IMSM_T_RAID0); + set_num_domains(map); + update_num_data_stripes(map, imsm_dev_size(dev)); + map->failed_disk_num = -1; +@@ -10007,7 +10036,7 @@ static int apply_takeover_update(struct imsm_update_takeover *u, + map = get_imsm_map(dev_new, MAP_0); + + map->map_state = IMSM_T_STATE_DEGRADED; +- map->raid_level = 1; ++ update_imsm_raid_level(map, IMSM_T_RAID10); + set_num_domains(map); + map->num_members = map->num_members * map->num_domains; + update_num_data_stripes(map, imsm_dev_size(dev)); +-- +2.41.0 + diff --git a/0055-imsm-refactor-RAID-level-handling.patch b/0055-imsm-refactor-RAID-level-handling.patch new file mode 100644 index 0000000..2e855b2 --- /dev/null +++ b/0055-imsm-refactor-RAID-level-handling.patch @@ -0,0 +1,345 @@ +From 191e6ddb1388236c5c54baf5020a87c996be941f Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:16 +0200 +Subject: [PATCH 55/69] imsm: refactor RAID level handling + +Add imsm_level_ops struct for better handling and unifying raid level +support. Add helper methods and move "orom_has_raid[...]" methods from +header to source file. + +RAID 1e is not supported under Linux, remove RAID 1e associated code. + +Refactor imsm_analyze_change() and is_raid_level_supported(). +Remove hardcoded check for 4 drives and make devNumChange a multiplier +for RAID 10. + +Refactor printing supported raid levels. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + platform-intel.c | 57 ++++++++++++++++++++++++ + platform-intel.h | 32 ++++++-------- + super-intel.c | 111 ++++++++++++++++++++++++++++------------------- + 3 files changed, 138 insertions(+), 62 deletions(-) + +diff --git a/platform-intel.c b/platform-intel.c +index ac282bc5..40e8fb82 100644 +--- a/platform-intel.c ++++ b/platform-intel.c +@@ -32,6 +32,63 @@ + + #define NVME_SUBSYS_PATH "/sys/devices/virtual/nvme-subsystem/" + ++static bool imsm_orom_has_raid0(const struct imsm_orom *orom) ++{ ++ return imsm_rlc_has_bit(orom, IMSM_OROM_RLC_RAID0); ++} ++ ++static bool imsm_orom_has_raid1(const struct imsm_orom *orom) ++{ ++ return imsm_rlc_has_bit(orom, IMSM_OROM_RLC_RAID1); ++} ++ ++static bool imsm_orom_has_raid10(const struct imsm_orom *orom) ++{ ++ return imsm_rlc_has_bit(orom, IMSM_OROM_RLC_RAID10); ++} ++ ++static bool imsm_orom_has_raid5(const struct imsm_orom *orom) ++{ ++ return imsm_rlc_has_bit(orom, IMSM_OROM_RLC_RAID5); ++} ++ ++/* IMSM platforms do not define how many disks are allowed for each level, ++ * but there are some global limitations we need to follow. ++ */ ++static bool imsm_orom_support_raid_disks_count_raid0(const int raid_disks) ++{ ++ return true; ++} ++ ++static bool imsm_orom_support_raid_disks_count_raid1(const int raid_disks) ++{ ++ if (raid_disks == 2) ++ return true; ++ return false; ++} ++ ++static bool imsm_orom_support_raid_disks_count_raid5(const int raid_disks) ++{ ++ if (raid_disks > 2) ++ return true; ++ return false; ++} ++ ++static bool imsm_orom_support_raid_disks_count_raid10(const int raid_disks) ++{ ++ if (raid_disks == 4) ++ return true; ++ return false; ++} ++ ++struct imsm_level_ops imsm_level_ops[] = { ++ {0, imsm_orom_has_raid0, imsm_orom_support_raid_disks_count_raid0, "raid0"}, ++ {1, imsm_orom_has_raid1, imsm_orom_support_raid_disks_count_raid1, "raid1"}, ++ {5, imsm_orom_has_raid5, imsm_orom_support_raid_disks_count_raid5, "raid5"}, ++ {10, imsm_orom_has_raid10, imsm_orom_support_raid_disks_count_raid10, "raid10"}, ++ {-1, NULL, NULL, NULL} ++}; ++ + static int devpath_to_ll(const char *dev_path, const char *entry, + unsigned long long *val); + +diff --git a/platform-intel.h b/platform-intel.h +index 3c2bc595..dcc5aaa7 100644 +--- a/platform-intel.h ++++ b/platform-intel.h +@@ -109,25 +109,21 @@ struct imsm_orom { + #define IMSM_OROM_CAPABILITIES_TPV (1 << 10) + } __attribute__((packed)); + +-static inline int imsm_orom_has_raid0(const struct imsm_orom *orom) +-{ +- return !!(orom->rlc & IMSM_OROM_RLC_RAID0); +-} +-static inline int imsm_orom_has_raid1(const struct imsm_orom *orom) +-{ +- return !!(orom->rlc & IMSM_OROM_RLC_RAID1); +-} +-static inline int imsm_orom_has_raid1e(const struct imsm_orom *orom) +-{ +- return !!(orom->rlc & IMSM_OROM_RLC_RAID1E); +-} +-static inline int imsm_orom_has_raid10(const struct imsm_orom *orom) +-{ +- return !!(orom->rlc & IMSM_OROM_RLC_RAID10); +-} +-static inline int imsm_orom_has_raid5(const struct imsm_orom *orom) ++/* IMSM metadata requirements for each level */ ++struct imsm_level_ops { ++ int level; ++ bool (*is_level_supported)(const struct imsm_orom *); ++ bool (*is_raiddisks_count_supported)(const int); ++ char *name; ++}; ++ ++extern struct imsm_level_ops imsm_level_ops[]; ++ ++static inline bool imsm_rlc_has_bit(const struct imsm_orom *orom, const unsigned short bit) + { +- return !!(orom->rlc & IMSM_OROM_RLC_RAID5); ++ if (orom->rlc & bit) ++ return true; ++ return false; + } + + /** +diff --git a/super-intel.c b/super-intel.c +index a7efc8df..da17265d 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -2681,6 +2681,15 @@ static int ahci_get_port_count(const char *hba_path, int *port_count) + return host_base; + } + ++static void print_imsm_level_capability(const struct imsm_orom *orom) ++{ ++ int idx; ++ ++ for (idx = 0; imsm_level_ops[idx].name; idx++) ++ if (imsm_level_ops[idx].is_level_supported(orom)) ++ printf("%s ", imsm_level_ops[idx].name); ++} ++ + static void print_imsm_capability(const struct imsm_orom *orom) + { + printf(" Platform : Intel(R) "); +@@ -2699,12 +2708,11 @@ static void print_imsm_capability(const struct imsm_orom *orom) + printf(" Version : %d.%d.%d.%d\n", orom->major_ver, + orom->minor_ver, orom->hotfix_ver, orom->build); + } +- printf(" RAID Levels :%s%s%s%s%s\n", +- imsm_orom_has_raid0(orom) ? " raid0" : "", +- imsm_orom_has_raid1(orom) ? " raid1" : "", +- imsm_orom_has_raid1e(orom) ? " raid1e" : "", +- imsm_orom_has_raid10(orom) ? " raid10" : "", +- imsm_orom_has_raid5(orom) ? " raid5" : ""); ++ ++ printf(" RAID Levels : "); ++ print_imsm_level_capability(orom); ++ printf("\n"); ++ + printf(" Chunk Sizes :%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", + imsm_orom_has_chunk(orom, 2) ? " 2k" : "", + imsm_orom_has_chunk(orom, 4) ? " 4k" : "", +@@ -2739,12 +2747,11 @@ static void print_imsm_capability_export(const struct imsm_orom *orom) + if (orom->major_ver || orom->minor_ver || orom->hotfix_ver || orom->build) + printf("IMSM_VERSION=%d.%d.%d.%d\n", orom->major_ver, orom->minor_ver, + orom->hotfix_ver, orom->build); +- printf("IMSM_SUPPORTED_RAID_LEVELS=%s%s%s%s%s\n", +- imsm_orom_has_raid0(orom) ? "raid0 " : "", +- imsm_orom_has_raid1(orom) ? "raid1 " : "", +- imsm_orom_has_raid1e(orom) ? "raid1e " : "", +- imsm_orom_has_raid5(orom) ? "raid10 " : "", +- imsm_orom_has_raid10(orom) ? "raid5 " : ""); ++ ++ printf("IMSM_SUPPORTED_RAID_LEVELS="); ++ print_imsm_level_capability(orom); ++ printf("\n"); ++ + printf("IMSM_SUPPORTED_CHUNK_SIZES=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", + imsm_orom_has_chunk(orom, 2) ? "2k " : "", + imsm_orom_has_chunk(orom, 4) ? "4k " : "", +@@ -6992,26 +6999,41 @@ static unsigned long long merge_extents(struct intel_super *super, const bool ex + return free_size - reservation_size; + } + +-static int is_raid_level_supported(const struct imsm_orom *orom, int level, int raiddisks) ++/** ++ * is_raid_level_supported() - check if this count of drives and level is supported by platform. ++ * @orom: hardware properties, could be NULL. ++ * @level: requested raid level. ++ * @raiddisks: requested disk count. ++ * ++ * IMSM UEFI/OROM does not provide information about supported count of raid disks ++ * for particular level. That is why it is hardcoded. ++ * It is recommended to not allow of usage other levels than supported, ++ * IMSM code is not tested against different level implementations. ++ * ++ * Return: true if supported, false otherwise. ++ */ ++static bool is_raid_level_supported(const struct imsm_orom *orom, int level, int raiddisks) + { +- if (level < 0 || level == 6 || level == 4) +- return 0; ++ int idx; + +- /* if we have an orom prevent invalid raid levels */ +- if (orom) +- switch (level) { +- case 0: return imsm_orom_has_raid0(orom); +- case 1: +- if (raiddisks > 2) +- return imsm_orom_has_raid1e(orom); +- return imsm_orom_has_raid1(orom) && raiddisks == 2; +- case 10: return imsm_orom_has_raid10(orom) && raiddisks == 4; +- case 5: return imsm_orom_has_raid5(orom) && raiddisks > 2; +- } +- else +- return 1; /* not on an Intel RAID platform so anything goes */ ++ for (idx = 0; imsm_level_ops[idx].name; idx++) { ++ if (imsm_level_ops[idx].level == level) ++ break; ++ } + +- return 0; ++ if (!imsm_level_ops[idx].name) ++ return false; ++ ++ if (!imsm_level_ops[idx].is_raiddisks_count_supported(raiddisks)) ++ return false; ++ ++ if (!orom) ++ return true; ++ ++ if (imsm_level_ops[idx].is_level_supported(orom)) ++ return true; ++ ++ return false; + } + + static int +@@ -11962,18 +11984,17 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, + int change = -1; + int check_devs = 0; + int chunk; +- /* number of added/removed disks in operation result */ +- int devNumChange = 0; + /* imsm compatible layout value for array geometry verification */ + int imsm_layout = -1; ++ int raid_disks = geo->raid_disks; + imsm_status_t rv; + + getinfo_super_imsm_volume(st, &info, NULL); +- if (geo->level != info.array.level && geo->level >= 0 && ++ if (geo->level != info.array.level && geo->level >= IMSM_T_RAID0 && + geo->level != UnSet) { + switch (info.array.level) { +- case 0: +- if (geo->level == 5) { ++ case IMSM_T_RAID0: ++ if (geo->level == IMSM_T_RAID5) { + change = CH_MIGRATION; + if (geo->layout != ALGORITHM_LEFT_ASYMMETRIC) { + pr_err("Error. Requested Layout not supported (left-asymmetric layout is supported only)!\n"); +@@ -11982,20 +12003,20 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, + } + imsm_layout = geo->layout; + check_devs = 1; +- devNumChange = 1; /* parity disk added */ +- } else if (geo->level == 10) { ++ raid_disks += 1; /* parity disk added */ ++ } else if (geo->level == IMSM_T_RAID10) { + change = CH_TAKEOVER; + check_devs = 1; +- devNumChange = 2; /* two mirrors added */ ++ raid_disks *= 2; /* mirrors added */ + imsm_layout = 0x102; /* imsm supported layout */ + } + break; +- case 1: +- case 10: ++ case IMSM_T_RAID1: ++ case IMSM_T_RAID10: + if (geo->level == 0) { + change = CH_TAKEOVER; + check_devs = 1; +- devNumChange = -(geo->raid_disks/2); ++ raid_disks /= 2; + imsm_layout = 0; /* imsm raid0 layout */ + } + break; +@@ -12011,10 +12032,10 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, + if (geo->layout != info.array.layout && + (geo->layout != UnSet && geo->layout != -1)) { + change = CH_MIGRATION; +- if (info.array.layout == 0 && info.array.level == 5 && ++ if (info.array.layout == 0 && info.array.level == IMSM_T_RAID5 && + geo->layout == 5) { + /* reshape 5 -> 4 */ +- } else if (info.array.layout == 5 && info.array.level == 5 && ++ } else if (info.array.layout == 5 && info.array.level == IMSM_T_RAID5 && + geo->layout == 0) { + /* reshape 4 -> 5 */ + geo->layout = 0; +@@ -12033,7 +12054,7 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, + + if (geo->chunksize > 0 && geo->chunksize != UnSet && + geo->chunksize != info.array.chunk_size) { +- if (info.array.level == 10) { ++ if (info.array.level == IMSM_T_RAID10) { + pr_err("Error. Chunk size change for RAID 10 is not supported.\n"); + change = -1; + goto analyse_change_exit; +@@ -12058,14 +12079,16 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, + rv = imsm_analyze_expand(st, geo, &info, direction); + if (rv != IMSM_STATUS_OK) + goto analyse_change_exit; ++ raid_disks = geo->raid_disks; + change = CH_ARRAY_SIZE; + } + + chunk = geo->chunksize / 1024; ++ + if (!validate_geometry_imsm(st, + geo->level, + imsm_layout, +- geo->raid_disks + devNumChange, ++ raid_disks, + &chunk, + geo->size, INVALID_SECTORS, + 0, 0, info.consistency_policy, 1)) +-- +2.41.0 + diff --git a/0056-imsm-bump-minimal-version.patch b/0056-imsm-bump-minimal-version.patch new file mode 100644 index 0000000..5ce8ed6 --- /dev/null +++ b/0056-imsm-bump-minimal-version.patch @@ -0,0 +1,180 @@ +From ec7e873ba6643a9e5e74311b00ede66a3d2e36c9 Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:17 +0200 +Subject: [PATCH 56/69] imsm: bump minimal version + +IMSM version 1.3 (called ATTRIBS) brought attributes used to define array +properties which require support in driver. The goal of this change was +to avoid changing version when adding new features. + +For some reasons migration has never been completed and currently (after +10 years of implementing) IMSM can use older versions. + +It is right time to finally switch it. There is no point in using old +versions, use 1.3.00 as minimal one. + +Define JD_VERSION used by Windows driver. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + super-intel.c | 87 ++++++++++++++++++++++----------------------------- + 1 file changed, 38 insertions(+), 49 deletions(-) + +diff --git a/super-intel.c b/super-intel.c +index da17265d..4b168add 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -32,14 +32,19 @@ + /* MPB == Metadata Parameter Block */ + #define MPB_SIGNATURE "Intel Raid ISM Cfg Sig. " + #define MPB_SIG_LEN (strlen(MPB_SIGNATURE)) +-#define MPB_VERSION_RAID0 "1.0.00" +-#define MPB_VERSION_RAID1 "1.1.00" +-#define MPB_VERSION_MANY_VOLUMES_PER_ARRAY "1.2.00" +-#define MPB_VERSION_3OR4_DISK_ARRAY "1.2.01" +-#define MPB_VERSION_RAID5 "1.2.02" +-#define MPB_VERSION_5OR6_DISK_ARRAY "1.2.04" +-#define MPB_VERSION_CNG "1.2.06" ++ ++/* Legacy IMSM versions: ++ * MPB_VERSION_RAID0 1.0.00 ++ * MPB_VERSION_RAID1 1.1.00 ++ * MPB_VERSION_MANY_VOLUMES_PER_ARRAY 1.2.00 ++ * MPB_VERSION_3OR4_DISK_ARRAY 1.2.01 ++ * MPB_VERSION_RAID5 1.2.02 ++ * MPB_VERSION_5OR6_DISK_ARRAY 1.2.04 ++ * MPB_VERSION_CNG 1.2.06 ++ */ ++ + #define MPB_VERSION_ATTRIBS "1.3.00" ++#define MPB_VERSION_ATTRIBS_JD "2.0.00" + #define MAX_SIGNATURE_LENGTH 32 + #define MAX_RAID_SERIAL_LEN 16 + +@@ -5512,51 +5517,46 @@ static unsigned long long info_to_blocks_per_member(mdu_array_info_t *info, + return (size * 2) & ~(info_to_blocks_per_strip(info) - 1); + } + ++static void imsm_write_signature(struct imsm_super *mpb) ++{ ++ /* It is safer to eventually truncate version rather than left it not NULL ended */ ++ snprintf((char *) mpb->sig, MAX_SIGNATURE_LENGTH, MPB_SIGNATURE MPB_VERSION_ATTRIBS); ++} ++ + static void imsm_update_version_info(struct intel_super *super) + { + /* update the version and attributes */ + struct imsm_super *mpb = super->anchor; +- char *version; + struct imsm_dev *dev; + struct imsm_map *map; + int i; + ++ mpb->attributes |= MPB_ATTRIB_CHECKSUM_VERIFY; ++ + for (i = 0; i < mpb->num_raid_devs; i++) { + dev = get_imsm_dev(super, i); + map = get_imsm_map(dev, MAP_0); ++ + if (__le32_to_cpu(dev->size_high) > 0) + mpb->attributes |= MPB_ATTRIB_2TB; + +- /* FIXME detect when an array spans a port multiplier */ +- #if 0 +- mpb->attributes |= MPB_ATTRIB_PM; +- #endif +- +- if (mpb->num_raid_devs > 1 || +- mpb->attributes != MPB_ATTRIB_CHECKSUM_VERIFY) { +- version = MPB_VERSION_ATTRIBS; +- switch (get_imsm_raid_level(map)) { +- case 0: mpb->attributes |= MPB_ATTRIB_RAID0; break; +- case 1: mpb->attributes |= MPB_ATTRIB_RAID1; break; +- case 10: mpb->attributes |= MPB_ATTRIB_RAID10; break; +- case 5: mpb->attributes |= MPB_ATTRIB_RAID5; break; +- } +- } else { +- if (map->num_members >= 5) +- version = MPB_VERSION_5OR6_DISK_ARRAY; +- else if (dev->status == DEV_CLONE_N_GO) +- version = MPB_VERSION_CNG; +- else if (get_imsm_raid_level(map) == 5) +- version = MPB_VERSION_RAID5; +- else if (map->num_members >= 3) +- version = MPB_VERSION_3OR4_DISK_ARRAY; +- else if (get_imsm_raid_level(map) == 1) +- version = MPB_VERSION_RAID1; +- else +- version = MPB_VERSION_RAID0; ++ switch (get_imsm_raid_level(map)) { ++ case IMSM_T_RAID0: ++ mpb->attributes |= MPB_ATTRIB_RAID0; ++ break; ++ case IMSM_T_RAID1: ++ mpb->attributes |= MPB_ATTRIB_RAID1; ++ break; ++ case IMSM_T_RAID5: ++ mpb->attributes |= MPB_ATTRIB_RAID5; ++ break; ++ case IMSM_T_RAID10: ++ mpb->attributes |= MPB_ATTRIB_RAID10; ++ break; + } +- strcpy(((char *) mpb->sig) + strlen(MPB_SIGNATURE), version); + } ++ ++ imsm_write_signature(mpb); + } + + /** +@@ -5785,7 +5785,6 @@ static int init_super_imsm(struct supertype *st, mdu_array_info_t *info, + struct intel_super *super; + struct imsm_super *mpb; + size_t mpb_size; +- char *version; + + if (data_offset != INVALID_SECTORS) { + pr_err("data-offset not supported by imsm\n"); +@@ -5828,13 +5827,7 @@ static int init_super_imsm(struct supertype *st, mdu_array_info_t *info, + return 0; + } + +- mpb->attributes = MPB_ATTRIB_CHECKSUM_VERIFY; +- +- version = (char *) mpb->sig; +- strcpy(version, MPB_SIGNATURE); +- version += strlen(MPB_SIGNATURE); +- strcpy(version, MPB_VERSION_RAID0); +- ++ imsm_update_version_info(super); + return 1; + } + +@@ -6208,7 +6201,6 @@ static union { + + static int write_super_imsm_spare(struct intel_super *super, struct dl *d) + { +- struct imsm_super *mpb = super->anchor; + struct imsm_super *spare = &spare_record.anchor; + __u32 sum; + +@@ -6217,14 +6209,11 @@ static int write_super_imsm_spare(struct intel_super *super, struct dl *d) + + spare->mpb_size = __cpu_to_le32(sizeof(struct imsm_super)); + spare->generation_num = __cpu_to_le32(1UL); +- spare->attributes = MPB_ATTRIB_CHECKSUM_VERIFY; + spare->num_disks = 1; + spare->num_raid_devs = 0; +- spare->cache_size = mpb->cache_size; + spare->pwr_cycle_count = __cpu_to_le32(1); + +- snprintf((char *) spare->sig, MAX_SIGNATURE_LENGTH, +- MPB_SIGNATURE MPB_VERSION_RAID0); ++ imsm_write_signature(spare); + + spare->disk[0] = d->disk; + if (__le32_to_cpu(d->disk.total_blocks_hi) > 0) +-- +2.41.0 + diff --git a/0057-imsm-define-RAID_10-attribute.patch b/0057-imsm-define-RAID_10-attribute.patch new file mode 100644 index 0000000..fc6f152 --- /dev/null +++ b/0057-imsm-define-RAID_10-attribute.patch @@ -0,0 +1,67 @@ +From 610fc2ee6fc09e828b14e8fa221b3f4f70fc7b2b Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:18 +0200 +Subject: [PATCH 57/69] imsm: define RAID_10 attribute + +Add MPB_ATTRIB_RAID10_EXT attribute to support RAID 10 +with more than 4 drives. + +Allow more than 4 drives in imsm_orom_support_raid_disks_raid10(). + +This is one of last patches for introducing R10D4+ to imsm. +Only small adjustments in reshape behaviours are needed. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + platform-intel.c | 3 ++- + super-intel.c | 5 +++++ + 2 files changed, 7 insertions(+), 1 deletion(-) + +diff --git a/platform-intel.c b/platform-intel.c +index 40e8fb82..15a9fa5a 100644 +--- a/platform-intel.c ++++ b/platform-intel.c +@@ -76,7 +76,8 @@ static bool imsm_orom_support_raid_disks_count_raid5(const int raid_disks) + + static bool imsm_orom_support_raid_disks_count_raid10(const int raid_disks) + { +- if (raid_disks == 4) ++ /* raid_disks count must be higher than 4 and even */ ++ if (raid_disks >= 4 && (raid_disks & 1) == 0) + return true; + return false; + } +diff --git a/super-intel.c b/super-intel.c +index 4b168add..2d309316 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -62,6 +62,8 @@ + #define MPB_ATTRIB_RAIDCNG __cpu_to_le32(0x00000020) + /* supports expanded stripe sizes of 256K, 512K and 1MB */ + #define MPB_ATTRIB_EXP_STRIPE_SIZE __cpu_to_le32(0x00000040) ++/* supports RAID10 with more than 4 drives */ ++#define MPB_ATTRIB_RAID10_EXT __cpu_to_le32(0x00000080) + + /* The OROM Support RST Caching of Volumes */ + #define MPB_ATTRIB_NVM __cpu_to_le32(0x02000000) +@@ -89,6 +91,7 @@ + MPB_ATTRIB_RAID10 | \ + MPB_ATTRIB_RAID5 | \ + MPB_ATTRIB_EXP_STRIPE_SIZE | \ ++ MPB_ATTRIB_RAID10_EXT | \ + MPB_ATTRIB_BBM) + + /* Define attributes that are unused but not harmful */ +@@ -5552,6 +5555,8 @@ static void imsm_update_version_info(struct intel_super *super) + break; + case IMSM_T_RAID10: + mpb->attributes |= MPB_ATTRIB_RAID10; ++ if (map->num_members > 4) ++ mpb->attributes |= MPB_ATTRIB_RAID10_EXT; + break; + } + } +-- +2.41.0 + diff --git a/0058-imsm-simplify-imsm_check_attributes.patch b/0058-imsm-simplify-imsm_check_attributes.patch new file mode 100644 index 0000000..e822557 --- /dev/null +++ b/0058-imsm-simplify-imsm_check_attributes.patch @@ -0,0 +1,153 @@ +From e0e56f4b2ed514f5049eb96b4ff8f7fdf30a4c49 Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:19 +0200 +Subject: [PATCH 58/69] imsm: simplify imsm_check_attributes() + +imsm_check_attributes() is too complex for that it really does. + +Remove repeating code and simplify the function. +Fix function calls. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + super-intel.c | 106 ++++++++------------------------------------------ + 1 file changed, 16 insertions(+), 90 deletions(-) + +diff --git a/super-intel.c b/super-intel.c +index 2d309316..d60915e8 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -2135,91 +2135,18 @@ void convert_from_4k(struct intel_super *super) + mpb->check_sum = __gen_imsm_checksum(mpb); + } + +-/******************************************************************************* +- * function: imsm_check_attributes +- * Description: Function checks if features represented by attributes flags +- * are supported by mdadm. +- * Parameters: +- * attributes - Attributes read from metadata +- * Returns: +- * 0 - passed attributes contains unsupported features flags +- * 1 - all features are supported +- ******************************************************************************/ +-static int imsm_check_attributes(__u32 attributes) ++/** ++ * imsm_check_attributes() - Check if features represented by attributes flags are supported. ++ * ++ * @attributes: attributes read from metadata. ++ * Returns: true if all features are supported, false otherwise. ++ */ ++static bool imsm_check_attributes(__u32 attributes) + { +- int ret_val = 1; +- __u32 not_supported = MPB_ATTRIB_SUPPORTED^0xffffffff; +- +- not_supported &= ~MPB_ATTRIB_IGNORED; +- +- not_supported &= attributes; +- if (not_supported) { +- pr_err("(IMSM): Unsupported attributes : %x\n", +- (unsigned)__le32_to_cpu(not_supported)); +- if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) { +- dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY \n"); +- not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY; +- } +- if (not_supported & MPB_ATTRIB_2TB) { +- dprintf("\t\tMPB_ATTRIB_2TB\n"); +- not_supported ^= MPB_ATTRIB_2TB; +- } +- if (not_supported & MPB_ATTRIB_RAID0) { +- dprintf("\t\tMPB_ATTRIB_RAID0\n"); +- not_supported ^= MPB_ATTRIB_RAID0; +- } +- if (not_supported & MPB_ATTRIB_RAID1) { +- dprintf("\t\tMPB_ATTRIB_RAID1\n"); +- not_supported ^= MPB_ATTRIB_RAID1; +- } +- if (not_supported & MPB_ATTRIB_RAID10) { +- dprintf("\t\tMPB_ATTRIB_RAID10\n"); +- not_supported ^= MPB_ATTRIB_RAID10; +- } +- if (not_supported & MPB_ATTRIB_RAID1E) { +- dprintf("\t\tMPB_ATTRIB_RAID1E\n"); +- not_supported ^= MPB_ATTRIB_RAID1E; +- } +- if (not_supported & MPB_ATTRIB_RAID5) { +- dprintf("\t\tMPB_ATTRIB_RAID5\n"); +- not_supported ^= MPB_ATTRIB_RAID5; +- } +- if (not_supported & MPB_ATTRIB_RAIDCNG) { +- dprintf("\t\tMPB_ATTRIB_RAIDCNG\n"); +- not_supported ^= MPB_ATTRIB_RAIDCNG; +- } +- if (not_supported & MPB_ATTRIB_BBM) { +- dprintf("\t\tMPB_ATTRIB_BBM\n"); +- not_supported ^= MPB_ATTRIB_BBM; +- } +- if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) { +- dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY (== MPB_ATTRIB_LEGACY)\n"); +- not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY; +- } +- if (not_supported & MPB_ATTRIB_EXP_STRIPE_SIZE) { +- dprintf("\t\tMPB_ATTRIB_EXP_STRIP_SIZE\n"); +- not_supported ^= MPB_ATTRIB_EXP_STRIPE_SIZE; +- } +- if (not_supported & MPB_ATTRIB_2TB_DISK) { +- dprintf("\t\tMPB_ATTRIB_2TB_DISK\n"); +- not_supported ^= MPB_ATTRIB_2TB_DISK; +- } +- if (not_supported & MPB_ATTRIB_NEVER_USE2) { +- dprintf("\t\tMPB_ATTRIB_NEVER_USE2\n"); +- not_supported ^= MPB_ATTRIB_NEVER_USE2; +- } +- if (not_supported & MPB_ATTRIB_NEVER_USE) { +- dprintf("\t\tMPB_ATTRIB_NEVER_USE\n"); +- not_supported ^= MPB_ATTRIB_NEVER_USE; +- } +- +- if (not_supported) +- dprintf("(IMSM): Unknown attributes : %x\n", not_supported); +- +- ret_val = 0; +- } ++ if ((attributes & (MPB_ATTRIB_SUPPORTED | MPB_ATTRIB_IGNORED)) == attributes) ++ return true; + +- return ret_val; ++ return false; + } + + static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map); +@@ -2247,11 +2174,10 @@ static void examine_super_imsm(struct supertype *st, char *homehost) + creation_time = __le64_to_cpu(mpb->creation_time); + printf(" Creation Time : %.24s\n", + creation_time ? ctime(&creation_time) : "Unknown"); +- printf(" Attributes : "); +- if (imsm_check_attributes(mpb->attributes)) +- printf("All supported\n"); +- else +- printf("not supported\n"); ++ ++ printf(" Attributes : %08x (%s)\n", mpb->attributes, ++ imsm_check_attributes(mpb->attributes) ? "supported" : "not supported"); ++ + getinfo_super_imsm(st, &info, NULL); + fname_from_uuid(&info, nbuf); + printf(" UUID : %s\n", nbuf + 5); +@@ -8182,9 +8108,9 @@ static struct mdinfo *container_content_imsm(struct supertype *st, char *subarra + int current_vol = super->current_vol; + + /* do not assemble arrays when not all attributes are supported */ +- if (imsm_check_attributes(mpb->attributes) == 0) { ++ if (imsm_check_attributes(mpb->attributes) == false) { + sb_errors = 1; +- pr_err("Unsupported attributes in IMSM metadata.Arrays activation is blocked.\n"); ++ pr_err("Unsupported attributes in IMSM metadata. Arrays activation is blocked.\n"); + } + + /* count spare devices, not used in maps +-- +2.41.0 + diff --git a/0059-imsm-support-RAID-10-with-more-than-4-drives.patch b/0059-imsm-support-RAID-10-with-more-than-4-drives.patch new file mode 100644 index 0000000..1a5e642 --- /dev/null +++ b/0059-imsm-support-RAID-10-with-more-than-4-drives.patch @@ -0,0 +1,168 @@ +From 44463edeb303a464c4a44fcea184b267aeb53302 Mon Sep 17 00:00:00 2001 +From: Mateusz Kusiak +Date: Mon, 29 Apr 2024 15:07:20 +0200 +Subject: [PATCH 59/69] imsm: support RAID 10 with more than 4 drives + +VROC UEFI driver does not support RAID 10 with more than 4 drives. +Add user prompts if such layout is being created and for R0->R10 +reshapes. + +Refactor ask() function: +- simplify the code, +- remove dialog reattempts, +- do no pass '?' sign on function calls, +- highlight default option on output. + +This patch completes adding support for R10D4+ to IMSM. + +Signed-off-by: Mateusz Kusiak +Signed-off-by: Mariusz Tkaczyk +--- + Create.c | 9 ++++++++- + super-intel.c | 14 ++++++++++++-- + util.c | 39 +++++++++++++++++++++++++-------------- + 3 files changed, 45 insertions(+), 17 deletions(-) + +diff --git a/Create.c b/Create.c +index d94253b1..d033eb68 100644 +--- a/Create.c ++++ b/Create.c +@@ -965,6 +965,13 @@ int Create(struct supertype *st, struct mddev_ident *ident, int subdevs, + return 1; + } + ++ if (st->ss == &super_imsm && s->level == 10 && s->raiddisks > 4) { ++ /* Print no matter runstop was specifed */ ++ pr_err("Warning! VROC UEFI driver does not support RAID10 in requested layout.\n"); ++ pr_err("Array won't be suitable as boot device.\n"); ++ warn = 1; ++ } ++ + if (!have_container && s->level > 0 && ((maxsize-s->size)*100 > maxsize)) { + if (c->runstop != 1 || c->verbose >= 0) + pr_err("largest drive (%s) exceeds size (%lluK) by more than 1%%\n", +@@ -984,7 +991,7 @@ int Create(struct supertype *st, struct mddev_ident *ident, int subdevs, + + if (warn) { + if (c->runstop!= 1) { +- if (!ask("Continue creating array? ")) { ++ if (!ask("Continue creating array")) { + pr_err("create aborted.\n"); + return 1; + } +diff --git a/super-intel.c b/super-intel.c +index d60915e8..2b8b6fda 100644 +--- a/super-intel.c ++++ b/super-intel.c +@@ -523,6 +523,7 @@ enum imsm_reshape_type { + CH_TAKEOVER, + CH_MIGRATION, + CH_ARRAY_SIZE, ++ CH_ABORT + }; + + /* definition of messages passed to imsm_process_update */ +@@ -11898,7 +11899,7 @@ success: + ****************************************************************************/ + enum imsm_reshape_type imsm_analyze_change(struct supertype *st, + struct geo_params *geo, +- int direction) ++ int direction, struct context *c) + { + struct mdinfo info; + int change = -1; +@@ -11925,6 +11926,14 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, + check_devs = 1; + raid_disks += 1; /* parity disk added */ + } else if (geo->level == IMSM_T_RAID10) { ++ if (geo->level == IMSM_T_RAID10 && geo->raid_disks > 2 && ++ !c->force) { ++ pr_err("Warning! VROC UEFI driver does not support RAID10 in requested layout.\n"); ++ pr_err("Array won't be suitable as boot device.\n"); ++ pr_err("Note: You can omit this check with \"--force\"\n"); ++ if (ask("Do you want to continue") < 1) ++ return CH_ABORT; ++ } + change = CH_TAKEOVER; + check_devs = 1; + raid_disks *= 2; /* mirrors added */ +@@ -12219,7 +12228,7 @@ static int imsm_reshape_super(struct supertype *st, struct shape *shape, struct + goto exit_imsm_reshape_super; + } + super->current_vol = dev->index; +- change = imsm_analyze_change(st, &geo, shape->direction); ++ change = imsm_analyze_change(st, &geo, shape->direction, c); + switch (change) { + case CH_TAKEOVER: + ret_val = imsm_takeover(st, &geo); +@@ -12262,6 +12271,7 @@ static int imsm_reshape_super(struct supertype *st, struct shape *shape, struct + free(u); + } + break; ++ case CH_ABORT: + default: + ret_val = 1; + } +diff --git a/util.c b/util.c +index 9e837045..4fbf11c4 100644 +--- a/util.c ++++ b/util.c +@@ -725,23 +725,33 @@ int stat_is_blkdev(char *devname, dev_t *rdev) + return 1; + } + ++/** ++ * ask() - prompt user for "yes/no" dialog. ++ * @mesg: message to be printed, without '?' sign. ++ * Returns: 1 if 'Y/y', 0 otherwise. ++ * ++ * The default value is 'N/n', thus the caps on "N" on prompt. ++ */ + int ask(char *mesg) + { +- char *add = ""; +- int i; +- for (i = 0; i < 5; i++) { +- char buf[100]; +- fprintf(stderr, "%s%s", mesg, add); +- fflush(stderr); +- if (fgets(buf, 100, stdin)==NULL) +- return 0; +- if (buf[0]=='y' || buf[0]=='Y') +- return 1; +- if (buf[0]=='n' || buf[0]=='N') +- return 0; +- add = "(y/n) "; ++ char buf[3] = {0}; ++ ++ fprintf(stderr, "%s [y/N]? ", mesg); ++ fflush(stderr); ++ if (fgets(buf, 3, stdin) == NULL) ++ return 0; ++ if (strlen(buf) == 1) { ++ pr_err("assuming no.\n"); ++ return 0; + } +- pr_err("assuming 'no'\n"); ++ if (buf[1] != '\n') ++ goto bad_option; ++ if (toupper(buf[0]) == 'Y') ++ return 1; ++ if (toupper(buf[0]) == 'N') ++ return 0; ++bad_option: ++ pr_err("bad option.\n"); + return 0; + } + +@@ -1868,6 +1878,7 @@ int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info) + + if (st->ss->external) + return sysfs_set_array(info); ++ + memset(&inf, 0, sizeof(inf)); + inf.major_version = info->array.major_version; + inf.minor_version = info->array.minor_version; +-- +2.41.0 + diff --git a/0060-tests-01r5fail-enhance.patch b/0060-tests-01r5fail-enhance.patch new file mode 100644 index 0000000..8d2c464 --- /dev/null +++ b/0060-tests-01r5fail-enhance.patch @@ -0,0 +1,41 @@ +From d399c494c6364a6b6d0f965c08443fdc79d1e248 Mon Sep 17 00:00:00 2001 +From: Xiao Ni +Date: Thu, 18 Apr 2024 18:23:19 +0800 +Subject: [PATCH 60/69] tests/01r5fail enhance + +After removing dev0, the recovery starts because it already has a spare +disk. It's good to check recovery. But it's not right to check recovery +after adding dev3. Because the recovery may finish. It depends on the +recovery performance of the testing machine. If the recovery finishes, +it will fail. But dev3 is only added as a spare disk, we can't expect +there is a recovery happens. + +So remove the codes about adding dev3. + +Signed-off-by: Xiao Ni +Signed-off-by: Mariusz Tkaczyk +--- + tests/01r5fail | 6 +----- + 1 file changed, 1 insertion(+), 5 deletions(-) + +diff --git a/tests/01r5fail b/tests/01r5fail +index 873dba58..c210d6e7 100644 +--- a/tests/01r5fail ++++ b/tests/01r5fail +@@ -17,11 +17,7 @@ check wait + mdadm $md0 --fail $dev0 + mdadm $md0 --remove $dev3 $dev0 + check recovery +-check state _UUU +- +-mdadm $md0 -a $dev3 +-check recovery + check wait + check state UUUU + +-mdadm -S $md0 +\ No newline at end of file ++mdadm -S $md0 +-- +2.41.0 + diff --git a/0061-tests-01r5integ.broken.patch b/0061-tests-01r5integ.broken.patch new file mode 100644 index 0000000..04856bc --- /dev/null +++ b/0061-tests-01r5integ.broken.patch @@ -0,0 +1,32 @@ +From a20cb3872c02241e4f0f7cc26933a43bac7d1cbb Mon Sep 17 00:00:00 2001 +From: Xiao Ni +Date: Thu, 18 Apr 2024 18:23:20 +0800 +Subject: [PATCH 61/69] tests/01r5integ.broken + +01r5integ can be run successfully 152 times without error with +kernel 6.9.0-rc4 and mdadm - v4.3-51-g52bead95. So remove this +one broken case. + +Signed-off-by: Xiao Ni +Signed-off-by: Mariusz Tkaczyk +--- + tests/01r5integ.broken | 7 ------- + 1 file changed, 7 deletions(-) + delete mode 100644 tests/01r5integ.broken + +diff --git a/tests/01r5integ.broken b/tests/01r5integ.broken +deleted file mode 100644 +index 20737637..00000000 +--- a/tests/01r5integ.broken ++++ /dev/null +@@ -1,7 +0,0 @@ +-fails rarely +- +-Fails about 1 in every 30 runs with a sha mismatch error: +- +- c49ab26e1b01def7874af9b8a6d6d0c29fdfafe6 /dev/md0 does not match +- 15dc2f73262f811ada53c65e505ceec9cf025cb9 /dev/md0 with /dev/loop3 +- missing +-- +2.41.0 + diff --git a/0062-tests-01raid6integ.broken-can-be-removed.patch b/0062-tests-01raid6integ.broken-can-be-removed.patch new file mode 100644 index 0000000..7abeaea --- /dev/null +++ b/0062-tests-01raid6integ.broken-can-be-removed.patch @@ -0,0 +1,31 @@ +From 896948b14ad26f15590269dce50ac4896284dc29 Mon Sep 17 00:00:00 2001 +From: Xiao Ni +Date: Thu, 18 Apr 2024 18:23:21 +0800 +Subject: [PATCH 62/69] tests/01raid6integ.broken can be removed + +01raid6integ can be run successfully with kernel 6.9.0-rc3. +So remove 01raid6integ.broken. + +Signed-off-by: Xiao Ni +Signed-off-by: Mariusz Tkaczyk +--- + tests/01raid6integ.broken | 7 ------- + 1 file changed, 7 deletions(-) + delete mode 100644 tests/01raid6integ.broken + +diff --git a/tests/01raid6integ.broken b/tests/01raid6integ.broken +deleted file mode 100644 +index 1df735f0..00000000 +--- a/tests/01raid6integ.broken ++++ /dev/null +@@ -1,7 +0,0 @@ +-fails infrequently +- +-Fails about 1 in 5 with a sha mismatch: +- +- 8286c2bc045ae2cfe9f8b7ae3a898fa25db6926f /dev/md0 does not match +- a083a0738b58caab37fd568b91b177035ded37df /dev/md0 with /dev/loop2 and +- /dev/loop3 missing +-- +2.41.0 + diff --git a/0063-Makefile-Move-pie-to-LDFLAGS.patch b/0063-Makefile-Move-pie-to-LDFLAGS.patch new file mode 100644 index 0000000..db2cb18 --- /dev/null +++ b/0063-Makefile-Move-pie-to-LDFLAGS.patch @@ -0,0 +1,38 @@ +From 893a55831e5abbcd15b171db66fa1f389fb61506 Mon Sep 17 00:00:00 2001 +From: Fabrice Fontaine +Date: Tue, 7 May 2024 19:32:16 +0200 +Subject: [PATCH 63/69] Makefile: Move -pie to LDFLAGS + +Move -pie from LDLIBS to LDFLAGS and make LDFLAGS configurable to allow +the user to drop it by setting their own LDFLAGS (e.g. PIE could be +enabled or disabled by the buildsystem such as buildroot). + +Suggested-by: Mariusz Tkaczyk +Signed-off-by: Fabrice Fontaine +Signed-off-by: Mariusz Tkaczyk +--- + Makefile | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/Makefile b/Makefile +index 7c221a89..adac7905 100644 +--- a/Makefile ++++ b/Makefile +@@ -132,12 +132,12 @@ CFLAGS += -DUSE_PTHREADS + MON_LDFLAGS += -pthread + endif + +-LDFLAGS = -Wl,-z,now,-z,noexecstack ++LDFLAGS ?= -pie -Wl,-z,now,-z,noexecstack + + # If you want a static binary, you might uncomment these + # LDFLAGS += -static + # STRIP = -s +-LDLIBS = -ldl -pie ++LDLIBS = -ldl + + # To explicitly disable libudev, set -DNO_LIBUDEV in CXFLAGS + ifeq (, $(findstring -DNO_LIBUDEV, $(CXFLAGS))) +-- +2.41.0 + diff --git a/0064-tests-23rdev-lifetime-fix-a-typo.patch b/0064-tests-23rdev-lifetime-fix-a-typo.patch new file mode 100644 index 0000000..ee8bc37 --- /dev/null +++ b/0064-tests-23rdev-lifetime-fix-a-typo.patch @@ -0,0 +1,30 @@ +From a0174749426f49a04f11ae0e728cb0a681bfa465 Mon Sep 17 00:00:00 2001 +From: Yu Kuai +Date: Thu, 9 May 2024 09:10:59 +0800 +Subject: [PATCH 64/69] tests/23rdev-lifetime: fix a typo + +"pill" was wrong, while it should be "kill", test will still pass while +test thread will not be cleaned up. + +Signed-off-by: Yu Kuai +Signed-off-by: Mariusz Tkaczyk +--- + tests/23rdev-lifetime | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/tests/23rdev-lifetime b/tests/23rdev-lifetime +index 1750b0db..03b61de4 100644 +--- a/tests/23rdev-lifetime ++++ b/tests/23rdev-lifetime +@@ -4,7 +4,7 @@ pid="" + runtime=2 + + clean_up_test() { +- pill -9 $pid ++ kill -9 $pid + echo clear > /sys/block/md0/md/array_state + } + +-- +2.41.0 + diff --git a/0065-util.c-change-devnm-to-const-in-mdmon-functions.patch b/0065-util.c-change-devnm-to-const-in-mdmon-functions.patch new file mode 100644 index 0000000..48cc6d7 --- /dev/null +++ b/0065-util.c-change-devnm-to-const-in-mdmon-functions.patch @@ -0,0 +1,55 @@ +From b0f4e8e30f38d83f7e3f53d01d72d4cb3b4d42d7 Mon Sep 17 00:00:00 2001 +From: Kinga Stefaniuk +Date: Tue, 7 May 2024 05:38:55 +0200 +Subject: [PATCH 65/69] util.c: change devnm to const in mdmon functions + +Devnm shall not be changed inside mdmon_running() +and mdmon_pid() functions, change this parameter to const. + +Signed-off-by: Kinga Stefaniuk +Signed-off-by: Mariusz Tkaczyk +--- + mdadm.h | 4 ++-- + util.c | 4 ++-- + 2 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/mdadm.h b/mdadm.h +index 2ff3e463..1ba541fc 100644 +--- a/mdadm.h ++++ b/mdadm.h +@@ -1768,8 +1768,8 @@ extern int is_subarray_active(char *subarray, char *devname); + extern int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet); + extern struct superswitch *version_to_superswitch(char *vers); + +-extern int mdmon_running(char *devnm); +-extern int mdmon_pid(char *devnm); ++extern int mdmon_running(const char *devnm); ++extern int mdmon_pid(const char *devnm); + extern int check_env(char *name); + extern __u32 random32(void); + extern void random_uuid(__u8 *buf); +diff --git a/util.c b/util.c +index 4fbf11c4..e2b490e1 100644 +--- a/util.c ++++ b/util.c +@@ -1902,7 +1902,7 @@ unsigned long long min_recovery_start(struct mdinfo *array) + return recovery_start; + } + +-int mdmon_pid(char *devnm) ++int mdmon_pid(const char *devnm) + { + char path[100]; + char pid[10]; +@@ -1922,7 +1922,7 @@ int mdmon_pid(char *devnm) + return atoi(pid); + } + +-int mdmon_running(char *devnm) ++int mdmon_running(const char *devnm) + { + int pid = mdmon_pid(devnm); + if (pid <= 0) +-- +2.41.0 + diff --git a/0066-Wait-for-mdmon-when-it-is-stared-via-systemd.patch b/0066-Wait-for-mdmon-when-it-is-stared-via-systemd.patch new file mode 100644 index 0000000..4b9851c --- /dev/null +++ b/0066-Wait-for-mdmon-when-it-is-stared-via-systemd.patch @@ -0,0 +1,121 @@ +From aa1cc5815d2b14a8b47add18cfaa8264e19c10ce Mon Sep 17 00:00:00 2001 +From: Kinga Stefaniuk +Date: Tue, 7 May 2024 05:38:56 +0200 +Subject: [PATCH 66/69] Wait for mdmon when it is stared via systemd + +When mdmon is being started it may need few seconds to start. +For now, we didn't wait for it. Introduce wait_for_mdmon() +function, which waits up to 5 seconds for mdmon to start completely. + +Signed-off-by: Kinga Stefaniuk +Signed-off-by: Mariusz Tkaczyk +--- + Assemble.c | 4 ++-- + Grow.c | 7 ++++--- + mdadm.h | 2 ++ + util.c | 29 +++++++++++++++++++++++++++++ + 4 files changed, 37 insertions(+), 5 deletions(-) + +diff --git a/Assemble.c b/Assemble.c +index f5e9ab1f..83dced19 100644 +--- a/Assemble.c ++++ b/Assemble.c +@@ -2173,8 +2173,8 @@ int assemble_container_content(struct supertype *st, int mdfd, + if (!mdmon_running(st->container_devnm)) + start_mdmon(st->container_devnm); + ping_monitor(st->container_devnm); +- if (mdmon_running(st->container_devnm) && +- st->update_tail == NULL) ++ if (wait_for_mdmon(st->container_devnm) == MDADM_STATUS_SUCCESS && ++ !st->update_tail) + st->update_tail = &st->updates; + } + +diff --git a/Grow.c b/Grow.c +index 87ed9214..1923c27c 100644 +--- a/Grow.c ++++ b/Grow.c +@@ -2134,7 +2134,7 @@ int Grow_reshape(char *devname, int fd, + if (!mdmon_running(st->container_devnm)) + start_mdmon(st->container_devnm); + ping_monitor(container); +- if (mdmon_running(st->container_devnm) == false) { ++ if (wait_for_mdmon(st->container_devnm) != MDADM_STATUS_SUCCESS) { + pr_err("No mdmon found. Grow cannot continue.\n"); + goto release; + } +@@ -3218,7 +3218,8 @@ static int reshape_array(char *container, int fd, char *devname, + if (!mdmon_running(container)) + start_mdmon(container); + ping_monitor(container); +- if (mdmon_running(container) && st->update_tail == NULL) ++ if (wait_for_mdmon(container) == MDADM_STATUS_SUCCESS && ++ !st->update_tail) + st->update_tail = &st->updates; + } + } +@@ -5173,7 +5174,7 @@ int Grow_continue_command(char *devname, int fd, struct context *c) + start_mdmon(container); + ping_monitor(container); + +- if (mdmon_running(container) == false) { ++ if (wait_for_mdmon(container) != MDADM_STATUS_SUCCESS) { + pr_err("No mdmon found. Grow cannot continue.\n"); + ret_val = 1; + goto Grow_continue_command_exit; +diff --git a/mdadm.h b/mdadm.h +index 1ba541fc..b71d7b32 100644 +--- a/mdadm.h ++++ b/mdadm.h +@@ -1770,6 +1770,8 @@ extern struct superswitch *version_to_superswitch(char *vers); + + extern int mdmon_running(const char *devnm); + extern int mdmon_pid(const char *devnm); ++extern mdadm_status_t wait_for_mdmon(const char *devnm); ++ + extern int check_env(char *name); + extern __u32 random32(void); + extern void random_uuid(__u8 *buf); +diff --git a/util.c b/util.c +index e2b490e1..bf79742f 100644 +--- a/util.c ++++ b/util.c +@@ -1932,6 +1932,35 @@ int mdmon_running(const char *devnm) + return 0; + } + ++/* ++ * wait_for_mdmon() - Waits for mdmon within specified time. ++ * @devnm: Device for which mdmon should start. ++ * ++ * Function waits for mdmon to start. It may need few seconds ++ * to start, we set timeout to 5, it should be sufficient. ++ * Do not wait if mdmon has been started. ++ * ++ * Return: MDADM_STATUS_SUCCESS if mdmon is running, error code otherwise. ++ */ ++mdadm_status_t wait_for_mdmon(const char *devnm) ++{ ++ const time_t mdmon_timeout = 5; ++ time_t start_time = time(0); ++ ++ if (mdmon_running(devnm)) ++ return MDADM_STATUS_SUCCESS; ++ ++ pr_info("Waiting for mdmon to start\n"); ++ while (time(0) - start_time < mdmon_timeout) { ++ sleep_for(0, MSEC_TO_NSEC(200), true); ++ if (mdmon_running(devnm)) ++ return MDADM_STATUS_SUCCESS; ++ }; ++ ++ pr_err("Timeout waiting for mdmon\n"); ++ return MDADM_STATUS_ERROR; ++} ++ + int start_mdmon(char *devnm) + { + int i; +-- +2.41.0 + diff --git a/0069-mdadm-Fix-compilation-for-32-bit-arch.patch b/0069-mdadm-Fix-compilation-for-32-bit-arch.patch new file mode 100644 index 0000000..12464af --- /dev/null +++ b/0069-mdadm-Fix-compilation-for-32-bit-arch.patch @@ -0,0 +1,62 @@ +From c5879860eac64ddd7bec4ba50c9adbfebcbf1d2e Mon Sep 17 00:00:00 2001 +From: Blazej Kucman +Date: Wed, 15 May 2024 13:26:28 +0200 +Subject: [PATCH 69/69] mdadm: Fix compilation for 32-bit arch +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Casting void pointer to __u64 works for 64-bit arch but fails to compile +on 32-bit arch like i686. + +Fail on i686 platform: +drive_encryption.c: In function ‘nvme_security_recv_ioctl’: +drive_encryption.c:236:25: error: cast from pointer to integer of +different size [-Werror=pointer-to-int-cast] + 236 | nvme_cmd.addr = (__u64)response_buffer; + | ^ +drive_encryption.c: In function ‘nvme_identify_ioctl’: +drive_encryption.c:271:25: error: cast from pointer to integer of +different size [-Werror=pointer-to-int-cast] + 271 | nvme_cmd.addr = (__u64)response_buffer; + | ^ +cc1: all warnings being treated as errors +make: *** [Makefile:211: drive_encryption.o] Error 1 + +This change adds cast void pointer to uintptr_t first to ensure that +proper pointer size is used for casting from pointer type. Then is safe to +cast it to __u64 because it is tracked as u_int, regardless it is 32-bit +or 64-bit arch. + +Reported-by: Xiao Ni +Fixes: cc48406887b3 ("Add reading Opal NVMe encryption information") +Signed-off-by: Blazej Kucman +--- + drive_encryption.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/drive_encryption.c b/drive_encryption.c +index 27da9621..a4ad799f 100644 +--- a/drive_encryption.c ++++ b/drive_encryption.c +@@ -233,7 +233,7 @@ nvme_security_recv_ioctl(int disk_fd, __u8 sec_protocol, __u16 comm_id, void *re + nvme_cmd.cdw10 = sec_protocol << 24 | comm_id << 8; + nvme_cmd.cdw11 = buf_size; + nvme_cmd.data_len = buf_size; +- nvme_cmd.addr = (__u64)response_buffer; ++ nvme_cmd.addr = (__u64)(uintptr_t)response_buffer; + + status = ioctl(disk_fd, NVME_IOCTL_ADMIN_CMD, &nvme_cmd); + if (status != 0) { +@@ -268,7 +268,7 @@ nvme_identify_ioctl(int disk_fd, void *response_buffer, size_t buf_size, const i + nvme_cmd.opcode = NVME_IDENTIFY; + nvme_cmd.cdw10 = NVME_IDENTIFY_CONTROLLER_DATA; + nvme_cmd.data_len = buf_size; +- nvme_cmd.addr = (__u64)response_buffer; ++ nvme_cmd.addr = (__u64)(uintptr_t)response_buffer; + + status = ioctl(disk_fd, NVME_IOCTL_ADMIN_CMD, &nvme_cmd); + if (status != 0) { +-- +2.41.0 + diff --git a/mdadm.spec b/mdadm.spec index 3be4471..e706d71 100644 --- a/mdadm.spec +++ b/mdadm.spec @@ -1,7 +1,7 @@ Name: mdadm Version: 4.3 # extraversion is used to define rhel internal version -%define extraversion 1 +%define extraversion 2 Release: %{extraversion}%{?dist} Summary: The mdadm program controls Linux md devices (software RAID arrays) URL: http://www.kernel.org/pub/linux/utils/raid/mdadm/ @@ -60,6 +60,32 @@ Patch037: 0038-mdadm-Fix-native-detail-export.patch Patch038: 0039-sysfs-remove-vers-parameter-from-sysfs_set_array.patch Patch039: 0040-mdadm-fix-grow-segfault-for-IMSM.patch Patch040: 0041-Remove-all-if-zeros-pt.2.patch +Patch041: 0042-mdadm-Move-pr_vrb-define-to-mdadm.h.patch +Patch042: 0043-Add-reading-Opal-NVMe-encryption-information.patch +Patch043: 0044-Add-reading-SATA-encryption-information.patch +Patch044: 0045-Add-key-ENCRYPTION_NO_VERIFY-to-conf.patch +Patch045: 0046-imsm-print-disk-encryption-information.patch +Patch046: 0047-imsm-drive-encryption-policy-implementation.patch +Patch047: 0048-mdadm-add-CHANGELOG.md.patch +Patch048: 0049-mdadm-Add-MAINTAINERS.md.patch +Patch049: 0050-mdadm-Add-README.md.patch +Patch050: 0051-Create.c-fix-uclibc-build.patch +Patch051: 0052-mdadm-pass-struct-context-for-external-reshapes.patch +Patch052: 0053-mdadm-use-struct-context-in-reshape_super.patch +Patch053: 0054-imsm-add-support-for-literal-RAID-10.patch +Patch054: 0055-imsm-refactor-RAID-level-handling.patch +Patch055: 0056-imsm-bump-minimal-version.patch +Patch056: 0057-imsm-define-RAID_10-attribute.patch +Patch057: 0058-imsm-simplify-imsm_check_attributes.patch +Patch058: 0059-imsm-support-RAID-10-with-more-than-4-drives.patch +Patch059: 0060-tests-01r5fail-enhance.patch +Patch060: 0061-tests-01r5integ.broken.patch +Patch061: 0062-tests-01raid6integ.broken-can-be-removed.patch +Patch062: 0063-Makefile-Move-pie-to-LDFLAGS.patch +Patch063: 0064-tests-23rdev-lifetime-fix-a-typo.patch +Patch064: 0065-util.c-change-devnm-to-const-in-mdmon-functions.patch +Patch065: 0066-Wait-for-mdmon-when-it-is-stared-via-systemd.patch +Patch066: 0069-mdadm-Fix-compilation-for-32-bit-arch.patch # Fedora customization patches @@ -138,6 +164,10 @@ install -m644 %{SOURCE5} %{buildroot}/etc/libreport/events.d /usr/share/mdadm/mdcheck %changelog +* Thu May 16 2024 Xiao Ni 4.3-2 +- Update to latest upstream +- Resolves RHEL-36424 + * Fri Mar 29 2024 Xiao Ni 4.3-1 - Update to 4.3 and to latest upstream - Resolves RHEL-30529