rpms/libnvme
7
0
Fork 0
Code Issues Pull Requests Releases Activity

import CS libnvme-1.9-3.el9

Browse Source
This commit is contained in:
eabdullin 2024-09-30 15:53:44 +00:00
parent 3c73f90106
commit 56c9539595
9 changed files with 662 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1 +1 @@
SOURCES/libnvme-1.6.tar.gz
SOURCES/libnvme-1.9.tar.gz

2
.libnvme.metadata
View File

@ -1 +1 @@
e4570f82f86ebeda9974a8884b2a74ce82767e7d SOURCES/libnvme-1.6.tar.gz
7ce814bb26bd5fc33b99f5ba48d99538f23756cd SOURCES/libnvme-1.9.tar.gz

32
SOURCES/0001-tree-handle-no-address-phy-slot-dirs.patch Normal file
View File

@ -0,0 +1,32 @@
From 49a4cd8f62d05bb4e1b6e1365bad638c366cdba9 Mon Sep 17 00:00:00 2001
From: Greg Joyce <gjoyce@linux.ibm.com>
Date: Tue, 23 Jul 2024 01:04:42 +0530
Subject: [PATCH] tree: handle no address phy slot dirs
Not all directories have an address. Verify addr before calling
strcmp().
Fixes: 42ac45359635 ("tree: Add PCI physical slot number for controller")
Signed-off-by: Greg Joyce <gjoyce@linux.ibm.com>
---
src/nvme/tree.c | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/nvme/tree.c b/src/nvme/tree.c
index 288b23c73a1b..b0ee94047634 100644
--- a/src/nvme/tree.c
+++ b/src/nvme/tree.c
@@ -1867,6 +1867,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);
}
--
2.43.0

58
SOURCES/0001-util-Introduce-alloc-helper-with-alignment-support.patch
View File

@ -1,58 +0,0 @@
From a2b8e52e46cfd888ac5a48d8ce632bd70a5caa93 Mon Sep 17 00:00:00 2001
From: Tomas Bzatek <tbzatek@redhat.com>
Date: Tue, 10 Oct 2023 18:16:24 +0200
Subject: [PATCH] util: Introduce alloc helper with alignment support
Similar to nvme-cli an alloc helper is needed for a couple
of ioctls sent out during tree scan.
Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
---
src/nvme/private.h | 2 ++
src/nvme/util.c | 13 +++++++++++++
2 files changed, 15 insertions(+)
diff --git a/src/nvme/private.h b/src/nvme/private.h
index 6fb9784a696d..ee9d738bd0af 100644
--- a/src/nvme/private.h
+++ b/src/nvme/private.h
@@ -182,6 +182,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);
+void *__nvme_alloc(size_t len);
+
#if (LOG_FUNCNAME == 1)
#define __nvme_log_func __func__
#else
diff --git a/src/nvme/util.c b/src/nvme/util.c
index 8fe094d55ef8..20679685bc8b 100644
--- a/src/nvme/util.c
+++ b/src/nvme/util.c
@@ -7,6 +7,7 @@
* Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
*/
+#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
@@ -1058,3 +1059,15 @@ bool nvme_iface_primary_addr_matches(const struct ifaddrs *iface_list, const cha
}
#endif /* HAVE_NETDB */
+
+void *__nvme_alloc(size_t len)
+{
+ size_t _len = round_up(len, 0x1000);
+ void *p;
+
+ if (posix_memalign((void *)&p, getpagesize(), _len))
+ return NULL;
+
+ memset(p, 0, _len);
+ return p;
+}
--
2.39.3

65
SOURCES/0002-tree-Allocate-aligned-payloads-for-ns-scan.patch
View File

@ -1,65 +0,0 @@
From 68c6ffb11d40a427fc1fd70ac2ac97fd01952913 Mon Sep 17 00:00:00 2001
From: Tomas Bzatek <tbzatek@redhat.com>
Date: Tue, 10 Oct 2023 18:18:38 +0200
Subject: [PATCH] tree: Allocate aligned payloads for ns scan
libnvme is actually doing some namespace identification
during tree scan, leading to stack smash on some systems.
Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
---
src/nvme/tree.c | 29 ++++++++++++++++++-----------
1 file changed, 18 insertions(+), 11 deletions(-)
diff --git a/src/nvme/tree.c b/src/nvme/tree.c
index 00cf96f7b458..5636aa1809ec 100644
--- a/src/nvme/tree.c
+++ b/src/nvme/tree.c
@@ -2404,26 +2404,33 @@ static void nvme_ns_parse_descriptors(struct nvme_ns *n,
static int nvme_ns_init(struct nvme_ns *n)
{
- struct nvme_id_ns ns = { };
- uint8_t buffer[NVME_IDENTIFY_DATA_SIZE] = { };
- struct nvme_ns_id_desc *descs = (void *)buffer;
+ struct nvme_id_ns *ns;
+ struct nvme_ns_id_desc *descs;
uint8_t flbas;
int ret;
- ret = nvme_ns_identify(n, &ns);
- if (ret)
+ ns = __nvme_alloc(sizeof(*ns));
+ if (!ns)
+ return 0;
+ ret = nvme_ns_identify(n, ns);
+ if (ret) {
+ free(ns);
return ret;
+ }
- nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &flbas);
- n->lba_shift = ns.lbaf[flbas].ds;
+ nvme_id_ns_flbas_to_lbaf_inuse(ns->flbas, &flbas);
+ n->lba_shift = ns->lbaf[flbas].ds;
n->lba_size = 1 << n->lba_shift;
- n->lba_count = le64_to_cpu(ns.nsze);
- n->lba_util = le64_to_cpu(ns.nuse);
- n->meta_size = le16_to_cpu(ns.lbaf[flbas].ms);
+ n->lba_count = le64_to_cpu(ns->nsze);
+ n->lba_util = le64_to_cpu(ns->nuse);
+ n->meta_size = le16_to_cpu(ns->lbaf[flbas].ms);
- if (!nvme_ns_identify_descs(n, descs))
+ descs = __nvme_alloc(NVME_IDENTIFY_DATA_SIZE);
+ if (descs && !nvme_ns_identify_descs(n, descs))
nvme_ns_parse_descriptors(n, descs);
+ free(ns);
+ free(descs);
return 0;
}
--
2.39.3

122
SOURCES/0003-linux-Allocate-aligned-payloads-for-id_ctrl-and-id_n.patch
View File

@ -1,122 +0,0 @@
From 3bf6e153a1c02b1c684ac3f5949cd32dec5f46c9 Mon Sep 17 00:00:00 2001
From: Tomas Bzatek <tbzatek@redhat.com>
Date: Thu, 12 Oct 2023 18:42:34 +0200
Subject: [PATCH] linux: Allocate aligned payloads for id_ctrl and id_ns calls
Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
---
src/nvme/linux.c | 61 ++++++++++++++++++++++++++++++++++--------------
1 file changed, 43 insertions(+), 18 deletions(-)
diff --git a/src/nvme/linux.c b/src/nvme/linux.c
index adbc4cdbd5f6..66be9eb81722 100644
--- a/src/nvme/linux.c
+++ b/src/nvme/linux.c
@@ -124,28 +124,37 @@ int nvme_fw_download_seq(int fd, __u32 size, __u32 xfer, __u32 offset,
int nvme_get_telemetry_max(int fd, enum nvme_telemetry_da *da, size_t *data_tx)
{
- struct nvme_id_ctrl id_ctrl;
- int err = nvme_identify_ctrl(fd, &id_ctrl);
+ struct nvme_id_ctrl *id_ctrl;
+ int err;
- if (err)
+ id_ctrl = __nvme_alloc(sizeof(*id_ctrl));
+ if (!id_ctrl) {
+ errno = ENOMEM;
+ return -1;
+ }
+ err = nvme_identify_ctrl(fd, id_ctrl);
+ if (err) {
+ free(id_ctrl);
return err;
+ }
if (data_tx) {
- *data_tx = id_ctrl.mdts;
- if (id_ctrl.mdts) {
+ *data_tx = id_ctrl->mdts;
+ if (id_ctrl->mdts) {
/* assuming CAP.MPSMIN is zero minimum Memory Page Size is at least
* 4096 bytes
*/
- *data_tx = (1 << id_ctrl.mdts) * 4096;
+ *data_tx = (1 << id_ctrl->mdts) * 4096;
}
}
if (da) {
- if (id_ctrl.lpa & 0x8)
+ if (id_ctrl->lpa & 0x8)
*da = NVME_TELEMETRY_DA_3;
- if (id_ctrl.lpa & 0x40)
+ if (id_ctrl->lpa & 0x40)
*da = NVME_TELEMETRY_DA_4;
}
+ free(id_ctrl);
return err;
}
@@ -376,32 +385,48 @@ int nvme_namespace_detach_ctrls(int fd, __u32 nsid, __u16 num_ctrls,
int nvme_get_ana_log_len(int fd, size_t *analen)
{
- struct nvme_id_ctrl ctrl;
+ struct nvme_id_ctrl *ctrl;
int ret;
- ret = nvme_identify_ctrl(fd, &ctrl);
- if (ret)
+ ctrl = __nvme_alloc(sizeof(*ctrl));
+ if (!ctrl) {
+ errno = ENOMEM;
+ return -1;
+ }
+ ret = nvme_identify_ctrl(fd, ctrl);
+ if (ret) {
+ free(ctrl);
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);
+ le32_to_cpu(ctrl->nanagrpid) * sizeof(struct nvme_ana_group_desc) +
+ le32_to_cpu(ctrl->mnan) * sizeof(__le32);
+ free(ctrl);
return 0;
}
int nvme_get_logical_block_size(int fd, __u32 nsid, int *blksize)
{
- struct nvme_id_ns ns;
+ struct nvme_id_ns *ns;
__u8 flbas;
int ret;
- ret = nvme_identify_ns(fd, nsid, &ns);
- if (ret)
+ ns = __nvme_alloc(sizeof(*ns));
+ if (!ns) {
+ errno = ENOMEM;
+ return -1;
+ }
+ ret = nvme_identify_ns(fd, nsid, ns);
+ if (ret) {
+ free(ns);
return ret;
+ }
- nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &flbas);
- *blksize = 1 << ns.lbaf[flbas].ds;
+ nvme_id_ns_flbas_to_lbaf_inuse(ns->flbas, &flbas);
+ *blksize = 1 << ns->lbaf[flbas].ds;
+ free(ns);
return 0;
}
--
2.39.3

80
SOURCES/0004-fabrics-Allocate-aligned-payloads-for-id_ctrl-and-di.patch
View File

@ -1,80 +0,0 @@
From da8c28e5e220be4742442114252d136097056928 Mon Sep 17 00:00:00 2001
From: Tomas Bzatek <tbzatek@redhat.com>
Date: Thu, 12 Oct 2023 18:43:16 +0200
Subject: [PATCH] fabrics: Allocate aligned payloads for id_ctrl and discovery
log calls
Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
---
src/nvme/fabrics.c | 29 +++++++++++++++++++----------
1 file changed, 19 insertions(+), 10 deletions(-)
diff --git a/src/nvme/fabrics.c b/src/nvme/fabrics.c
index 21fb29200b4b..2e48ac869679 100644
--- a/src/nvme/fabrics.c
+++ b/src/nvme/fabrics.c
@@ -1073,7 +1073,7 @@ static struct nvmf_discovery_log *nvme_discovery_log(nvme_ctrl_t c,
size = sizeof(struct nvmf_discovery_log);
free(log);
- log = calloc(1, size);
+ log = __nvme_alloc(size);
if (!log) {
nvme_msg(r, LOG_ERR,
"could not allocate memory for discovery log header\n");
@@ -1105,7 +1105,7 @@ static struct nvmf_discovery_log *nvme_discovery_log(nvme_ctrl_t c,
sizeof(struct nvmf_disc_log_entry) * numrec;
free(log);
- log = calloc(1, size);
+ log = __nvme_alloc(size);
if (!log) {
nvme_msg(r, LOG_ERR,
"could not alloc memory for discovery log page\n");
@@ -1709,26 +1709,35 @@ static const char *dctype_str[] = {
*/
static int nvme_fetch_cntrltype_dctype_from_id(nvme_ctrl_t c)
{
- struct nvme_id_ctrl id = { 0 };
+ struct nvme_id_ctrl *id;
int ret;
- ret = nvme_ctrl_identify(c, &id);
- if (ret)
+ id = __nvme_alloc(sizeof(*id));
+ if (!id) {
+ errno = ENOMEM;
+ return -1;
+ }
+
+ ret = nvme_ctrl_identify(c, id);
+ if (ret) {
+ free(id);
return ret;
+ }
if (!c->cntrltype) {
- if (id.cntrltype > NVME_CTRL_CNTRLTYPE_ADMIN || !cntrltype_str[id.cntrltype])
+ if (id->cntrltype > NVME_CTRL_CNTRLTYPE_ADMIN || !cntrltype_str[id->cntrltype])
c->cntrltype = strdup("reserved");
else
- c->cntrltype = strdup(cntrltype_str[id.cntrltype]);
+ c->cntrltype = strdup(cntrltype_str[id->cntrltype]);
}
- if (!c->dctype) {
- if (id.dctype > NVME_CTRL_DCTYPE_CDC || !dctype_str[id.dctype])
+ if (!c->dctype) {
+ if (id->dctype > NVME_CTRL_DCTYPE_CDC || !dctype_str[id->dctype])
c->dctype = strdup("reserved");
else
- c->dctype = strdup(dctype_str[id.dctype]);
+ c->dctype = strdup(dctype_str[id->dctype]);
}
+ free(id);
return 0;
}
--
2.39.3

609
SOURCES/libnvme-1.10-uriparser.patch Normal file
View File

@ -0,0 +1,609 @@
From 6829a6903c7a32a7b4dd32597c7f2a811b5a58bb Mon Sep 17 00:00:00 2001
From: Tomas Bzatek <tbzatek@redhat.com>
Date: Wed, 17 Apr 2024 18:04:34 +0200
Subject: [PATCH 1/3] fabrics: Introduce simple URI parser
A very simple URI parser implementing URI syntax described
in the Boot Specification, rev. 1.0.
Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
---
src/libnvme.map | 2 +
src/nvme/fabrics.c | 116 +++++++++++++++++++++++++++++++++++++++++++++
src/nvme/fabrics.h | 44 +++++++++++++++++
3 files changed, 162 insertions(+)
diff -up libnvme-1.9/src/libnvme.map.bak libnvme-1.9/src/libnvme.map
--- libnvme-1.9/src/libnvme.map.bak 2024-05-03 14:08:20.000000000 +0200
+++ libnvme-1.9/src/libnvme.map 2024-06-21 15:46:53.920532333 +0200
@@ -10,6 +10,8 @@ LIBNVME_1.9 {
nvme_submit_passthru64;
nvme_update_key;
nvme_ctrl_get_cntlid;
+ nvme_parse_uri;
+ nvme_free_uri;
};
LIBNVME_1_8 {
diff --git a/src/nvme/fabrics.c b/src/nvme/fabrics.c
index 6738e9dc..324a7321 100644
--- a/src/nvme/fabrics.c
+++ b/src/nvme/fabrics.c
@@ -1703,3 +1703,119 @@ 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);
}
+
+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;
+ 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>://<SERVERNAME/IP>[:TRANSPORT PORT]/<SUBSYS NQN>/<NID>
+ * or
+ * NVME<+PROTOCOL>://<DISCOVERY CONTROLLER ADDRESS>[:DISCOVERY-
+ * -CONTROLLER PORT]/NQN.2014-08.ORG.NVMEXPRESS.DISCOVERY/<NID>
+ */
+
+ /* TODO: unescape? */
+
+ 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 = strndup(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",
+ &uri->host, &uri->port) < 1) {
+ nvme_free_uri(uri);
+ errno = EINVAL;
+ return NULL;
+ }
+
+ /* split path into elements */
+ if (path) {
+ char *e, *elem;
+
+ /* separate the fragment */
+ e = strrchr(path, '#');
+ if (e) {
+ uri->fragment = strdup(e + 1);
+ *e = '\0';
+ }
+ /* separate the query string */
+ e = strrchr(path, '?');
+ if (e) {
+ uri->query = strdup(e + 1);
+ *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++] = strdup(elem);
+ while (elem && strlen(elem)) {
+ elem = strtok_r(NULL, "/", &e);
+ if (elem)
+ uri->path_segments[i++] = strdup(elem);
+ }
+ }
+
+ 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 4ebeb35e..3be35310 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
@@ -324,4 +346,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 */
From 27ea060ef42c76ed1c88d92c435b88b481e7defb Mon Sep 17 00:00:00 2001
From: Tomas Bzatek <tbzatek@redhat.com>
Date: Wed, 17 Apr 2024 18:06:23 +0200
Subject: [PATCH 2/3] tests: Add uriparser tests
Simple testcase both for valid and malformed URI strings.
Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
---
test/meson.build | 9 ++
test/uriparser.c | 208 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 217 insertions(+)
create mode 100644 test/uriparser.c
diff --git a/test/meson.build b/test/meson.build
index 93e69991..55992df7 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -66,6 +66,15 @@ uuid = executable(
test('uuid', uuid)
+uriparser = executable(
+ 'test-uriparser',
+ ['uriparser.c'],
+ dependencies: libnvme_dep,
+ include_directories: [incdir, internal_incdir]
+)
+
+test('uriparser', uriparser)
+
if conf.get('HAVE_NETDB')
mock_ifaddrs = library(
'mock-ifaddrs',
diff --git a/test/uriparser.c b/test/uriparser.c
new file mode 100644
index 00000000..cf26bfd2
--- /dev/null
+++ b/test/uriparser.c
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/**
+ * This file is part of libnvme.
+ * Copyright (c) 2024 Tomas Bzatek <tbzatek@redhat.com>
+ */
+
+#include <assert.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include <ccan/array_size/array_size.h>
+
+#include <libnvme.h>
+#include <nvme/private.h>
+
+struct test_data {
+ const char *uri;
+ /* parsed data */
+ const char *scheme;
+ const char *host;
+ const char *user;
+ const char *proto;
+ int port;
+ const char *path[7];
+ const char *query;
+ const char *frag;
+};
+
+static struct test_data test_data[] = {
+ { "nvme://192.168.1.1", "nvme", "192.168.1.1" },
+ { "nvme://192.168.1.1/", "nvme", "192.168.1.1" },
+ { "nvme://192.168.1.1:1234", "nvme", "192.168.1.1", .port = 1234 },
+ { "nvme://192.168.1.1:1234/", "nvme", "192.168.1.1", .port = 1234 },
+ { "nvme+tcp://192.168.1.1", "nvme", "192.168.1.1", .proto = "tcp" },
+ { "nvme+rdma://192.168.1.1/", "nvme", "192.168.1.1", .proto = "rdma" },
+ { "nvme+tcp://192.168.1.1:1234",
+ "nvme", "192.168.1.1", .proto = "tcp", .port = 1234 },
+ { "nvme+tcp://192.168.1.1:1234/",
+ "nvme", "192.168.1.1", .proto = "tcp", .port = 1234 },
+ { "nvme+tcp://192.168.1.1:4420/path",
+ "nvme", "192.168.1.1", .proto = "tcp", .port = 4420,
+ .path = { "path", NULL }},
+ { "nvme+tcp://192.168.1.1/path/",
+ "nvme", "192.168.1.1", .proto = "tcp", .path = { "path", NULL }},
+ { "nvme+tcp://192.168.1.1:4420/p1/p2/p3",
+ "nvme", "192.168.1.1", .proto = "tcp", .port = 4420,
+ .path = { "p1", "p2", "p3", NULL }},
+ { "nvme+tcp://192.168.1.1:4420/p1/p2/p3/",
+ "nvme", "192.168.1.1", .proto = "tcp", .port = 4420,
+ .path = { "p1", "p2", "p3", NULL }},
+ { "nvme+tcp://192.168.1.1:4420//p1//p2/////p3",
+ "nvme", "192.168.1.1", .proto = "tcp", .port = 4420,
+ .path = { "p1", "p2", "p3", NULL }},
+ { "nvme+tcp://192.168.1.1:4420//p1//p2/////p3/",
+ "nvme", "192.168.1.1", .proto = "tcp", .port = 4420,
+ .path = { "p1", "p2", "p3", NULL }},
+ { "nvme://[fe80::1010]", "nvme", "fe80::1010" },
+ { "nvme://[fe80::1010]/", "nvme", "fe80::1010" },
+ { "nvme://[fe80::1010]:1234", "nvme", "fe80::1010", .port = 1234 },
+ { "nvme://[fe80::1010]:1234/", "nvme", "fe80::1010", .port = 1234 },
+ { "nvme+tcp://[fe80::1010]", "nvme", "fe80::1010", .proto = "tcp" },
+ { "nvme+rdma://[fe80::1010]/", "nvme", "fe80::1010", .proto = "rdma" },
+ { "nvme+tcp://[fe80::1010]:1234",
+ "nvme", "fe80::1010", .proto = "tcp", .port = 1234 },
+ { "nvme+tcp://[fe80::1010]:1234/",
+ "nvme", "fe80::1010", .proto = "tcp", .port = 1234 },
+ { "nvme+tcp://[fe80::1010]:4420/path",
+ "nvme", "fe80::1010", .proto = "tcp", .port = 4420,
+ .path = { "path", NULL }},
+ { "nvme+tcp://[fe80::1010]/path/",
+ "nvme", "fe80::1010", .proto = "tcp", .path = { "path", NULL }},
+ { "nvme+tcp://[fe80::1010]:4420/p1/p2/p3",
+ "nvme", "fe80::1010", .proto = "tcp", .port = 4420,
+ .path = { "p1", "p2", "p3", NULL }},
+ { "nvme+tcp://[fe80::fc7d:8cff:fe5b:962e]:666/p1/p2/p3/",
+ "nvme", "fe80::fc7d:8cff:fe5b:962e", .proto = "tcp", .port = 666,
+ .path = { "p1", "p2", "p3", NULL }},
+ { "nvme://h?query", "nvme", "h", .query = "query" },
+ { "nvme://h/?query", "nvme", "h", .query = "query" },
+ { "nvme://h/x?query",
+ "nvme", "h", .path = { "x" }, .query = "query" },
+ { "nvme://h/p1/?query",
+ "nvme", "h", .path = { "p1" }, .query = "query" },
+ { "nvme://h/p1/x?query",
+ "nvme", "h", .path = { "p1", "x" }, .query = "query" },
+ { "nvme://h#fragment", "nvme", "h", .frag = "fragment" },
+ { "nvme://h/#fragment", "nvme", "h", .frag = "fragment" },
+ { "nvme://h/x#fragment",
+ "nvme", "h", .path = { "x" }, .frag = "fragment" },
+ { "nvme://h/p1/#fragment",
+ "nvme", "h", .path = { "p1" }, .frag = "fragment" },
+ { "nvme://h/p1/x#fragment",
+ "nvme", "h", .path = { "p1", "x" }, .frag = "fragment" },
+ { "nvme://h/?query#fragment",
+ "nvme", "h", .query = "query", .frag = "fragment" },
+ { "nvme://h/x?query#fragment",
+ "nvme", "h", .path = { "x" }, .query = "query", .frag = "fragment" },
+ { "nvme://h/p1/?query#fragment",
+ "nvme", "h", .path = { "p1" }, .query = "query", .frag = "fragment" },
+ { "nvme://h/p1/x?query#fragment",
+ "nvme", "h", .path = { "p1", "x" }, .query = "query",
+ .frag = "fragment" },
+ { "nvme://h/#fragment?query",
+ "nvme", "h", .frag = "fragment?query" },
+ { "nvme://h/x#fragment?query",
+ "nvme", "h", .path = { "x" }, .frag = "fragment?query" },
+ { "nvme://h/p1/#fragment?query",
+ "nvme", "h", .path = { "p1" }, .frag = "fragment?query" },
+ { "nvme://h/p1/x#fragment?query",
+ "nvme", "h", .path = { "p1", "x" }, .frag = "fragment?query" },
+ { "nvme://user@h", "nvme", "h", .user = "user" },
+ { "nvme://user@h/", "nvme", "h", .user = "user" },
+ { "nvme://user:pass@h/", "nvme", "h", .user = "user:pass" },
+ { "nvme://[fe80::1010]@h/", "nvme", "h", .user = "[fe80::1010]" },
+ { "nvme://u[fe80::1010]@h/", "nvme", "h", .user = "u[fe80::1010]" },
+ { "nvme://u[aa:bb::cc]@h/", "nvme", "h", .user = "u[aa:bb::cc]" },
+ { "nvme+rdma://u[aa:bb::cc]@[aa:bb::cc]:12345/p1/x?q=val#fr",
+ "nvme", "aa:bb::cc", .proto = "rdma", .port = 12345,
+ .user = "u[aa:bb::cc]", .path = { "p1", "x" },
+ .query = "q=val", .frag = "fr" },
+};
+
+const char *test_data_bad[] = {
+ "",
+ " ",
+ "nonsense",
+ "vnme:",
+ "vnme:/",
+ "vnme://",
+ "vnme:///",
+ "vnme+foo://",
+ "nvme:hostname/",
+ "nvme:/hostname/",
+ "nvme:///hostname/",
+ "nvme+foo:///hostname/",
+};
+
+static void test_uriparser(void)
+{
+ printf("Testing URI parser:\n");
+ for (int i = 0; i < ARRAY_SIZE(test_data); i++) {
+ const struct test_data *d = &test_data[i];
+ struct nvme_fabrics_uri *parsed_data;
+ char **s;
+ int i;
+
+ printf(" '%s'...", d->uri);
+ parsed_data = nvme_parse_uri(d->uri);
+ assert(parsed_data);
+
+ assert(strcmp(d->scheme, parsed_data->scheme) == 0);
+ if (d->proto) {
+ assert(parsed_data->protocol != NULL);
+ assert(strcmp(d->proto, parsed_data->protocol) == 0);
+ } else
+ assert(d->proto == parsed_data->protocol);
+ assert(strcmp(d->host, parsed_data->host) == 0);
+ assert(d->port == parsed_data->port);
+
+ if (!parsed_data->path_segments)
+ assert(d->path[0] == NULL);
+ else {
+ for (i = 0, s = parsed_data->path_segments;
+ s && *s; s++, i++) {
+ assert(d->path[i] != NULL);
+ assert(strcmp(d->path[i], *s) == 0);
+ }
+ /* trailing NULL element */
+ assert(d->path[i] == parsed_data->path_segments[i]);
+ }
+ if (d->query) {
+ assert(parsed_data->query != NULL);
+ assert(strcmp(d->query, parsed_data->query) == 0);
+ } else
+ assert(d->query == parsed_data->query);
+ if (d->frag) {
+ assert(parsed_data->fragment != NULL);
+ assert(strcmp(d->frag, parsed_data->fragment) == 0);
+ } else
+ assert(d->frag == parsed_data->fragment);
+ nvme_free_uri(parsed_data);
+ printf(" OK\n");
+ }
+}
+
+static void test_uriparser_bad(void)
+{
+ printf("Testing malformed URI strings:\n");
+ for (int i = 0; i < ARRAY_SIZE(test_data_bad); i++) {
+ struct nvme_fabrics_uri *parsed_data;
+
+ printf(" '%s'...", test_data_bad[i]);
+ parsed_data = nvme_parse_uri(test_data_bad[i]);
+ assert(parsed_data == NULL);
+ printf(" OK\n");
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ test_uriparser();
+ test_uriparser_bad();
+
+ fflush(stdout);
+
+ return 0;
+}
From b2044e8f416b54df34e0d162b59ca0745db92927 Mon Sep 17 00:00:00 2001
From: Tomas Bzatek <tbzatek@redhat.com>
Date: Mon, 13 May 2024 17:38:25 +0200
Subject: [PATCH 3/3] fabrics: Unescape URI elements
This adds support for unescaping percent-encoded URI parts.
Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
---
src/nvme/fabrics.c | 47 +++++++++++++++++++++++++++++++++++++---------
test/uriparser.c | 13 +++++++++++++
2 files changed, 51 insertions(+), 9 deletions(-)
diff --git a/src/nvme/fabrics.c b/src/nvme/fabrics.c
index 324a7321..e5921f8b 100644
--- a/src/nvme/fabrics.c
+++ b/src/nvme/fabrics.c
@@ -1704,12 +1704,41 @@ 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;
@@ -1726,8 +1755,6 @@ struct nvme_fabrics_uri *nvme_parse_uri(const char *str)
* -CONTROLLER PORT]/NQN.2014-08.ORG.NVMEXPRESS.DISCOVERY/<NID>
*/
- /* TODO: unescape? */
-
uri = calloc(1, sizeof(struct nvme_fabrics_uri));
if (!uri)
return NULL;
@@ -1750,20 +1777,22 @@ struct nvme_fabrics_uri *nvme_parse_uri(const char *str)
host = strrchr(authority, '@');
if (host) {
host++;
- uri->userinfo = strndup(authority, host - authority);
+ 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)
+ &uri->host, &uri->port) < 1) {
/* treat it as IPv4/hostname */
if (sscanf(host, "%m[^:]:%d",
- &uri->host, &uri->port) < 1) {
+ &h, &uri->port) < 1) {
nvme_free_uri(uri);
errno = EINVAL;
return NULL;
}
+ uri->host = unescape_uri(h, 0);
+ }
/* split path into elements */
if (path) {
@@ -1772,13 +1801,13 @@ struct nvme_fabrics_uri *nvme_parse_uri(const char *str)
/* separate the fragment */
e = strrchr(path, '#');
if (e) {
- uri->fragment = strdup(e + 1);
+ uri->fragment = unescape_uri(e + 1, 0);
*e = '\0';
}
/* separate the query string */
e = strrchr(path, '?');
if (e) {
- uri->query = strdup(e + 1);
+ uri->query = unescape_uri(e + 1, 0);
*e = '\0';
}
@@ -1791,11 +1820,11 @@ struct nvme_fabrics_uri *nvme_parse_uri(const char *str)
i = 0;
elem = strtok_r(path, "/", &e);
if (elem)
- uri->path_segments[i++] = strdup(elem);
+ uri->path_segments[i++] = unescape_uri(elem, 0);
while (elem && strlen(elem)) {
elem = strtok_r(NULL, "/", &e);
if (elem)
- uri->path_segments[i++] = strdup(elem);
+ uri->path_segments[i++] = unescape_uri(elem, 0);
}
}
diff --git a/test/uriparser.c b/test/uriparser.c
index cf26bfd2..09b2a732 100644
--- a/test/uriparser.c
+++ b/test/uriparser.c
@@ -119,6 +119,19 @@ static struct test_data test_data[] = {
"nvme", "aa:bb::cc", .proto = "rdma", .port = 12345,
.user = "u[aa:bb::cc]", .path = { "p1", "x" },
.query = "q=val", .frag = "fr" },
+ { "nvme://ex%5Cmp%3Ae", "nvme", "ex\\mp:e" },
+ { "nvme://ex%5Cmp%3Ae.com/", "nvme", "ex\\mp:e.com" },
+ { "nvme://u%24er@ex%5Cmp%3Ae.com/", "nvme", "ex\\mp:e.com",
+ .user = "u$er" },
+ { "nvme+tcp://ex%5Cmp%3Ae.com:1234",
+ "nvme", "ex\\mp:e.com", .proto = "tcp", .port = 1234 },
+ { "nvme+tcp://ex%5Cmp%3Ae.com:1234/p1/ex%3Camp%3Ele/p3",
+ "nvme", "ex\\mp:e.com", .proto = "tcp", .port = 1234,
+ .path = { "p1", "ex<amp>le", "p3", NULL } },
+ { "nvme+tcp://ex%5Cmp%3Ae.com:1234/p1/%3C%3E/p3?q%5E%24ry#fr%26gm%23nt",
+ "nvme", "ex\\mp:e.com", .proto = "tcp", .port = 1234,
+ .path = { "p1", "<>", "p3", NULL }, .query = "q^$ry",
+ .frag = "fr&gm#nt" },
};
const char *test_data_bad[] = {

27
SPECS/libnvme.spec
View File

@ -3,16 +3,15 @@
Name: libnvme
Summary: Linux-native nvme device management library
Version: 1.6
Release: 1%{?dist}
Version: 1.9
Release: 3%{?dist}
License: LGPL-2.1-or-later
URL: https://github.com/linux-nvme/libnvme
Source0: %{url}/archive/v%{version_no_tilde}/%{name}-%{version_no_tilde}.tar.gz
Patch0: 0001-util-Introduce-alloc-helper-with-alignment-support.patch
Patch1: 0002-tree-Allocate-aligned-payloads-for-ns-scan.patch
Patch2: 0003-linux-Allocate-aligned-payloads-for-id_ctrl-and-id_n.patch
Patch3: 0004-fabrics-Allocate-aligned-payloads-for-id_ctrl-and-di.patch
# https://issues.redhat.com/browse/RHEL-37608
Patch0: libnvme-1.10-uriparser.patch
Patch1: 0001-tree-handle-no-address-phy-slot-dirs.patch
BuildRequires: gcc gcc-c++
BuildRequires: swig
@ -76,9 +75,9 @@ mv %{buildroot}/usr/*.rst %{buildroot}%{_pkgdocdir}/
%files
%license COPYING ccan/licenses/*
%{_libdir}/libnvme.so.1
%{_libdir}/libnvme.so.1.6.0
%{_libdir}/libnvme.so.1.9.0
%{_libdir}/libnvme-mi.so.1
%{_libdir}/libnvme-mi.so.1.6.0
%{_libdir}/libnvme-mi.so.1.9.0
%files devel
%{_libdir}/libnvme.so
@ -98,6 +97,18 @@ mv %{buildroot}/usr/*.rst %{buildroot}%{_pkgdocdir}/
%{python3_sitearch}/libnvme/*
%changelog
* Thu Aug 01 2024 Maurizio Lombardi <mlombard@redhat.com> - 1.9-3
- Backport fix for RHEL-49544
* Wed Jul 24 2024 Tomas Bzatek <tbzatek@redhat.com> - 1.9-2
- Backport URI parser API
* Tue May 07 2024 Maurizio Lombardi <mlombard@redhat.com> - 1.9-1
- Rebase to version 1.9
* Tue Apr 02 2024 Maurizio Lombardi <mlombard@redhat.com> - 1.8-1
- Update to version 1.8
* Fri Nov 03 2023 Maurizio Lombardi <mlombard@redhat.com> - 1.6-1
- Update to version 1.6, including the stack-smashing fixes