From 7818b1a548434d2bf91a0662c547445013ae952d Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 5 Aug 2024 10:35:44 +0200 Subject: Adding upstream version 1.10. Signed-off-by: Daniel Baumann --- src/nvme/base64.c | 5 +- src/nvme/fabrics.c | 184 ++++++++++++++++++++++++++++++++++++++-- src/nvme/fabrics.h | 64 ++++++++++++++ src/nvme/ioctl.c | 168 ++++++++++++++++++++++++++++++------ src/nvme/ioctl.h | 31 ++++++- src/nvme/json.c | 23 +++-- src/nvme/linux.c | 209 +++++++++++++++++++++++++++++---------------- src/nvme/linux.h | 21 +++++ src/nvme/log.c | 68 +++++++++------ src/nvme/log.h | 25 ++++-- src/nvme/mi-mctp.c | 4 +- src/nvme/mi.c | 244 ++++++++++++++++++++++++++++++++++++++++++++++------- src/nvme/mi.h | 29 ++++++- src/nvme/private.h | 24 +++--- src/nvme/tree.c | 179 +++++++++++++++++++++++++++++++++------ src/nvme/tree.h | 47 ++++++++++- src/nvme/types.h | 85 ++++++++++++++----- src/nvme/util.c | 2 +- 18 files changed, 1163 insertions(+), 249 deletions(-) (limited to 'src/nvme') diff --git a/src/nvme/base64.c b/src/nvme/base64.c index 5fae829..0163fa1 100644 --- a/src/nvme/base64.c +++ b/src/nvme/base64.c @@ -7,6 +7,7 @@ * Author: Hannes Reinecke */ +#include #include #include #include @@ -29,7 +30,7 @@ static const char base64_table[65] = int base64_encode(const unsigned char *src, int srclen, char *dst) { int i, bits = 0; - u_int32_t ac = 0; + uint32_t ac = 0; char *cp = dst; for (i = 0; i < srclen; i++) { @@ -64,7 +65,7 @@ int base64_encode(const unsigned char *src, int srclen, char *dst) */ int base64_decode(const char *src, int srclen, unsigned char *dst) { - u_int32_t ac = 0; + uint32_t ac = 0; int i, bits = 0; unsigned char *bp = dst; diff --git a/src/nvme/fabrics.c b/src/nvme/fabrics.c index 6738e9d..acf12bc 100644 --- a/src/nvme/fabrics.c +++ b/src/nvme/fabrics.c @@ -1342,27 +1342,42 @@ static int uuid_from_dmi(char *system_uuid) return ret; } -char *nvmf_hostnqn_generate() +char *nvmf_hostid_generate() { - char *hostnqn; int ret; char uuid_str[NVME_UUID_LEN_STRING]; unsigned char uuid[NVME_UUID_LEN]; ret = uuid_from_dmi(uuid_str); - if (ret < 0) { + if (ret < 0) ret = uuid_from_device_tree(uuid_str); - } if (ret < 0) { if (nvme_uuid_random(uuid) < 0) memset(uuid, 0, NVME_UUID_LEN); nvme_uuid_to_string(uuid, uuid_str); } - if (asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", uuid_str) < 0) - return NULL; + return strdup(uuid_str); +} - return hostnqn; +char *nvmf_hostnqn_generate_from_hostid(char *hostid) +{ + char *hid = NULL; + char *hostnqn; + int ret; + + if (!hostid) + hostid = hid = nvmf_hostid_generate(); + + ret = asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", hostid); + free(hid); + + return (ret < 0) ? NULL : hostnqn; +} + +char *nvmf_hostnqn_generate() +{ + return nvmf_hostnqn_generate_from_hostid(NULL); } static char *nvmf_read_file(const char *f, int len) @@ -1387,8 +1402,11 @@ char *nvmf_hostnqn_from_file() { char *hostnqn = getenv("LIBNVME_HOSTNQN"); - if (hostnqn) + if (hostnqn) { + if (!strcmp(hostnqn, "")) + return NULL; return strdup(hostnqn); + } return nvmf_read_file(NVMF_HOSTNQN_FILE, NVMF_NQN_SIZE); } @@ -1397,8 +1415,11 @@ char *nvmf_hostid_from_file() { char *hostid = getenv("LIBNVME_HOSTID"); - if (hostid) + if (hostid) { + if (!strcmp(hostid, "")) + return NULL; return strdup(hostid); + } return nvmf_read_file(NVMF_HOSTID_FILE, NVMF_HOSTID_SIZE); } @@ -1703,3 +1724,148 @@ int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result) */ return nvmf_dim(c, tas, NVMF_TRTYPE_TCP, nvme_get_adrfam(c), "", NULL, result); } + +#define IS_XDIGIT(c) ((c >= '0' && c <= '9') || \ + (c >= 'A' && c <= 'F') || \ + (c >= 'a' && c <= 'f')) +#define XDIGIT_VAL(c) ((c >= '0' && c <= '9') ? c - '0' : ( \ + (c >= 'A' && c <= 'F') ? c - 'A' + 10 : c - 'a' + 10)) + +/* returns newly allocated string */ +static char *unescape_uri(const char *str, int len) +{ + char *dst; + int l; + int i, j; + + l = len > 0 ? len : strlen(str); + dst = malloc(l + 1); + for (i = 0, j = 0; i < l; i++, j++) { + if (str[i] == '%' && i + 2 < l && + IS_XDIGIT(str[i + 1]) && IS_XDIGIT(str[i + 2])) { + dst[j] = (XDIGIT_VAL(str[i + 1]) << 4) + + XDIGIT_VAL(str[i + 2]); + i += 2; + } else + dst[j] = str[i]; + } + dst[j] = '\0'; + return dst; +} + +struct nvme_fabrics_uri *nvme_parse_uri(const char *str) +{ + struct nvme_fabrics_uri *uri; + _cleanup_free_ char *scheme = NULL; + _cleanup_free_ char *authority = NULL; + _cleanup_free_ char *path = NULL; + _cleanup_free_ char *h = NULL; + const char *host; + int i; + + /* As defined in Boot Specification rev. 1.0: + * + * section 1.5.7: NVMe-oF URI Format + * nvme+tcp://192.168.1.1:4420/ + * nvme+tcp://[FE80::1010]:4420/ + * + * section 3.1.2.5.3: DHCP Root-Path - a hierarchical NVMe-oF URI Format + * NVME<+PROTOCOL>://[:TRANSPORT PORT]// + * or + * NVME<+PROTOCOL>://[:DISCOVERY- + * -CONTROLLER PORT]/NQN.2014-08.ORG.NVMEXPRESS.DISCOVERY/ + */ + + uri = calloc(1, sizeof(struct nvme_fabrics_uri)); + if (!uri) + return NULL; + + if (sscanf(str, "%m[^:/]://%m[^/?#]%ms", + &scheme, &authority, &path) < 2) { + nvme_free_uri(uri); + errno = EINVAL; + return NULL; + } + + if (sscanf(scheme, "%m[^+]+%ms", + &uri->scheme, &uri->protocol) < 1) { + nvme_free_uri(uri); + errno = EINVAL; + return NULL; + } + + /* split userinfo */ + host = strrchr(authority, '@'); + if (host) { + host++; + uri->userinfo = unescape_uri(authority, host - authority); + } else + host = authority; + + /* try matching IPv6 address first */ + if (sscanf(host, "[%m[^]]]:%d", + &uri->host, &uri->port) < 1) { + /* treat it as IPv4/hostname */ + if (sscanf(host, "%m[^:]:%d", + &h, &uri->port) < 1) { + nvme_free_uri(uri); + errno = EINVAL; + return NULL; + } + uri->host = unescape_uri(h, 0); + } + + /* split path into elements */ + if (path) { + char *e, *elem; + + /* separate the fragment */ + e = strrchr(path, '#'); + if (e) { + uri->fragment = unescape_uri(e + 1, 0); + *e = '\0'; + } + /* separate the query string */ + e = strrchr(path, '?'); + if (e) { + uri->query = unescape_uri(e + 1, 0); + *e = '\0'; + } + + /* count elements first */ + for (i = 0, e = path; *e; e++) + if (*e == '/' && *(e + 1) != '/') + i++; + uri->path_segments = calloc(i + 2, sizeof(char *)); + + i = 0; + elem = strtok_r(path, "/", &e); + if (elem) + uri->path_segments[i++] = unescape_uri(elem, 0); + while (elem && strlen(elem)) { + elem = strtok_r(NULL, "/", &e); + if (elem) + uri->path_segments[i++] = unescape_uri(elem, 0); + } + } + + return uri; +} + +void nvme_free_uri(struct nvme_fabrics_uri *uri) +{ + char **s; + + if (!uri) + return; + free(uri->scheme); + free(uri->protocol); + free(uri->userinfo); + free(uri->host); + for (s = uri->path_segments; s && *s; s++) + free(*s); + free(uri->path_segments); + free(uri->query); + free(uri->fragment); + free(uri); +} diff --git a/src/nvme/fabrics.h b/src/nvme/fabrics.h index 4ebeb35..8e26e9f 100644 --- a/src/nvme/fabrics.h +++ b/src/nvme/fabrics.h @@ -67,6 +67,28 @@ struct nvme_fabrics_config { bool concat; }; +/** + * struct nvme_fabrics_uri - Parsed URI structure + * @scheme: Scheme name (typically 'nvme') + * @protocol: Optional protocol/transport (e.g. 'tcp') + * @userinfo: Optional user information component of the URI authority + * @host: Host transport address + * @port: The port subcomponent or 0 if not specified + * @path_segments: NULL-terminated array of path segments + * @query: Optional query string component (separated by '?') + * @fragment: Optional fragment identifier component (separated by '#') + */ +struct nvme_fabrics_uri { + char *scheme; + char *protocol; + char *userinfo; + char *host; + int port; + char **path_segments; + char *query; + char *fragment; +}; + /** * nvmf_trtype_str() - Decode TRTYPE field * @trtype: value to be decoded @@ -257,6 +279,26 @@ struct nvmf_discovery_log *nvmf_get_discovery_wargs(struct nvme_get_discovery_ar */ char *nvmf_hostnqn_generate(); +/** + * nvmf_hostnqn_generate_from_hostid() - Generate a host nqn from host identifier + * @hostid: Host identifier + * + * If @hostid is NULL, the function generates it based on the machine + * identifier. + * + * Return: On success, an NVMe Qualified Name for host identification. This + * name is based on the given host identifier. On failure, NULL. + */ +char *nvmf_hostnqn_generate_from_hostid(char *hostid); + +/** + * nvmf_hostid_generate() - Generate a machine specific host identifier + * + * Return: On success, an identifier string based on the machine identifier to + * be used as NVMe Host Identifier, or NULL on failure. + */ +char *nvmf_hostid_generate(); + /** * nvmf_hostnqn_from_file() - Reads the host nvm qualified name from the config * default location @@ -324,4 +366,26 @@ bool nvmf_is_registration_supported(nvme_ctrl_t c); */ int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result); +/** + * nvme_parse_uri() - Parse the URI string + * @str: URI string + * + * Parse the URI string as defined in the NVM Express Boot Specification. + * Supported URI elements looks as follows: + * + * nvme+tcp://user@host:port/subsys_nqn/nid?query=val#fragment + * + * Return: &nvme_fabrics_uri structure on success; NULL on failure with errno + * set. + */ +struct nvme_fabrics_uri *nvme_parse_uri(const char *str); + +/** + * nvme_free_uri() - Free the URI structure + * @uri: &nvme_fabrics_uri structure + * + * Free an &nvme_fabrics_uri structure. + */ +void nvme_free_uri(struct nvme_fabrics_uri *uri); + #endif /* _LIBNVME_FABRICS_H */ diff --git a/src/nvme/ioctl.c b/src/nvme/ioctl.c index ce5a911..9707829 100644 --- a/src/nvme/ioctl.c +++ b/src/nvme/ioctl.c @@ -355,6 +355,131 @@ int nvme_get_log_page(int fd, __u32 xfer_len, struct nvme_get_log_args *args) return 0; } +static int read_ana_chunk(int fd, enum nvme_log_ana_lsp lsp, bool rae, + __u8 *log, __u8 **read, __u8 *to_read, __u8 *log_end) +{ + if (to_read > log_end) { + errno = ENOSPC; + return -1; + } + + while (*read < to_read) { + __u32 len = min(log_end - *read, NVME_LOG_PAGE_PDU_SIZE); + int ret; + + ret = nvme_get_log_ana(fd, lsp, rae, *read - log, len, *read); + if (ret) + return ret; + + *read += len; + } + return 0; +} + +static int try_read_ana(int fd, enum nvme_log_ana_lsp lsp, bool rae, + struct nvme_ana_log *log, __u8 *log_end, + __u8 *read, __u8 **to_read, bool *may_retry) +{ + __u16 ngrps = le16_to_cpu(log->ngrps); + + while (ngrps--) { + __u8 *group = *to_read; + int ret; + __le32 nnsids; + + *to_read += sizeof(*log->descs); + ret = read_ana_chunk(fd, lsp, rae, + (__u8 *)log, &read, *to_read, log_end); + if (ret) { + /* + * If the provided buffer isn't long enough, + * the log page may have changed while reading it + * and the computed length was inaccurate. + * Have the caller check chgcnt and retry. + */ + *may_retry = errno == ENOSPC; + return ret; + } + + /* + * struct nvme_ana_group_desc has 8-byte alignment + * but the group pointer is only 4-byte aligned. + * Don't dereference the misaligned pointer. + */ + memcpy(&nnsids, + group + offsetof(struct nvme_ana_group_desc, nnsids), + sizeof(nnsids)); + *to_read += le32_to_cpu(nnsids) * sizeof(__le32); + ret = read_ana_chunk(fd, lsp, rae, + (__u8 *)log, &read, *to_read, log_end); + if (ret) { + *may_retry = errno == ENOSPC; + return ret; + } + } + + *may_retry = true; + return 0; +} + +int nvme_get_ana_log_atomic(int fd, bool rgo, bool rae, unsigned int retries, + struct nvme_ana_log *log, __u32 *len) +{ + const enum nvme_log_ana_lsp lsp = + rgo ? NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY : 0; + /* Get Log Page can only fetch multiples of dwords */ + __u8 * const log_end = (__u8 *)log + (*len & -4); + __u8 *read = (__u8 *)log; + __u8 *to_read; + int ret; + + if (!retries) { + errno = EINVAL; + return -1; + } + + to_read = (__u8 *)log->descs; + ret = read_ana_chunk(fd, lsp, rae, + (__u8 *)log, &read, to_read, log_end); + if (ret) + return ret; + + do { + bool may_retry = false; + int saved_ret; + int saved_errno; + __le64 chgcnt; + + saved_ret = try_read_ana(fd, lsp, rae, log, log_end, + read, &to_read, &may_retry); + /* + * If the log page was read with multiple Get Log Page commands, + * chgcnt must be checked afterwards to ensure atomicity + */ + *len = to_read - (__u8 *)log; + if (*len <= NVME_LOG_PAGE_PDU_SIZE || !may_retry) + return saved_ret; + + saved_errno = errno; + chgcnt = log->chgcnt; + read = (__u8 *)log; + to_read = (__u8 *)log->descs; + ret = read_ana_chunk(fd, lsp, rae, + (__u8 *)log, &read, to_read, log_end); + if (ret) + return ret; + + if (log->chgcnt == chgcnt) { + /* Log hasn't changed; return try_read_ana() result */ + errno = saved_errno; + return saved_ret; + } + } while (--retries); + + errno = EAGAIN; + return -1; +} + int nvme_set_features(struct nvme_set_features_args *args) { __u32 cdw10 = NVME_SET(args->fid, FEATURES_CDW10_FID) | @@ -1670,35 +1795,30 @@ static int nvme_set_var_size_tags(__u32 *cmd_dw2, __u32 *cmd_dw3, __u32 *cmd_dw1 __u8 pif, __u8 sts, __u64 reftag, __u64 storage_tag) { __u32 cdw2 = 0, cdw3 = 0, cdw14; - beint64_t be_reftag = cpu_to_be64(reftag); - beint64_t be_storage_tag = cpu_to_be64(storage_tag); switch (pif) { - /* 16b Protection Information */ - case 0: - cdw14 = be_reftag & 0xffffffff; - cdw14 |= ((be_storage_tag << (32 - sts)) & 0xffffffff); + case NVME_NVM_PIF_16B_GUARD: + cdw14 = reftag & 0xffffffff; + cdw14 |= ((storage_tag << (32 - sts)) & 0xffffffff); break; - /* 32b Protection Information */ - case 1: - cdw14 = be_reftag & 0xffffffff; - cdw3 = be_reftag >> 32; - cdw14 |= ((be_storage_tag << (80 - sts)) & 0xffff0000); + case NVME_NVM_PIF_32B_GUARD: + cdw14 = reftag & 0xffffffff; + cdw3 = reftag >> 32; + cdw14 |= ((storage_tag << (80 - sts)) & 0xffff0000); if (sts >= 48) - cdw3 |= ((be_storage_tag >> (sts - 48)) & 0xffffffff); + cdw3 |= ((storage_tag >> (sts - 48)) & 0xffffffff); else - cdw3 |= ((be_storage_tag << (48 - sts)) & 0xffffffff); - cdw2 = (be_storage_tag >> (sts - 16)) & 0xffff; + cdw3 |= ((storage_tag << (48 - sts)) & 0xffffffff); + cdw2 = (storage_tag >> (sts - 16)) & 0xffff; break; - /* 64b Protection Information */ - case 2: - cdw14 = be_reftag & 0xffffffff; - cdw3 = (be_reftag >> 32) & 0xffff; - cdw14 |= ((be_storage_tag << (48 - sts)) & 0xffffffff); + case NVME_NVM_PIF_64B_GUARD: + cdw14 = reftag & 0xffffffff; + cdw3 = (reftag >> 32) & 0xffff; + cdw14 |= ((storage_tag << (48 - sts)) & 0xffffffff); if (sts >= 16) - cdw3 |= ((be_storage_tag >> (sts - 16)) & 0xffff); + cdw3 |= ((storage_tag >> (sts - 16)) & 0xffff); else - cdw3 |= ((be_storage_tag << (16 - sts)) & 0xffff); + cdw3 |= ((storage_tag << (16 - sts)) & 0xffff); break; default: perror("Unsupported Protection Information Format"); @@ -1706,9 +1826,9 @@ static int nvme_set_var_size_tags(__u32 *cmd_dw2, __u32 *cmd_dw3, __u32 *cmd_dw1 return -1; } - *cmd_dw2 = cdw2; - *cmd_dw3 = cdw3; - *cmd_dw14 = cdw14; + *cmd_dw2 = cpu_to_be32(cdw2); + *cmd_dw3 = cpu_to_be32(cdw3); + *cmd_dw14 = cpu_to_be32(cdw14); return 0; } diff --git a/src/nvme/ioctl.h b/src/nvme/ioctl.h index be4c1b7..2ebd39c 100644 --- a/src/nvme/ioctl.h +++ b/src/nvme/ioctl.h @@ -1865,7 +1865,7 @@ static inline int nvme_get_log_fdp_events(int fd, __u16 egid, bool host_events, * the asymmetric namespace access information for ANA Groups that contain * namespaces that are attached to the controller processing the command. * - * See &struct nvme_ana_rsp_hdr for the definition of the returned structure. + * See &struct nvme_ana_log for the definition of the returned structure. * * Return: The nvme command status if a response was received (see * &enum nvme_status_field) or -1 with errno set otherwise. @@ -1887,7 +1887,7 @@ static inline int nvme_get_log_ana(int fd, enum nvme_log_ana_lsp lsp, bool rae, .lsi = NVME_LOG_LSI_NONE, .lsp = (__u8)lsp, .uuidx = NVME_UUID_NONE, - .rae = false, + .rae = rae, .ot = false, }; return nvme_get_log_page(fd, NVME_LOG_PAGE_PDU_SIZE, &args); @@ -1900,18 +1900,41 @@ static inline int nvme_get_log_ana(int fd, enum nvme_log_ana_lsp lsp, bool rae, * @len: The allocated length of the log page * @log: User address to store the ana group log * - * See &struct nvme_ana_group_desc for the definition of the returned structure. + * See &struct nvme_ana_log for the definition of the returned structure. * * Return: The nvme command status if a response was received (see * &enum nvme_status_field) or -1 with errno set otherwise. */ static inline int nvme_get_log_ana_groups(int fd, bool rae, __u32 len, - struct nvme_ana_group_desc *log) + struct nvme_ana_log *log) { return nvme_get_log_ana(fd, NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY, rae, 0, len, log); } +/** + * nvme_get_ana_log_atomic() - Retrieve Asymmetric Namespace Access log page atomically + * @fd: File descriptor of nvme device + * @rgo: Whether to retrieve ANA groups only (no NSIDs) + * @rae: Whether to retain asynchronous events + * @retries: The maximum number of times to retry on log page changes + * @log: Pointer to a buffer to receive the ANA log page + * @len: Input: the length of the log page buffer. + * Output: the actual length of the ANA log page. + * + * See &struct nvme_ana_log for the definition of the returned structure. + * + * Return: If successful, returns 0 and sets *len to the actual log page length. + * If unsuccessful, returns the nvme command status if a response was received + * (see &enum nvme_status_field) or -1 with errno set otherwise. + * Sets errno = EINVAL if retries == 0. + * Sets errno = EAGAIN if unable to read the log page atomically + * because chgcnt changed during each of the retries attempts. + * Sets errno = ENOSPC if the full log page does not fit in the provided buffer. + */ +int nvme_get_ana_log_atomic(int fd, bool rgo, bool rae, unsigned int retries, + struct nvme_ana_log *log, __u32 *len); + /** * nvme_get_log_lba_status() - Retrieve LBA Status * @fd: File descriptor of nvme device diff --git a/src/nvme/json.c b/src/nvme/json.c index a02bd2d..2c769f2 100644 --- a/src/nvme/json.c +++ b/src/nvme/json.c @@ -339,6 +339,9 @@ static void json_update_port(struct json_object *ctrl_array, nvme_ctrl_t c) const char *transport, *value; transport = nvme_ctrl_get_transport(c); + if (!strcmp(transport, "pcie")) + return; + json_object_object_add(port_obj, "transport", json_object_new_string(transport)); value = nvme_ctrl_get_traddr(c); @@ -432,11 +435,13 @@ static void json_update_subsys(struct json_object *subsys_array, nvme_subsystem_for_each_ctrl(s, c) { json_update_port(port_array, c); } - if (json_object_array_length(port_array)) + if (json_object_array_length(port_array)) { json_object_object_add(subsys_obj, "ports", port_array); - else + json_object_array_add(subsys_array, subsys_obj); + } else { json_object_put(port_array); - json_object_array_add(subsys_array, subsys_obj); + json_object_put(subsys_obj); + } } int json_update_config(nvme_root_t r, const char *config_file) @@ -476,12 +481,14 @@ int json_update_config(nvme_root_t r, const char *config_file) nvme_for_each_subsystem(h, s) { json_update_subsys(subsys_array, s); } - if (json_object_array_length(subsys_array)) + if (json_object_array_length(subsys_array)) { json_object_object_add(host_obj, "subsystems", - subsys_array); - else + subsys_array); + json_object_array_add(json_root, host_obj); + } else { json_object_put(subsys_array); - json_object_array_add(json_root, host_obj); + json_object_put(host_obj); + } } if (!config_file) { ret = json_object_to_fd(1, json_root, JSON_C_TO_STRING_PRETTY); @@ -633,7 +640,7 @@ int json_dump_tree(nvme_root_t r) } json_object_object_add(json_root, "hosts", host_array); - ret = json_object_to_fd(fileno(r->fp), json_root, JSON_C_TO_STRING_PRETTY); + ret = json_object_to_fd(r->log.fd, json_root, JSON_C_TO_STRING_PRETTY); if (ret < 0) { nvme_msg(r, LOG_ERR, "Failed to write, %s\n", json_util_get_last_err()); diff --git a/src/nvme/linux.c b/src/nvme/linux.c index 25196fd..aff0544 100644 --- a/src/nvme/linux.c +++ b/src/nvme/linux.c @@ -18,7 +18,6 @@ #include #ifdef CONFIG_OPENSSL -#include #include #include #include @@ -166,7 +165,7 @@ int nvme_get_telemetry_log(int fd, bool create, bool ctrl, bool rae, size_t max_ struct nvme_telemetry_log *telem; enum nvme_cmd_get_log_lid lid; - _cleanup_free_ void *log; + _cleanup_free_ void *log = NULL; void *tmp; int err; size_t dalb; @@ -296,8 +295,8 @@ int nvme_get_new_host_telemetry(int fd, struct nvme_telemetry_log **log, int nvme_get_lba_status_log(int fd, bool rae, struct nvme_lba_status_log **log) { + _cleanup_free_ struct nvme_lba_status_log *buf = NULL; __u32 size; - _cleanup_free_ struct nvme_lba_status_log *buf; void *tmp; int err; struct nvme_get_log_args args = { @@ -386,6 +385,16 @@ int nvme_namespace_detach_ctrls(int fd, __u32 nsid, __u16 num_ctrls, NVME_DEFAULT_IOCTL_TIMEOUT); } +size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl, + bool rgo) +{ + __u32 nanagrpid = le32_to_cpu(id_ctrl->nanagrpid); + size_t size = sizeof(struct nvme_ana_log) + + nanagrpid * sizeof(struct nvme_ana_group_desc); + + return rgo ? size : size + le32_to_cpu(id_ctrl->mnan) * sizeof(__le32); +} + int nvme_get_ana_log_len(int fd, size_t *analen) { _cleanup_free_ struct nvme_id_ctrl *ctrl = NULL; @@ -400,9 +409,7 @@ int nvme_get_ana_log_len(int fd, size_t *analen) if (ret) return ret; - *analen = sizeof(struct nvme_ana_log) + - le32_to_cpu(ctrl->nanagrpid) * sizeof(struct nvme_ana_group_desc) + - le32_to_cpu(ctrl->mnan) * sizeof(__le32); + *analen = nvme_get_ana_log_len_from_id_ctrl(ctrl, false); return 0; } @@ -544,22 +551,18 @@ static int derive_retained_key(int hmac, const char *hostnqn, return -1; } -static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, - int version, int hmac, char *identity, - unsigned char *retained, size_t key_len) +static int derive_psk_digest(const char *hostnqn, const char *subsysnqn, + int version, int hmac, + unsigned char *retained, size_t key_len, + char *digest, size_t digest_len) { - if (version != 0) { - nvme_msg(NULL, LOG_ERR, "NVMe TLS 2.0 is not supported; " - "recompile with OpenSSL support.\n"); - errno = ENOTSUP; - return -1; - } - sprintf(identity, "NVMe0R%02d %s %s", - hmac, hostnqn, subsysnqn); - return strlen(identity); + nvme_msg(NULL, LOG_ERR, "NVMe TLS 2.0 is not supported; " + "recompile with OpenSSL support.\n"); + errno = ENOTSUP; + return -1; } -static int derive_tls_key(int hmac, const char *identity, +static int derive_tls_key(int version, int hmac, const char *context, unsigned char *retained, unsigned char *psk, size_t key_len) { @@ -655,7 +658,7 @@ static int derive_retained_key(int hmac, const char *hostnqn, return key_len; } -static int derive_tls_key(int hmac, const char *identity, +static int derive_tls_key(int version, int hmac, const char *context, unsigned char *retained, unsigned char *psk, size_t key_len) { @@ -703,9 +706,20 @@ static int derive_tls_key(int hmac, const char *identity, errno = ENOKEY; return -1; } + if (version == 1) { + char hash_str[4]; + + sprintf(hash_str, "%02d ", hmac); + if (EVP_PKEY_CTX_add1_hkdf_info(ctx, + (const unsigned char *)hash_str, + strlen(hash_str)) <= 0) { + errno = ENOKEY; + return -1; + } + } if (EVP_PKEY_CTX_add1_hkdf_info(ctx, - (const unsigned char *)identity, - strlen(identity)) <= 0) { + (const unsigned char *)context, + strlen(context)) <= 0) { errno = ENOKEY; return -1; } @@ -731,9 +745,6 @@ int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac, _cleanup_hmac_ctx_ HMAC_CTX *hmac_ctx = NULL; const EVP_MD *md; - ENGINE_load_builtin_engines(); - ENGINE_register_all_complete(); - hmac_ctx = HMAC_CTX_new(); if (!hmac_ctx) { errno = ENOMEM; @@ -788,28 +799,18 @@ int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac, return 0; } -static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, - int version, int hmac, char *identity, - unsigned char *retained, size_t key_len) +static int derive_psk_digest(const char *hostnqn, const char *subsysnqn, + int version, int hmac, + unsigned char *retained, size_t key_len, + char *digest, size_t digest_len) { static const char hmac_seed[] = "NVMe-over-Fabrics"; size_t hmac_len; const EVP_MD *md = select_hmac(hmac, &hmac_len); _cleanup_hmac_ctx_ HMAC_CTX *hmac_ctx = NULL; _cleanup_free_ unsigned char *psk_ctx = NULL; - _cleanup_free_ char *enc_ctx = NULL; size_t len; - if (version == 0) { - sprintf(identity, "NVMe%01dR%02d %s %s", - version, hmac, hostnqn, subsysnqn); - return strlen(identity); - } - if (version > 1) { - errno = EINVAL; - return -1; - } - hmac_ctx = HMAC_CTX_new(); if (!hmac_ctx) { errno = ENOMEM; @@ -856,17 +857,19 @@ static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, errno = ENOKEY; return -1; } - enc_ctx = malloc(key_len * 2); - memset(enc_ctx, 0, key_len * 2); - len = base64_encode(psk_ctx, key_len, enc_ctx); + if (key_len * 2 > digest_len) { + errno = EINVAL; + return -1; + } + memset(digest, 0, digest_len); + len = base64_encode(psk_ctx, key_len, digest); if (len < 0) { errno = ENOKEY; return len; } - sprintf(identity, "NVMe%01dR%02d %s %s %s", - version, hmac, hostnqn, subsysnqn, enc_ctx); - return strlen(identity); + return strlen(digest); } + #endif /* !CONFIG_OPENSSL_1 */ #ifdef CONFIG_OPENSSL_3 @@ -961,9 +964,10 @@ int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac, return 0; } -static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, - int version, int hmac, char *identity, - unsigned char *retained, size_t key_len) +static int derive_psk_digest(const char *hostnqn, const char *subsysnqn, + int version, int hmac, + unsigned char *retained, size_t key_len, + char *digest, size_t digest_len) { static const char hmac_seed[] = "NVMe-over-Fabrics"; size_t hmac_len; @@ -972,21 +976,10 @@ static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, _cleanup_evp_mac_ctx_ EVP_MAC_CTX *mac_ctx = NULL; _cleanup_evp_mac_ EVP_MAC *mac = NULL; char *progq = NULL; - char *digest = NULL; + char *dig = NULL; _cleanup_free_ unsigned char *psk_ctx = NULL; - _cleanup_free_ char *enc_ctx = NULL; size_t len; - if (version == 0) { - sprintf(identity, "NVMe%01dR%02d %s %s", - version, hmac, hostnqn, subsysnqn); - return strlen(identity); - } - if (version > 1) { - errno = EINVAL; - return -1; - } - lib_ctx = OSSL_LIB_CTX_new(); if (!lib_ctx) { errno = ENOMEM; @@ -1005,19 +998,19 @@ static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, } switch (hmac) { case NVME_HMAC_ALG_SHA2_256: - digest = OSSL_DIGEST_NAME_SHA2_256; + dig = OSSL_DIGEST_NAME_SHA2_256; break; case NVME_HMAC_ALG_SHA2_384: - digest = OSSL_DIGEST_NAME_SHA2_384; + dig = OSSL_DIGEST_NAME_SHA2_384; break; default: errno = EINVAL; break; } - if (!digest) + if (!dig) return -1; *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, - digest, 0); + dig, 0); *p = OSSL_PARAM_construct_end(); psk_ctx = malloc(key_len); @@ -1061,18 +1054,38 @@ static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, errno = EMSGSIZE; return -1; } - enc_ctx = malloc(hmac_len * 2); - memset(enc_ctx, 0, hmac_len * 2); - len = base64_encode(psk_ctx, hmac_len, enc_ctx); + if (hmac_len * 2 > digest_len) { + errno = EINVAL; + return -1; + } + memset(digest, 0, digest_len); + len = base64_encode(psk_ctx, hmac_len, digest); if (len < 0) { errno = ENOKEY; return len; } + return strlen(digest); +} +#endif /* !CONFIG_OPENSSL_3 */ + +static int gen_tls_identity(const char *hostnqn, const char *subsysnqn, + int version, int hmac, char *digest, + char *identity) +{ + if (version == 0) { + sprintf(identity, "NVMe%01dR%02d %s %s", + version, hmac, hostnqn, subsysnqn); + return strlen(identity); + } + if (version > 1) { + errno = EINVAL; + return -1; + } + sprintf(identity, "NVMe%01dR%02d %s %s %s", - version, hmac, hostnqn, subsysnqn, enc_ctx); + version, hmac, hostnqn, subsysnqn, digest); return strlen(identity); } -#endif /* !CONFIG_OPENSSL_3 */ static int derive_nvme_keys(const char *hostnqn, const char *subsysnqn, char *identity, int version, @@ -1080,6 +1093,8 @@ static int derive_nvme_keys(const char *hostnqn, const char *subsysnqn, unsigned char *psk, int key_len) { _cleanup_free_ unsigned char *retained = NULL; + _cleanup_free_ char *digest = NULL; + char *context = identity; int ret = -1; if (!hostnqn || !subsysnqn || !identity || !psk) { @@ -1095,11 +1110,28 @@ static int derive_nvme_keys(const char *hostnqn, const char *subsysnqn, ret = derive_retained_key(hmac, hostnqn, configured, retained, key_len); if (ret < 0) return ret; + + if (version == 1) { + size_t digest_len = 2 * key_len; + + digest = malloc(digest_len); + if (!digest) { + errno = ENOMEM; + return -1; + } + ret = derive_psk_digest(hostnqn, subsysnqn, version, hmac, + retained, key_len, + digest, digest_len); + if (ret) + return ret; + context = digest; + } ret = gen_tls_identity(hostnqn, subsysnqn, version, hmac, - identity, retained, key_len); + digest, identity); if (ret < 0) return ret; - return derive_tls_key(hmac, identity, retained, psk, key_len); + return derive_tls_key(version, hmac, context, retained, + psk, key_len); } static size_t nvme_identity_len(int hmac, int version, const char *hostnqn, @@ -1355,6 +1387,24 @@ long nvme_insert_tls_key_versioned(const char *keyring, const char *key_type, return key; } +long nvme_revoke_tls_key(const char *keyring, const char *key_type, + const char *identity) +{ + key_serial_t keyring_id; + long key; + + keyring_id = nvme_lookup_keyring(keyring); + if (keyring_id == 0) { + errno = ENOKEY; + return 0; + } + + key = keyctl_search(keyring_id, key_type, identity, 0); + if (key < 0) + return -1; + + return keyctl_revoke(key); +} #else long nvme_lookup_keyring(const char *keyring) { @@ -1419,6 +1469,15 @@ long nvme_insert_tls_key_versioned(const char *keyring, const char *key_type, errno = ENOTSUP; return -1; } + +long nvme_revoke_tls_key(const char *keyring, const char *key_type, + const char *identity) +{ + nvme_msg(NULL, LOG_ERR, "key operations not supported; " + "recompile with keyutils support.\n"); + errno = ENOTSUP; + return -1; +} #endif long nvme_insert_tls_key(const char *keyring, const char *key_type, @@ -1513,10 +1572,10 @@ unsigned char *nvme_import_tls_key(const char *encoded_key, int *key_len, return NULL; } crc = crc32(crc, decoded_key, decoded_len); - key_crc = ((u_int32_t)decoded_key[decoded_len]) | - ((u_int32_t)decoded_key[decoded_len + 1] << 8) | - ((u_int32_t)decoded_key[decoded_len + 2] << 16) | - ((u_int32_t)decoded_key[decoded_len + 3] << 24); + key_crc = ((uint32_t)decoded_key[decoded_len]) | + ((uint32_t)decoded_key[decoded_len + 1] << 8) | + ((uint32_t)decoded_key[decoded_len + 2] << 16) | + ((uint32_t)decoded_key[decoded_len + 3] << 24); if (key_crc != crc) { nvme_msg(NULL, LOG_ERR, "CRC mismatch (key %08x, crc %08x)", key_crc, crc); diff --git a/src/nvme/linux.h b/src/nvme/linux.h index bd74262..8e5e8ad 100644 --- a/src/nvme/linux.h +++ b/src/nvme/linux.h @@ -128,6 +128,16 @@ int nvme_get_host_telemetry(int fd, struct nvme_telemetry_log **log, int nvme_get_new_host_telemetry(int fd, struct nvme_telemetry_log **log, enum nvme_telemetry_da da, size_t *size); +/** + * nvme_get_ana_log_len_from_id_ctrl() - Retrieve maximum possible ANA log size + * @id_ctrl: Controller identify data + * @rgo: If true, return maximum log page size without NSIDs + * + * Return: A byte limit on the size of the controller's ANA log page + */ +size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl, + bool rgo); + /** * nvme_get_ana_log_len() - Retrieve size of the current ANA log * @fd: File descriptor of nvme device @@ -401,6 +411,17 @@ char *nvme_generate_tls_key_identity(const char *hostnqn, const char *subsysnqn, int version, int hmac, unsigned char *configured_key, int key_len); +/** + * nvme_revoke_tls_key() - Revoke TLS key from keyring + * @keyring: Keyring to use + * @key_type: Type of the key to revoke + * @identity: Key identity string + * + * Return: 0 on success or on failure -1 with errno set. + */ +long nvme_revoke_tls_key(const char *keyring, const char *key_type, + const char *identity); + /** * nvme_export_tls_key() - Export a TLS key * @key_data: Raw data of the key diff --git a/src/nvme/log.c b/src/nvme/log.c index c98d213..eaf74e1 100644 --- a/src/nvme/log.c +++ b/src/nvme/log.c @@ -26,13 +26,18 @@ #define LOG_CLOCK CLOCK_MONOTONIC #endif -static nvme_root_t root; +static struct nvme_log def_log = { + .fd = STDERR_FILENO, + .level = DEFAULT_LOGLEVEL, + .pid = false, + .timestamp = false, +}; void __attribute__((format(printf, 4, 5))) -__nvme_msg(nvme_root_t r, int lvl, +__nvme_msg(nvme_root_t r, int level, const char *func, const char *format, ...) { - FILE *fp = stderr; + struct nvme_log *l; va_list ap; char pidbuf[16]; char timebuf[32]; @@ -50,18 +55,15 @@ __nvme_msg(nvme_root_t r, int lvl, _cleanup_free_ char *message = NULL; int idx = 0; - if (!r) - r = root; - if (r) - fp = r->fp; + l = &r->log; + else + l = &def_log; - if (r && lvl > r->log_level) - return; - if (!r && lvl > DEFAULT_LOGLEVEL) + if (level > l->level) return; - if (r && r->log_timestamp) { + if (l->timestamp) { struct timespec now; clock_gettime(LOG_CLOCK, &now); @@ -71,7 +73,7 @@ __nvme_msg(nvme_root_t r, int lvl, } else *timebuf = '\0'; - if (r && r->log_pid) { + if (l->pid) { snprintf(pidbuf, sizeof(pidbuf), "%ld", (long)getpid()); idx |= 1 << 1; } else @@ -89,42 +91,56 @@ __nvme_msg(nvme_root_t r, int lvl, message = NULL; va_end(ap); - fprintf(fp, "%s%s", + dprintf(l->fd, "%s%s", header ? header : "", message ? message : ""); } void nvme_init_logging(nvme_root_t r, int lvl, bool log_pid, bool log_tstamp) { - r->log_level = lvl; - r->log_pid = log_pid; - r->log_timestamp = log_tstamp; + r->log.level = lvl; + r->log.pid = log_pid; + r->log.timestamp = log_tstamp; } int nvme_get_logging_level(nvme_root_t r, bool *log_pid, bool *log_tstamp) { - if (!r) - r = root; - if (!r) - return DEFAULT_LOGLEVEL; + struct nvme_log *l; + + if (r) + l = &r->log; + else + l = &def_log; + if (log_pid) - *log_pid = r->log_pid; + *log_pid = l->pid; if (log_tstamp) - *log_tstamp = r->log_timestamp; - return r->log_level; + *log_tstamp = l->timestamp; + return l->level; +} + +void nvme_init_default_logging(FILE *fp, int level, bool log_pid, bool log_tstamp) +{ + def_log.fd = fileno(fp); + def_log.level = level; + def_log.pid = log_pid; + def_log.timestamp = log_tstamp; } void nvme_set_root(nvme_root_t r) { - root = r; + def_log.fd = r->log.fd; + def_log.level = r->log.level; + def_log.pid = r->log.pid; + def_log.timestamp = r->log.timestamp; } void nvme_set_debug(bool debug) { - root->log_level = debug ? LOG_DEBUG : DEFAULT_LOGLEVEL; + def_log.level = debug ? LOG_DEBUG : DEFAULT_LOGLEVEL; } bool nvme_get_debug(void) { - return root->log_level == LOG_DEBUG; + return def_log.level == LOG_DEBUG; } diff --git a/src/nvme/log.h b/src/nvme/log.h index cd243ea..80c642a 100644 --- a/src/nvme/log.h +++ b/src/nvme/log.h @@ -35,6 +35,18 @@ */ void nvme_init_logging(nvme_root_t r, int lvl, bool log_pid, bool log_tstamp); +/** + * nvme_init_default_logging() - Initialize default (fallback) logging + * @fp: File descriptor for logging messages + * @lvl: Logging level to set + * @log_pid: Boolean to enable logging of the PID + * @log_tstamp: Boolean to enable logging of the timestamp + * + * Sets the default logging settings for the library in case the root object + * is absent. + */ +void nvme_init_default_logging(FILE *fp, int lvl, bool log_pid, bool log_tstamp); + /** * nvme_get_logging_level() - Get current logging level * @r: nvme_root_t context @@ -59,24 +71,27 @@ int nvme_get_logging_level(nvme_root_t r, bool *log_pid, bool *log_tstamp); * will be set as well. This means the global root object is always pointing to * the latest created root object. Note the first @nvme_free_tree call will reset * the global root object. + * + * This function is deprecated. Use nvme_init_default_logging or/and + * nvme_init_logging instead. */ -void nvme_set_root(nvme_root_t r); +void nvme_set_root(nvme_root_t r) __attribute__((deprecated)); /** * nvme_set_debug - Set NVMe command debugging output * @debug: true to enable or false to disable * - * Don't use it, it's debricated. + * This function is deprecated. Use nvme_init_default_logging instead. */ -void nvme_set_debug(bool debug); +void nvme_set_debug(bool debug) __attribute__((deprecated)); /** * nvme_get_debug - Get NVMe command debugging output * - * Don't use it, it's debricated. + * This function is deprecated. Use nvme_get_logging_level instead. * * Return: false if disabled or true if enabled. */ -bool nvme_get_debug(void); +bool nvme_get_debug(void) __attribute__((deprecated)); #endif /* _LOG_H */ diff --git a/src/nvme/mi-mctp.c b/src/nvme/mi-mctp.c index 86c4c29..2f1c02d 100644 --- a/src/nvme/mi-mctp.c +++ b/src/nvme/mi-mctp.c @@ -506,8 +506,6 @@ nvme_mi_ep_t nvme_mi_open_mctp(nvme_root_t root, unsigned int netid, __u8 eid) */ ep->timeout = 5000; - nvme_mi_ep_probe(ep); - return ep; err_free_rspbuf: @@ -595,7 +593,7 @@ static int handle_mctp_endpoint(nvme_root_t root, const char* objpath, bool have_eid = false, have_net = false, have_nvmemi = false; mctp_eid_t eid; int net; - int rc; + int rc = 0; /* for each property */ for (;;) { diff --git a/src/nvme/mi.c b/src/nvme/mi.c index 84d51b0..d98c74a 100644 --- a/src/nvme/mi.c +++ b/src/nvme/mi.c @@ -11,6 +11,7 @@ #include #include #include +#include #include #include @@ -41,18 +42,32 @@ static bool nvme_mi_probe_enabled_default(void) */ nvme_root_t nvme_mi_create_root(FILE *fp, int log_level) { - struct nvme_root *r = calloc(1, sizeof(*r)); + struct nvme_root *r; + int fd; + r = calloc(1, sizeof(*r)); if (!r) { + errno = ENOMEM; return NULL; } - r->log_level = log_level; - r->fp = stderr; + + if (fp) { + fd = fileno(fp); + if (fd < 0) { + free(r); + return NULL; + } + } else + fd = STDERR_FILENO; + + r->log.fd = fd; + r->log.level = log_level; + r->mi_probe_enabled = nvme_mi_probe_enabled_default(); - if (fp) - r->fp = fp; + list_head_init(&r->hosts); list_head_init(&r->endpoints); + return r; } @@ -128,6 +143,20 @@ void nvme_mi_ep_probe(struct nvme_mi_ep *ep) struct nvme_mi_ctrl *ctrl; int rc; + /* Ensure the probe occurs at most once. This isn't just to mitigate doubling + * a linear stream of commands, it also terminates recursion via the + * nvme_mi_submit() call issued by nvme_mi_admin_identify_partial() below. + */ + if (ep->quirks_probed) + return; + + /* Mark ep->quirks as valid. Note that for the purpose of quirk probing, + * the quirk probe itself cannot rely on quirks, and so the fact that none are + * yet set is desirable. The request that triggered nvme_mi_submit() will have + * an initialised ep->quirks when we return from the root probe call. + */ + ep->quirks_probed = true; + if (!ep->root->mi_probe_enabled) return; @@ -250,6 +279,7 @@ struct nvme_mi_ep *nvme_mi_init_ep(nvme_root_t root) list_node_init(&ep->root_entry); ep->root = root; + ep->quirks_probed = false; ep->controllers_scanned = false; ep->timeout = default_timeout; ep->mprt_max = 0; @@ -327,7 +357,7 @@ int nvme_mi_scan_ep(nvme_mi_ep_t ep, bool force_rescan) rc = nvme_mi_mi_read_mi_data_ctrl_list(ep, 0, &list); if (rc) - return -1; + return rc; n_ctrl = le16_to_cpu(list.num); if (n_ctrl > NVME_ID_CTRL_LIST_MAX) { @@ -413,6 +443,8 @@ int nvme_mi_submit(nvme_mi_ep_t ep, struct nvme_mi_req *req, return -1; } + nvme_mi_ep_probe(ep); + if (ep->transport->mic_enabled) nvme_mi_calc_req_mic(req); @@ -639,6 +671,7 @@ int nvme_mi_admin_admin_passthru(nvme_mi_ctrl_t ctrl, __u8 opcode, __u8 flags, struct nvme_mi_admin_req_hdr req_hdr; struct nvme_mi_resp resp; struct nvme_mi_req req; + unsigned int timeout_save; int rc; int direction = opcode & 0x3; bool has_write_data = false; @@ -665,11 +698,6 @@ int nvme_mi_admin_admin_passthru(nvme_mi_ctrl_t ctrl, __u8 opcode, __u8 flags, has_read_data = true; } - if (timeout_ms > nvme_mi_ep_get_timeout(ctrl->ep)) { - /* Set timeout if user needs a bigger timeout */ - nvme_mi_ep_set_timeout(ctrl->ep, timeout_ms); - } - nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, opcode); req_hdr.cdw1 = cpu_to_le32(nsid); req_hdr.cdw2 = cpu_to_le32(cdw2); @@ -701,7 +729,17 @@ int nvme_mi_admin_admin_passthru(nvme_mi_ctrl_t ctrl, __u8 opcode, __u8 flags, resp.data_len = data_len; } + /* if the user has specified a custom timeout, save the current + * timeout and override + */ + if (timeout_ms != 0) { + timeout_save = nvme_mi_ep_get_timeout(ctrl->ep); + nvme_mi_ep_set_timeout(ctrl->ep, timeout_ms); + } rc = nvme_mi_submit(ctrl->ep, &req, &resp); + if (timeout_ms != 0) + nvme_mi_ep_set_timeout(ctrl->ep, timeout_save); + if (rc) return rc; @@ -896,6 +934,133 @@ int nvme_mi_admin_get_log(nvme_mi_ctrl_t ctrl, struct nvme_get_log_args *args) return nvme_mi_admin_get_log_page(ctrl, 4096, args); } +static int read_ana_chunk(nvme_mi_ctrl_t ctrl, enum nvme_log_ana_lsp lsp, bool rae, + __u8 *log, __u8 **read, __u8 *to_read, __u8 *log_end) +{ + if (to_read > log_end) { + errno = ENOSPC; + return -1; + } + + while (*read < to_read) { + __u32 len = min(log_end - *read, NVME_LOG_PAGE_PDU_SIZE); + int ret; + + ret = nvme_mi_admin_get_log_ana(ctrl, lsp, rae, + *read - log, len, *read); + if (ret) + return ret; + + *read += len; + } + return 0; +} + +static int try_read_ana(nvme_mi_ctrl_t ctrl, enum nvme_log_ana_lsp lsp, bool rae, + struct nvme_ana_log *log, __u8 *log_end, + __u8 *read, __u8 **to_read, bool *may_retry) +{ + __u16 ngrps = le16_to_cpu(log->ngrps); + + while (ngrps--) { + __u8 *group = *to_read; + int ret; + __le32 nnsids; + + *to_read += sizeof(*log->descs); + ret = read_ana_chunk(ctrl, lsp, rae, + (__u8 *)log, &read, *to_read, log_end); + if (ret) { + /* + * If the provided buffer isn't long enough, + * the log page may have changed while reading it + * and the computed length was inaccurate. + * Have the caller check chgcnt and retry. + */ + *may_retry = errno == ENOSPC; + return ret; + } + + /* + * struct nvme_ana_group_desc has 8-byte alignment + * but the group pointer is only 4-byte aligned. + * Don't dereference the misaligned pointer. + */ + memcpy(&nnsids, + group + offsetof(struct nvme_ana_group_desc, nnsids), + sizeof(nnsids)); + *to_read += le32_to_cpu(nnsids) * sizeof(__le32); + ret = read_ana_chunk(ctrl, lsp, rae, + (__u8 *)log, &read, *to_read, log_end); + if (ret) { + *may_retry = errno == ENOSPC; + return ret; + } + } + + *may_retry = true; + return 0; +} + +int nvme_mi_admin_get_ana_log_atomic(nvme_mi_ctrl_t ctrl, bool rgo, bool rae, + unsigned int retries, + struct nvme_ana_log *log, __u32 *len) +{ + const enum nvme_log_ana_lsp lsp = + rgo ? NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY : 0; + /* Get Log Page can only fetch multiples of dwords */ + __u8 * const log_end = (__u8 *)log + (*len & -4); + __u8 *read = (__u8 *)log; + __u8 *to_read; + int ret; + + if (!retries) { + errno = EINVAL; + return -1; + } + + to_read = (__u8 *)log->descs; + ret = read_ana_chunk(ctrl, lsp, rae, + (__u8 *)log, &read, to_read, log_end); + if (ret) + return ret; + + do { + bool may_retry = false; + int saved_ret; + int saved_errno; + __le64 chgcnt; + + saved_ret = try_read_ana(ctrl, lsp, rae, log, log_end, + read, &to_read, &may_retry); + /* + * If the log page was read with multiple Get Log Page commands, + * chgcnt must be checked afterwards to ensure atomicity + */ + *len = to_read - (__u8 *)log; + if (*len <= NVME_LOG_PAGE_PDU_SIZE || !may_retry) + return saved_ret; + + saved_errno = errno; + chgcnt = log->chgcnt; + read = (__u8 *)log; + to_read = (__u8 *)log->descs; + ret = read_ana_chunk(ctrl, lsp, rae, + (__u8 *)log, &read, to_read, log_end); + if (ret) + return ret; + + if (log->chgcnt == chgcnt) { + /* Log hasn't changed; return try_read_ana() result */ + errno = saved_errno; + return saved_ret; + } + } while (--retries); + + errno = EAGAIN; + return -1; +} + int nvme_mi_admin_security_send(nvme_mi_ctrl_t ctrl, struct nvme_security_send_args *args) { @@ -1003,8 +1168,10 @@ int nvme_mi_admin_get_features(nvme_mi_ctrl_t ctrl, struct nvme_mi_req req; int rc; - if (args->args_size < sizeof(*args)) - return -EINVAL; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_get_features); @@ -1042,8 +1209,10 @@ int nvme_mi_admin_set_features(nvme_mi_ctrl_t ctrl, struct nvme_mi_req req; int rc; - if (args->args_size < sizeof(*args)) - return -EINVAL; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_set_features); @@ -1140,8 +1309,10 @@ int nvme_mi_admin_ns_attach(nvme_mi_ctrl_t ctrl, struct nvme_mi_req req; int rc; - if (args->args_size < sizeof(*args)) - return -EINVAL; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_ns_attach); @@ -1173,17 +1344,20 @@ int nvme_mi_admin_fw_download(nvme_mi_ctrl_t ctrl, struct nvme_mi_req req; int rc; - if (args->args_size < sizeof(*args)) - return -EINVAL; - - if (args->data_len & 0x3) - return -EINVAL; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } - if (args->offset & 0x3) - return -EINVAL; + if ((args->data_len & 0x3) || (!args->data_len)) { + errno = EINVAL; + return -1; + } - if (!args->data_len) - return -EINVAL; + if (args->offset & 0x3) { + errno = EINVAL; + return -1; + } nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_fw_download); @@ -1215,8 +1389,10 @@ int nvme_mi_admin_fw_commit(nvme_mi_ctrl_t ctrl, struct nvme_mi_req req; int rc; - if (args->args_size < sizeof(*args)) - return -EINVAL; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_fw_commit); @@ -1245,8 +1421,10 @@ int nvme_mi_admin_format_nvm(nvme_mi_ctrl_t ctrl, struct nvme_mi_req req; int rc; - if (args->args_size < sizeof(*args)) - return -EINVAL; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_format_nvm); @@ -1279,8 +1457,10 @@ int nvme_mi_admin_sanitize_nvm(nvme_mi_ctrl_t ctrl, struct nvme_mi_req req; int rc; - if (args->args_size < sizeof(*args)) - return -EINVAL; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_sanitize_nvm); diff --git a/src/nvme/mi.h b/src/nvme/mi.h index bd26627..ae32a90 100644 --- a/src/nvme/mi.h +++ b/src/nvme/mi.h @@ -1917,7 +1917,7 @@ static inline int nvme_mi_admin_get_log_predictable_lat_event(nvme_mi_ctrl_t ctr * the asymmetric namespace access information for ANA Groups that contain * namespaces that are attached to the controller processing the command. * - * See &struct nvme_ana_rsp_hdr for the definition of the returned structure. + * See &struct nvme_ana_log for the definition of the returned structure. * * Return: The nvme command status if a response was received (see * &enum nvme_status_field) or -1 with errno set otherwise. @@ -1938,7 +1938,7 @@ static inline int nvme_mi_admin_get_log_ana(nvme_mi_ctrl_t ctrl, .lsi = NVME_LOG_LSI_NONE, .lsp = (__u8)lsp, .uuidx = NVME_UUID_NONE, - .rae = false, + .rae = rae, .ot = false, }; return nvme_mi_admin_get_log(ctrl, &args); @@ -1965,6 +1965,31 @@ static inline int nvme_mi_admin_get_log_ana_groups(nvme_mi_ctrl_t ctrl, len, log); } +/** + * nvme_mi_admin_get_ana_log_atomic() - Retrieve Asymmetric Namespace Access + * log page atomically + * @ctrl: Controller to query + * @rgo: Whether to retrieve ANA groups only (no NSIDs) + * @rae: Whether to retain asynchronous events + * @retries: The maximum number of times to retry on log page changes + * @log: Pointer to a buffer to receive the ANA log page + * @len: Input: the length of the log page buffer. + * Output: the actual length of the ANA log page. + * + * See &struct nvme_ana_log for the definition of the returned structure. + * + * Return: If successful, returns 0 and sets *len to the actual log page length. + * If unsuccessful, returns the nvme command status if a response was received + * (see &enum nvme_status_field) or -1 with errno set otherwise. + * Sets errno = EINVAL if retries == 0. + * Sets errno = EAGAIN if unable to read the log page atomically + * because chgcnt changed during each of the retries attempts. + * Sets errno = ENOSPC if the full log page does not fit in the provided buffer. + */ +int nvme_mi_admin_get_ana_log_atomic(nvme_mi_ctrl_t ctrl, bool rgo, bool rae, + unsigned int retries, + struct nvme_ana_log *log, __u32 *len); + /** * nvme_mi_admin_get_log_lba_status() - Retrieve LBA Status * @ctrl: Controller to query diff --git a/src/nvme/private.h b/src/nvme/private.h index dec3d85..3fa5aca 100644 --- a/src/nvme/private.h +++ b/src/nvme/private.h @@ -160,17 +160,22 @@ struct nvme_fabric_options { bool trsvcid; }; +struct nvme_log { + int fd; + int level; + bool pid; + bool timestamp; +}; + struct nvme_root { char *config_file; char *application; struct list_head hosts; struct list_head endpoints; /* MI endpoints */ - FILE *fp; - int log_level; - bool log_pid; - bool log_timestamp; + struct nvme_log log; bool modified; bool mi_probe_enabled; + bool create_only; struct nvme_fabric_options *options; }; @@ -198,14 +203,10 @@ void *__nvme_realloc(void *p, size_t len); #endif void __attribute__((format(printf, 4, 5))) -__nvme_msg(nvme_root_t r, int lvl, const char *func, const char *format, ...); +__nvme_msg(nvme_root_t r, int level, const char *func, const char *format, ...); -#define nvme_msg(r, lvl, format, ...) \ - do { \ - if ((lvl) <= MAX_LOGLEVEL) \ - __nvme_msg(r, lvl, __nvme_log_func, \ - format, ##__VA_ARGS__); \ - } while (0) +#define nvme_msg(r, level, format, ...) \ + __nvme_msg(r, level, __nvme_log_func, format, ##__VA_ARGS__) #define root_from_ctrl(c) ((c)->s && (c)->s->h ? (c)->s->h->r : NULL) #define root_from_ns(n) ((n)->s && (n)->s->h ? (n)->s->h->r : \ @@ -256,6 +257,7 @@ struct nvme_mi_ep { void *transport_data; struct list_node root_entry; struct list_head controllers; + bool quirks_probed; bool controllers_scanned; unsigned int timeout; unsigned int mprt_max; diff --git a/src/nvme/tree.c b/src/nvme/tree.c index eb9486d..3722461 100644 --- a/src/nvme/tree.c +++ b/src/nvme/tree.c @@ -117,16 +117,99 @@ static void cleanup_dirents(struct dirents *ents) #define _cleanup_dirents_ __cleanup__(cleanup_dirents) +static char *nvme_hostid_from_hostnqn(const char *hostnqn) +{ + const char *uuid; + + uuid = strstr(hostnqn, "uuid:"); + if (!uuid) + return NULL; + + return strdup(uuid + strlen("uuid:")); +} + +int nvme_host_get_ids(nvme_root_t r, + char *hostnqn_arg, char *hostid_arg, + char **hostnqn, char **hostid) +{ + _cleanup_free_ char *nqn = NULL; + _cleanup_free_ char *hid = NULL; + _cleanup_free_ char *hnqn = NULL; + nvme_host_t h; + + /* command line argumments */ + if (hostid_arg) + hid = strdup(hostid_arg); + if (hostnqn_arg) + hnqn = strdup(hostnqn_arg); + + /* JSON config: assume the first entry is the default host */ + h = nvme_first_host(r); + if (h) { + if (!hid) + hid = strdup(nvme_host_get_hostid(h)); + if (!hnqn) + hnqn = strdup(nvme_host_get_hostnqn(h)); + } + + /* /etc/nvme/hostid and/or /etc/nvme/hostnqn */ + if (!hid) + hid = nvmf_hostid_from_file(); + if (!hnqn) + hnqn = nvmf_hostnqn_from_file(); + + /* incomplete configuration, thus derive hostid from hostnqn */ + if (!hid && hnqn) + hid = nvme_hostid_from_hostnqn(hnqn); + + /* + * fallback to use either DMI information or device-tree. If all + * fails generate one + */ + if (!hid) { + hid = nvmf_hostid_generate(); + if (!hid) { + errno = -ENOMEM; + return -1; + } + + nvme_msg(r, LOG_DEBUG, + "warning: using auto generated hostid and hostnqn\n"); + } + + /* incomplete configuration, thus derive hostnqn from hostid */ + if (!hnqn) { + hnqn = nvmf_hostnqn_generate_from_hostid(hid); + if (!hnqn) { + errno = -ENOMEM; + return -1; + } + } + + /* sanity checks */ + nqn = nvme_hostid_from_hostnqn(hnqn); + if (nqn && strcmp(nqn, hid)) { + nvme_msg(r, LOG_DEBUG, + "warning: use hostid '%s' which does not match uuid in hostnqn '%s'\n", + hid, hnqn); + } + + *hostid = hid; + *hostnqn = hnqn; + hid = NULL; + hnqn = NULL; + + return 0; +} + nvme_host_t nvme_default_host(nvme_root_t r) { - struct nvme_host *h; _cleanup_free_ char *hostnqn = NULL; _cleanup_free_ char *hostid = NULL; + struct nvme_host *h; - hostnqn = nvmf_hostnqn_from_file(); - if (!hostnqn) - hostnqn = nvmf_hostnqn_generate(); - hostid = nvmf_hostid_from_file(); + if (nvme_host_get_ids(r, NULL, NULL, &hostnqn, &hostid)) + return NULL; h = nvme_lookup_host(r, hostnqn, hostid); @@ -187,25 +270,37 @@ int nvme_scan_topology(struct nvme_root *r, nvme_scan_filter_t f, void *f_args) nvme_root_t nvme_create_root(FILE *fp, int log_level) { - struct nvme_root *r = calloc(1, sizeof(*r)); + struct nvme_root *r; + int fd; + r = calloc(1, sizeof(*r)); if (!r) { errno = ENOMEM; return NULL; } - r->log_level = log_level; - r->fp = stderr; - if (fp) - r->fp = fp; + + if (fp) { + fd = fileno(fp); + if (fd < 0) { + free(r); + return NULL; + } + } else + fd = STDERR_FILENO; + + r->log.fd = fd; + r->log.level = log_level; + list_head_init(&r->hosts); list_head_init(&r->endpoints); - nvme_set_root(r); + return r; } int nvme_read_config(nvme_root_t r, const char *config_file) { int err = -1; + int tmp; if (!r || !config_file) { errno = ENODEV; @@ -217,13 +312,17 @@ int nvme_read_config(nvme_root_t r, const char *config_file) errno = ENOMEM; return err; } + + tmp = errno; err = json_read_config(r, config_file); /* * The json configuration file is optional, * so ignore errors when opening the file. */ - if (err < 0 && errno != EPROTO) - err = 0; + if (err < 0 && errno != EPROTO) { + errno = tmp; + return 0; + } return err; } @@ -270,6 +369,11 @@ void nvme_root_set_application(nvme_root_t r, const char *a) r->application = strdup(a); } +void nvme_root_skip_namespaces(nvme_root_t r) +{ + r->create_only = true; +} + nvme_host_t nvme_first_host(nvme_root_t r) { return list_top(&r->hosts, struct nvme_host, entry); @@ -361,14 +465,17 @@ void nvme_free_tree(nvme_root_t r) { struct nvme_host *h, *_h; - free(r->options); + if (!r) + return; + + if (r->options) + free(r->options); nvme_for_each_host_safe(r, h, _h) __nvme_free_host(h); if (r->config_file) free(r->config_file); if (r->application) free(r->application); - nvme_set_root(NULL); free(r); } @@ -538,7 +645,7 @@ struct nvme_subsystem *nvme_alloc_subsystem(struct nvme_host *h, list_head_init(&s->ctrls); list_head_init(&s->namespaces); list_node_init(&s->entry); - list_add(&h->subsystems, &s->entry); + list_add_tail(&h->subsystems, &s->entry); h->r->modified = true; return s; } @@ -622,7 +729,7 @@ struct nvme_host *nvme_lookup_host(nvme_root_t r, const char *hostnqn, list_head_init(&h->subsystems); list_node_init(&h->entry); h->r = r; - list_add(&r->hosts, &h->entry); + list_add_tail(&r->hosts, &h->entry); r->modified = true; return h; @@ -634,6 +741,12 @@ static int nvme_subsystem_scan_namespaces(nvme_root_t r, nvme_subsystem_t s, _cleanup_dirents_ struct dirents namespaces = {}; int i, ret; + if (r->create_only) { + nvme_msg(r, LOG_DEBUG, + "skipping namespace scan for subsys %s\n", + s->subsysnqn); + return 0; + } namespaces.num = nvme_scan_subsystem_namespaces(s, &namespaces.ents); if (namespaces.num < 0) { nvme_msg(r, LOG_DEBUG, @@ -806,7 +919,7 @@ static void nvme_subsystem_set_path_ns(nvme_subsystem_t s, nvme_path_t p) sprintf(n_name, "nvme%dn%d", i, nsid); nvme_subsystem_for_each_ns(s, n) { if (!strcmp(n_name, nvme_ns_get_name(n))) { - list_add(&n->paths, &p->nentry); + list_add_tail(&n->paths, &p->nentry); p->n = n; } } @@ -852,7 +965,7 @@ static int nvme_ctrl_scan_path(nvme_root_t r, struct nvme_ctrl *c, char *name) list_node_init(&p->nentry); nvme_subsystem_set_path_ns(c->s, p); list_node_init(&p->entry); - list_add(&c->paths, &p->entry); + list_add_tail(&c->paths, &p->entry); return 0; } @@ -1591,8 +1704,8 @@ nvme_ctrl_t __nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport, const char *host_iface, const char *trsvcid, const char *subsysnqn, nvme_ctrl_t p) { + _cleanup_candidate_ struct candidate_args candidate = {}; struct nvme_ctrl *c, *matching_c = NULL; - _cleanup_candidate_ struct candidate_args candidate; ctrl_match_t ctrl_match; /* Init candidate and get the matching function to use */ @@ -1615,8 +1728,8 @@ bool nvme_ctrl_config_match(struct nvme_ctrl *c, const char *transport, const char *subsysnqn, const char *host_traddr, const char *host_iface) { + _cleanup_candidate_ struct candidate_args candidate = {}; ctrl_match_t ctrl_match; - _cleanup_candidate_ struct candidate_args candidate; /* Init candidate and get the matching function to use */ ctrl_match = _candidate_init(&candidate, transport, traddr, trsvcid, @@ -1655,7 +1768,7 @@ nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport, host_traddr, host_iface, trsvcid); if (c) { c->s = s; - list_add(&s->ctrls, &c->entry); + list_add_tail(&s->ctrls, &c->entry); s->h->r->modified = true; } return c; @@ -1666,6 +1779,11 @@ static int nvme_ctrl_scan_paths(nvme_root_t r, struct nvme_ctrl *c) _cleanup_dirents_ struct dirents paths = {}; int i; + if (r->create_only) { + nvme_msg(r, LOG_DEBUG, + "skipping path scan for ctrl %s\n", c->name); + return 0; + } paths.num = nvme_scan_ctrl_namespace_paths(c, &paths.ents); if (paths.num < 0) return paths.num; @@ -1681,6 +1799,11 @@ static int nvme_ctrl_scan_namespaces(nvme_root_t r, struct nvme_ctrl *c) _cleanup_dirents_ struct dirents namespaces = {}; int i; + if (r->create_only) { + nvme_msg(r, LOG_DEBUG, "skipping namespace scan for ctrl %s\n", + c->name); + return 0; + } namespaces.num = nvme_scan_ctrl_namespaces(c, &namespaces.ents); for (i = 0; i < namespaces.num; i++) nvme_ctrl_scan_namespace(r, c, namespaces.ents[i]->d_name); @@ -1749,6 +1872,10 @@ static char *nvme_ctrl_lookup_phy_slot(nvme_root_t r, const char *address) return NULL; } addr = nvme_get_attr(path, "address"); + + /* some directories don't have an address entry */ + if (!addr) + continue; if (strcmp(addr, target_addr) == 0) return strdup(entry->d_name); } @@ -1861,7 +1988,7 @@ int nvme_init_ctrl(nvme_host_t h, nvme_ctrl_t c, int instance) if (s->subsystype && !strcmp(s->subsystype, "discovery")) c->discovery_ctrl = true; c->s = s; - list_add(&s->ctrls, &c->entry); + list_add_tail(&s->ctrls, &c->entry); return ret; } @@ -2635,7 +2762,7 @@ static int nvme_ctrl_scan_namespace(nvme_root_t r, struct nvme_ctrl *c, } n->s = c->s; n->c = c; - list_add(&c->namespaces, &n->entry); + list_add_tail(&c->namespaces, &n->entry); return 0; } @@ -2658,7 +2785,7 @@ static void nvme_subsystem_set_ns_path(nvme_subsystem_t s, nvme_ns_t n) if (ret != 3) continue; if (ns_ctrl == p_subsys && ns_nsid == p_nsid) { - list_add(&n->paths, &p->nentry); + list_add_tail(&n->paths, &p->nentry); p->n = n; } } @@ -2696,7 +2823,7 @@ static int nvme_subsystem_scan_namespace(nvme_root_t r, nvme_subsystem_t s, __nvme_free_ns(_n); } n->s = s; - list_add(&s->namespaces, &n->entry); + list_add_tail(&s->namespaces, &n->entry); nvme_subsystem_set_ns_path(s, n); return 0; } diff --git a/src/nvme/tree.h b/src/nvme/tree.h index 5e82579..1b583cd 100644 --- a/src/nvme/tree.h +++ b/src/nvme/tree.h @@ -62,6 +62,14 @@ void nvme_root_set_application(nvme_root_t r, const char *a); */ const char *nvme_root_get_application(nvme_root_t r); +/** + * nvme_root_skip_namespaces - Skip namespace scanning + * @r: &nvme_root_t object + * + * Sets a flag to skip namespaces during scanning. + */ +void nvme_root_skip_namespaces(nvme_root_t r); + /** * nvme_root_release_fds - Close all opened file descriptors in the tree * @r: &nvme_root_t object @@ -161,13 +169,48 @@ bool nvme_host_is_pdc_enabled(nvme_host_t h, bool fallback); * nvme_default_host() - Initializes the default host * @r: &nvme_root_t object * - * Initializes the default host object based on the values in - * /etc/nvme/hostnqn and /etc/nvme/hostid and attaches it to @r. + * Initializes the default host object based on the hostnqn/hostid + * values returned by nvme_host_get_ids() and attaches it to @r. * * Return: &nvme_host_t object */ nvme_host_t nvme_default_host(nvme_root_t r); +/** + * nvme_host_get_ids - Retrieve host ids from various sources + * + * @r: &nvme_root_t object + * @hostnqn_arg: Input hostnqn (command line) argument + * @hostid_arg: Input hostid (command line) argument + * @hostnqn: Output hostnqn + * @hostid: Output hostid + * + * nvme_host_get_ids figures out which hostnqn/hostid is to be used. + * There are several sources where this information can be retrieved. + * + * The order is: + * + * - Start with informartion from DMI or device-tree + * - Override hostnqn and hostid from /etc/nvme files + * - Override hostnqn or hostid with values from JSON + * configuration file. The first host entry in the file is + * considered the default host. + * - Override hostnqn or hostid with values from the command line + * (@hostnqn_arg, @hostid_arg). + * + * If the IDs are still NULL after the lookup algorithm, the function + * will generate random IDs. + * + * The function also verifies that hostnqn and hostid matches. The Linux + * NVMe implementation expects a 1:1 matching between the IDs. + * + * Return: 0 on success (@hostnqn and @hostid contain valid strings + * which the caller needs to free), -1 otherwise and errno is set. + */ +int nvme_host_get_ids(nvme_root_t r, + char *hostnqn_arg, char *hostid_arg, + char **hostnqn, char **hostid); + /** * nvme_first_subsystem() - Start subsystem iterator * @h: &nvme_host_t object diff --git a/src/nvme/types.h b/src/nvme/types.h index 26e5e25..5fa969d 100644 --- a/src/nvme/types.h +++ b/src/nvme/types.h @@ -1570,6 +1570,8 @@ enum nvme_id_ctrl_oaes { * @NVME_CTRL_CTRATT_DEL_ENDURANCE_GROUPS: Delete Endurance Groups supported * @NVME_CTRL_CTRATT_DEL_NVM_SETS: Delete NVM Sets supported * @NVME_CTRL_CTRATT_ELBAS: Extended LBA Formats supported + * @NVME_CTRL_CTRATT_MEM: MDTS and Size Limits Exclude Metadata supported + * @NVME_CTRL_CTRATT_HMBR: HMB Restrict Non-Operational Power State Access * @NVME_CTRL_CTRATT_FDPS: Flexible Data Placement supported */ enum nvme_id_ctrl_ctratt { @@ -1589,6 +1591,8 @@ enum nvme_id_ctrl_ctratt { NVME_CTRL_CTRATT_DEL_ENDURANCE_GROUPS = 1 << 13, NVME_CTRL_CTRATT_DEL_NVM_SETS = 1 << 14, NVME_CTRL_CTRATT_ELBAS = 1 << 15, + NVME_CTRL_CTRATT_MEM = 1 << 16, + NVME_CTRL_CTRATT_HMBR = 1 << 17, NVME_CTRL_CTRATT_FDPS = 1 << 19, }; @@ -2298,7 +2302,7 @@ enum nvme_id_nsfeat { NVME_NS_FEAT_NATOMIC = 1 << 1, NVME_NS_FEAT_DULBE = 1 << 2, NVME_NS_FEAT_ID_REUSE = 1 << 3, - NVME_NS_FEAT_IO_OPT = 1 << 4, + NVME_NS_FEAT_IO_OPT = 3 << 4, }; /** @@ -2332,10 +2336,31 @@ enum nvme_id_ns_flbas { * the variable-sized storage tag/reference tag fields * @NVME_NVM_ELBAF_PIF_MASK: Mask to get the protection information format for * the extended LBA format. + * @NVME_NVM_ELBAF_QPIF_MASK: Mask to get the Qualified Protection Information + * Format. */ enum nvme_nvm_id_ns_elbaf { NVME_NVM_ELBAF_STS_MASK = 127 << 0, NVME_NVM_ELBAF_PIF_MASK = 3 << 7, + NVME_NVM_ELBAF_QPIF_MASK = 15 << 9, +}; + +/** + * enum nvme_nvm_id_ns_pif - This field indicates the type of the Protection + * Information Format + * @NVME_NVM_PIF_16B_GUARD: 16-bit Guard Protection Information Format + * @NVME_NVM_PIF_32B_GUARD: 32-bit Guard Protection Information Format + * @NVME_NVM_PIF_64B_GUARD: 64-bit Guard Protection Information Format + * @NVME_NVM_PIF_QTYPE: If Qualified Protection Information Format Supports + * and Protection Information Format is set to 3, then + * protection information format is taken from Qualified + * Protection Information Format field. + */ +enum nvme_nvm_id_ns_pif { + NVME_NVM_PIF_16B_GUARD = 0, + NVME_NVM_PIF_32B_GUARD = 1, + NVME_NVM_PIF_64B_GUARD = 2, + NVME_NVM_PIF_QTYPE = 3, }; /** @@ -2683,32 +2708,44 @@ struct nvme_ns_list { * @dmrl: Dataset Management Ranges Limit * @dmrsl: Dataset Management Range Size Limit * @dmsl: Dataset Management Size Limit - * @rsvd16: reserved + * @rsvd16: Reserved + * @aocs: Admin Optional Command Support + * @rsvd20: Reserved */ struct nvme_id_ctrl_nvm { - __u8 vsl; - __u8 wzsl; - __u8 wusl; - __u8 dmrl; - __le32 dmrsl; - __le64 dmsl; - __u8 rsvd16[4080]; + __u8 vsl; + __u8 wzsl; + __u8 wusl; + __u8 dmrl; + __le32 dmrsl; + __le64 dmsl; + __u8 rsvd16[2]; + __le16 aocs; + __u8 rsvd20[4076]; }; /** * struct nvme_nvm_id_ns - NVME Command Set I/O Command Set Specific Identify Namespace Data Structure * @lbstm: Logical Block Storage Tag Mask * @pic: Protection Information Capabilities - * @rsvd9: Reserved + * @pifa: Protection Information Format Attribute + * @rsvd10: Reserved * @elbaf: List of Extended LBA Format Support - * @rsvd268: Reserved + * @npdgl: Namespace Preferred Deallocate Granularity Large + * @rsvd272: Reserved + * @tlbaag: Tracked LBA Allocation Granularity + * @rsvd296: Reserved */ struct nvme_nvm_id_ns { __le64 lbstm; __u8 pic; - __u8 rsvd9[3]; + __u8 pifa; + __u8 rsvd10[2]; __le32 elbaf[64]; - __u8 rsvd268[3828]; + __le32 npdgl; + __u8 rsvd272[20]; + __le32 tlbaag; + __u8 rsvd296[3800]; }; /** @@ -3847,6 +3884,8 @@ struct nvme_persistent_event_entry { * @NVME_PEL_SET_FEATURE_EVENT: Set Feature Event * @NVME_PEL_TELEMETRY_CRT: Telemetry Log Create Event * @NVME_PEL_THERMAL_EXCURSION_EVENT: Thermal Excursion Event + * @NVME_PEL_VENDOR_SPECIFIC_EVENT: Vendor Specific Event + * @NVME_PEL_TCG_DEFINED_EVENT: TCG Defined Event */ enum nvme_persistent_event_types { NVME_PEL_SMART_HEALTH_EVENT = 0x01, @@ -3862,6 +3901,8 @@ enum nvme_persistent_event_types { NVME_PEL_SET_FEATURE_EVENT = 0x0b, NVME_PEL_TELEMETRY_CRT = 0x0c, NVME_PEL_THERMAL_EXCURSION_EVENT = 0x0d, + NVME_PEL_VENDOR_SPECIFIC_EVENT = 0xde, + NVME_PEL_TCG_DEFINED_EVENT = 0xdf, }; /** @@ -4138,14 +4179,18 @@ struct nvme_lbas_ns_element { }; /** - * enum nvme_lba_status_atype - Potentially Unrecoverable LBAs - * @NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED: Potentially Unrecoverable LBAs - * @NVME_LBA_STATUS_ATYPE_SCAN_TRACKED: Potentially Unrecoverable LBAs - * associated with physical storage + * enum nvme_lba_status_atype - Action type the controller uses to return LBA status + * @NVME_LBA_STATUS_ATYPE_ALLOCATED: Return tracked allocated LBAs status + * @NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED: Perform scan and return Untracked and + * Tracked Potentially Unrecoverable LBAs + * status + * @NVME_LBA_STATUS_ATYPE_TRACKED: Return Tracked Potentially Unrecoverable + * LBAs associated with physical storage */ enum nvme_lba_status_atype { - NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED = 0x10, - NVME_LBA_STATUS_ATYPE_SCAN_TRACKED = 0x11, + NVME_LBA_STATUS_ATYPE_ALLOCATED = 0x2, + NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED = 0x10, + NVME_LBA_STATUS_ATYPE_TRACKED = 0x11, }; /** @@ -8248,6 +8293,7 @@ enum nvme_data_tfr { * @nvme_cmd_resv_acquire: Reservation Acquire * @nvme_cmd_io_mgmt_recv: I/O Management Receive * @nvme_cmd_resv_release: Reservation Release + * @nvme_cmd_cancel: Cancel * @nvme_cmd_copy: Copy * @nvme_cmd_io_mgmt_send: I/O Management Send * @nvme_zns_cmd_mgmt_send: Zone Management Send @@ -8268,6 +8314,7 @@ enum nvme_io_opcode { nvme_cmd_resv_acquire = 0x11, nvme_cmd_io_mgmt_recv = 0x12, nvme_cmd_resv_release = 0x15, + nvme_cmd_cancel = 0x18, nvme_cmd_copy = 0x19, nvme_cmd_io_mgmt_send = 0x1d, nvme_zns_cmd_mgmt_send = 0x79, diff --git a/src/nvme/util.c b/src/nvme/util.c index 7404509..ce0ce76 100644 --- a/src/nvme/util.c +++ b/src/nvme/util.c @@ -1144,7 +1144,7 @@ void *__nvme_realloc(void *p, size_t len) void *result = __nvme_alloc(len); - if (p) { + if (p && result) { memcpy(result, p, min(old_len, len)); free(p); } -- cgit v1.2.3