From 2c4324b658931882bfb664e05673cd5c9082429d Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Fri, 7 Oct 2022 15:42:44 +0200

Subject: [PATCH] nvme: Rework the disconnect device topology crawl

This is more sane regarding to memory ownership and

the scanned topology tree.

---

 src/plugins/nvme/nvme-fabrics.c | 93 +++++++++++++++++----------------

 tests/nvme_test.py              |  2 +-

 2 files changed, 50 insertions(+), 45 deletions(-)

diff --git a/src/plugins/nvme/nvme-fabrics.c b/src/plugins/nvme/nvme-fabrics.c

index 20ed57f5d..26e2fa6ec 100644

--- a/src/plugins/nvme/nvme-fabrics.c

+++ b/src/plugins/nvme/nvme-fabrics.c

@@ -281,6 +281,47 @@ gboolean bd_nvme_connect (const gchar *subsysnqn, const gchar *transport, const

     return TRUE;

 }

+static gboolean _disconnect (const gchar *subsysnqn, const gchar *path, GError **error, gboolean *found) {

+    nvme_root_t root;

+    nvme_host_t host;

+    nvme_subsystem_t subsys;

+    nvme_ctrl_t ctrl;

+    int ret;

+

+    root = nvme_create_root (NULL, -1);

+    if (root == NULL) {

+        g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_FAILED,

+                     "Failed to create topology root: %s",

+                     strerror_l (errno, _C_LOCALE));

+        return FALSE;

+    }

+    ret = nvme_scan_topology (root, NULL, NULL);

+    if (ret < 0) {

+        g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_FAILED,

+                     "Failed to scan topology: %s",

+                     strerror_l (errno, _C_LOCALE));

+        nvme_free_tree (root);

+        return FALSE;

+    }

+    nvme_for_each_host (root, host)

+        nvme_for_each_subsystem (host, subsys)

+            if (!subsysnqn || g_strcmp0 (nvme_subsystem_get_nqn (subsys), subsysnqn) == 0)

+                nvme_subsystem_for_each_ctrl (subsys, ctrl)

+                    if (!path || g_strcmp0 (nvme_ctrl_get_name (ctrl), path) == 0) {

+                        ret = nvme_disconnect_ctrl (ctrl);

+                        if (ret != 0) {

+                            g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_FAILED,

+                                         "Error disconnecting the controller: %s",

+                                         strerror_l (errno, _C_LOCALE));

+                            nvme_free_tree (root);

+                            return FALSE;

+                        }

+                        *found = TRUE;

+                    }

+    nvme_free_tree (root);

+    return TRUE;

+}

+

 /**

  * bd_nvme_disconnect:

  * @subsysnqn: The name of the NVMe subsystem to disconnect.

@@ -296,37 +337,16 @@ gboolean bd_nvme_connect (const gchar *subsysnqn, const gchar *transport, const

  * Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR

  */

 gboolean bd_nvme_disconnect (const gchar *subsysnqn, GError **error) {

-    nvme_root_t root;

-    nvme_host_t host;

-    nvme_subsystem_t subsys;

-    nvme_ctrl_t ctrl;

     gboolean found = FALSE;

-    root = nvme_scan (NULL);

-    nvme_init_logging (root, -1, false, false);

-    nvme_for_each_host (root, host)

-        nvme_for_each_subsystem (host, subsys)

-            if (g_strcmp0 (nvme_subsystem_get_nqn (subsys), subsysnqn) == 0)

-                nvme_subsystem_for_each_ctrl (subsys, ctrl) {

-                    int ret;

-

-                    ret = nvme_disconnect_ctrl (ctrl);

-                    if (ret != 0) {

-                        g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_FAILED,

-                                     "Error disconnecting the controller: %s",

-                                     strerror_l (errno, _C_LOCALE));

-                        nvme_free_tree (root);

-                        return FALSE;

-                    }

-                    found = TRUE;

-                }

-    nvme_free_tree (root);

+    if (!_disconnect (subsysnqn, NULL, error, &found))

+        return FALSE;

+

     if (!found) {

         g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_NO_MATCH,

                      "No subsystems matching '%s' NQN found.", subsysnqn);

         return FALSE;

     }

-

     return TRUE;

 }

@@ -344,36 +364,21 @@ gboolean bd_nvme_disconnect (const gchar *subsysnqn, GError **error) {

  * Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR

  */

 gboolean bd_nvme_disconnect_by_path (const gchar *path, GError **error) {

-    nvme_root_t root;

-    nvme_ctrl_t ctrl;

     const gchar *p;

-    int ret;

+    gboolean found = FALSE;

     p = path;

     if (g_str_has_prefix (p, "/dev/"))

         p += 5;

-    root = nvme_scan (NULL);

-    nvme_init_logging (root, -1, false, false);

-    ctrl = nvme_scan_ctrl (root, p);

-    if (!ctrl) {

-        g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_NO_MATCH,

-                     "Unable to match a NVMeoF controller for the specified block device %s.",

-                     path);

-        nvme_free_tree (root);

+    if (!_disconnect (NULL, p, error, &found))

         return FALSE;

-    }

-    ret = nvme_disconnect_ctrl (ctrl);

-    if (ret != 0) {

-        g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_FAILED,

-                     "Error disconnecting the controller: %s",

-                     strerror_l (errno, _C_LOCALE));

-        nvme_free_tree (root);

+    if (!found) {

+        g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_NO_MATCH,

+                     "No controllers matching the %s device name found.", path);

         return FALSE;

     }

-    nvme_free_tree (root);

-

     return TRUE;

 }

diff --git a/tests/nvme_test.py b/tests/nvme_test.py

index f205e5391..696d594c9 100644

--- a/tests/nvme_test.py

+++ b/tests/nvme_test.py

@@ -387,7 +387,7 @@ def test_connect_single_ns(self):

         # disconnect

         with self.assertRaisesRegexp(GLib.GError, r"No subsystems matching '.*' NQN found."):

             BlockDev.nvme_disconnect(self.SUBNQN + "xx")

-        with self.assertRaisesRegexp(GLib.GError, r"Unable to match a NVMeoF controller for the specified block device /dev/nvme.*xx"):

+        with self.assertRaisesRegexp(GLib.GError, r"No controllers matching the /dev/nvme.*xx device name found."):

             BlockDev.nvme_disconnect_by_path(ctrls[0] + "xx")

         # should disconnect both connections as long the SUBNQN matches

         BlockDev.nvme_disconnect(self.SUBNQN)

From ac1e0c50dd7bab21a7837c806b82bf34090127d1 Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Sun, 5 Feb 2023 21:51:42 +0100

Subject: [PATCH] nvme: Strip trailing whitespaces from subsysnqn when matching

 the device tree

---

 src/plugins/nvme/nvme-fabrics.c | 9 ++++++++-

 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/plugins/nvme/nvme-fabrics.c b/src/plugins/nvme/nvme-fabrics.c

index 5cc7f670d..27f6ed444 100644

--- a/src/plugins/nvme/nvme-fabrics.c

+++ b/src/plugins/nvme/nvme-fabrics.c

@@ -721,6 +721,12 @@ gchar ** bd_nvme_find_ctrls_for_ns (const gchar *ns_sysfs_path, const gchar *sub

     nvme_ctrl_t c;

     nvme_ns_t n;

     char realp[PATH_MAX];

+    gchar *subsysnqn_p;

+

+    /* libnvme strips trailing spaces and newlines when reading values from sysfs */

+    subsysnqn_p = g_strdup (subsysnqn);

+    if (subsysnqn_p)

+        g_strchomp (subsysnqn_p);

     ptr_array = g_ptr_array_new ();

@@ -736,7 +742,7 @@ gchar ** bd_nvme_find_ctrls_for_ns (const gchar *ns_sysfs_path, const gchar *sub

         nvme_for_each_subsystem (h, s) {

             gboolean found = FALSE;

-            if (subsysnqn && g_strcmp0 (nvme_subsystem_get_nqn (s), subsysnqn) != 0)

+            if (subsysnqn && g_strcmp0 (nvme_subsystem_get_nqn (s), subsysnqn_p) != 0)

                 continue;

             nvme_subsystem_for_each_ctrl (s, c)

@@ -767,6 +773,7 @@ gchar ** bd_nvme_find_ctrls_for_ns (const gchar *ns_sysfs_path, const gchar *sub

         }

     }

     nvme_free_tree (root);

+    g_free (subsysnqn_p);

     g_ptr_array_add (ptr_array, NULL);  /* trailing NULL element */

     return (gchar **) g_ptr_array_free (ptr_array, FALSE);

From 29b4defc50451dd54f1a7a988b92bdf5fadb22df Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Mon, 6 Feb 2023 11:29:43 +0100

Subject: [PATCH] nvme: Return NULL in case the supported NVMe revision is not

 reported

...as is often the case for older, pre-1.2 NVMe devices.

---

 src/lib/plugin_apis/nvme.api | 2 +-

 src/plugins/nvme/nvme-info.c | 2 ++

 src/plugins/nvme/nvme.h      | 2 +-

 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/lib/plugin_apis/nvme.api b/src/lib/plugin_apis/nvme.api

index 7bc2cf9ef..6e73870e5 100644

--- a/src/lib/plugin_apis/nvme.api

+++ b/src/lib/plugin_apis/nvme.api

@@ -142,7 +142,7 @@ GType bd_nvme_controller_info_get_type ();

  * @model_number: The model number.

  * @serial_number: The serial number.

  * @firmware_ver: The currently active firmware revision.

- * @nvme_ver: The NVM Express base specification that the controller implementation supports.

+ * @nvme_ver: The NVM Express base specification that the controller implementation supports or %NULL when not reported by the device.

  * @features: features and capabilities present for this controller, see #BDNVMEControllerFeature.

  * @controller_type: The controller type.

  * @selftest_ext_time: Extended Device Self-test Time, if #BD_NVME_CTRL_FEAT_SELFTEST is supported then this field

diff --git a/src/plugins/nvme/nvme-info.c b/src/plugins/nvme/nvme-info.c

index ec5cae332..23ee8afde 100644

--- a/src/plugins/nvme/nvme-info.c

+++ b/src/plugins/nvme/nvme-info.c

@@ -401,6 +401,8 @@ static gchar *decode_nvme_rev (guint32 ver) {

     if (mjr >= 2 || mnr >= 2)

         ter = ver & 0xFF;

+    if (mjr == 0 && mnr == 0)

+        return NULL;

     if (ter == 0)

         return g_strdup_printf ("%u.%u", mjr, mnr);

     else

diff --git a/src/plugins/nvme/nvme.h b/src/plugins/nvme/nvme.h

index ad456a82e..fa6f6abcc 100644

--- a/src/plugins/nvme/nvme.h

+++ b/src/plugins/nvme/nvme.h

@@ -129,7 +129,7 @@ typedef enum {

  * @model_number: The model number.

  * @serial_number: The serial number.

  * @firmware_ver: The currently active firmware revision.

- * @nvme_ver: The NVM Express base specification that the controller implementation supports.

+ * @nvme_ver: The NVM Express base specification that the controller implementation supports or %NULL when not reported by the device.

  * @features: features and capabilities present for this controller, see #BDNVMEControllerFeature.

  * @controller_type: The controller type.

  * @selftest_ext_time: Extended Device Self-test Time, if #BD_NVME_CTRL_FEAT_SELFTEST is supported then this field

From 5a709aa3475ee083237c3faf4fff8c316767bd71 Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Wed, 26 Apr 2023 18:39:57 +0200

Subject: [PATCH] nvme: Add support for ENVME_CONNECT_CONNREFUSED

Requires libnvme-1.3

---

 configure.ac                  | 2 +-

 src/lib/plugin_apis/nvme.api  | 2 ++

 src/plugins/nvme/nvme-error.c | 3 +++

 src/plugins/nvme/nvme.h       | 2 ++

 4 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac

index 727465c9b..16fe3a0c2 100644

--- a/configure.ac

+++ b/configure.ac

@@ -238,7 +238,7 @@ AS_IF([test "x$with_nvdimm" != "xno"],

       [])

 AS_IF([test "x$with_nvme" != "xno"],

-      [LIBBLOCKDEV_PKG_CHECK_MODULES([NVME], [libnvme >= 1.2])],

+      [LIBBLOCKDEV_PKG_CHECK_MODULES([NVME], [libnvme >= 1.3])],

       [])

 AS_IF([test "x$with_vdo" != "xno"],

diff --git a/src/lib/plugin_apis/nvme.api b/src/lib/plugin_apis/nvme.api

index 6e73870e5..1099da7db 100644

--- a/src/lib/plugin_apis/nvme.api

+++ b/src/lib/plugin_apis/nvme.api

@@ -31,6 +31,7 @@ GQuark bd_nvme_error_quark (void) {

  * @BD_NVME_ERROR_CONNECT_ADDRINUSE: HostNQN already in use.

  * @BD_NVME_ERROR_CONNECT_NODEV: Invalid interface.

  * @BD_NVME_ERROR_CONNECT_OPNOTSUPP: Operation not supported.

+ * @BD_NVME_ERROR_CONNECT_REFUSED: Connection refused.

  */

 /* BpG-skip-end */

 typedef enum {

@@ -51,6 +52,7 @@ typedef enum {

     BD_NVME_ERROR_CONNECT_ADDRINUSE,

     BD_NVME_ERROR_CONNECT_NODEV,

     BD_NVME_ERROR_CONNECT_OPNOTSUPP,

+    BD_NVME_ERROR_CONNECT_REFUSED,

 } BDNVMEError;

 typedef enum {

diff --git a/src/plugins/nvme/nvme-error.c b/src/plugins/nvme/nvme-error.c

index cb95a46dc..4bd4d7712 100644

--- a/src/plugins/nvme/nvme-error.c

+++ b/src/plugins/nvme/nvme-error.c

@@ -137,6 +137,9 @@ void _nvme_fabrics_errno_to_gerror (int result, int _errno, GError **error)

             case ENVME_CONNECT_OPNOTSUPP:

                 code = BD_NVME_ERROR_CONNECT_OPNOTSUPP;

                 break;

+            case ENVME_CONNECT_CONNREFUSED:

+                code = BD_NVME_ERROR_CONNECT_REFUSED;

+                break;

             default:

                 code = BD_NVME_ERROR_CONNECT;

         }

diff --git a/src/plugins/nvme/nvme.h b/src/plugins/nvme/nvme.h

index 438d66334..afd41b267 100644

--- a/src/plugins/nvme/nvme.h

+++ b/src/plugins/nvme/nvme.h

@@ -27,6 +27,7 @@ GQuark bd_nvme_error_quark (void);

  * @BD_NVME_ERROR_CONNECT_ADDRINUSE: HostNQN already in use.

  * @BD_NVME_ERROR_CONNECT_NODEV: Invalid interface.

  * @BD_NVME_ERROR_CONNECT_OPNOTSUPP: Operation not supported.

+ * @BD_NVME_ERROR_CONNECT_REFUSED: Connection refused.

  */

 typedef enum {

     BD_NVME_ERROR_TECH_UNAVAIL,

@@ -46,6 +47,7 @@ typedef enum {

     BD_NVME_ERROR_CONNECT_ADDRINUSE,

     BD_NVME_ERROR_CONNECT_NODEV,

     BD_NVME_ERROR_CONNECT_OPNOTSUPP,

+    BD_NVME_ERROR_CONNECT_REFUSED,

 } BDNVMEError;

 typedef enum {

From b19600de73233317cd9de68dba356ec4bb80a0f3 Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Thu, 27 Apr 2023 17:32:25 +0200

Subject: [PATCH] nvme: Add support for 'keyring' and 'tls_key' fabrics

 attributes

Requires libnvme-1.4

---

 configure.ac                    |  5 ++++-

 src/lib/plugin_apis/nvme.api    |  2 ++

 src/plugins/nvme/nvme-fabrics.c | 21 +++++++++++++++++++++

 3 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac

index 16fe3a0c2..12d007a53 100644

--- a/configure.ac

+++ b/configure.ac

@@ -238,7 +238,10 @@ AS_IF([test "x$with_nvdimm" != "xno"],

       [])

 AS_IF([test "x$with_nvme" != "xno"],

-      [LIBBLOCKDEV_PKG_CHECK_MODULES([NVME], [libnvme >= 1.3])],

+      [LIBBLOCKDEV_PKG_CHECK_MODULES([NVME], [libnvme >= 1.3])

+      AS_IF([$PKG_CONFIG --atleast-version=1.4 libnvme],

+            [AC_DEFINE([HAVE_LIBNVME_1_4])], [])

+      ],

       [])

 AS_IF([test "x$with_vdo" != "xno"],

diff --git a/src/lib/plugin_apis/nvme.api b/src/lib/plugin_apis/nvme.api

index 1099da7db..667dbe9e0 100644

--- a/src/lib/plugin_apis/nvme.api

+++ b/src/lib/plugin_apis/nvme.api

@@ -1415,6 +1415,8 @@ gboolean bd_nvme_set_host_id (const gchar *host_id, GError **error);

  * - `"data_digest"`: Generates/verifies data digest (TCP). Boolean value.

  * - `"tls"`: Enable TLS encryption (TCP). Boolean value.

  * - `"hostsymname"`: TP8010: NVMe host symbolic name.

+ * - `"keyring"`: Keyring to store and lookup keys. String value.

+ * - `"tls_key"`: TLS PSK for the connection. String value.

  *

  * Boolean values can be expressed by "0"/"1", "on"/"off" or "True"/"False" case-insensitive

  * strings. Failed numerical or boolean string conversions will result in the option being ignored.

diff --git a/src/plugins/nvme/nvme-fabrics.c b/src/plugins/nvme/nvme-fabrics.c

index 27f6ed444..0c64fb513 100644

--- a/src/plugins/nvme/nvme-fabrics.c

+++ b/src/plugins/nvme/nvme-fabrics.c

@@ -125,6 +125,25 @@ static void parse_extra_args (const BDExtraArg **extra, struct nvme_fabrics_conf

         else

         if (g_strcmp0 ((*extra_i)->opt, "tls") == 0)

             SAFE_BOOL_CONV (cfg->tls)

+#ifdef HAVE_LIBNVME_1_4

+        else

+        if (g_strcmp0 ((*extra_i)->opt, "keyring") == 0) {

+            int keyring;

+

+            keyring = nvme_lookup_keyring ((*extra_i)->val);

+            if (keyring) {

+                cfg->keyring = keyring;

+                nvme_set_keyring (cfg->keyring);

+            }

+        } else

+        if (g_strcmp0 ((*extra_i)->opt, "tls_key") == 0) {

+            int key;

+

+            key = nvme_lookup_key ("psk", (*extra_i)->val);

+            if (key)

+                cfg->tls_key = key;

+        }

+#endif

     }

 #undef SAFE_INT_CONV

@@ -179,6 +198,8 @@ static void parse_extra_args (const BDExtraArg **extra, struct nvme_fabrics_conf

  * - `"data_digest"`: Generates/verifies data digest (TCP). Boolean value.

  * - `"tls"`: Enable TLS encryption (TCP). Boolean value.

  * - `"hostsymname"`: TP8010: NVMe host symbolic name.

+ * - `"keyring"`: Keyring to store and lookup keys. String value.

+ * - `"tls_key"`: TLS PSK for the connection. String value.

  *

  * Boolean values can be expressed by "0"/"1", "on"/"off" or "True"/"False" case-insensitive

  * strings. Failed numerical or boolean string conversions will result in the option being ignored.

From 941448f5ec9f465266e1baf5de23e36692a17274 Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Thu, 27 Apr 2023 19:05:00 +0200

Subject: [PATCH] nvme: Fix 128-bit int conversion

Still using target 64-bit int and expecting overflow. This change

at least handles endianness conversion properly.

Futher experiments reveal shortcomings during gobject-introspection

data type translation so until 128-bit int is properly supported

throughout the stack, we can only hope numbers won't be that high.

---

 src/plugins/nvme/nvme-info.c | 17 ++++++++++++++---

 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/plugins/nvme/nvme-info.c b/src/plugins/nvme/nvme-info.c

index 23ee8afde..bbc7de4f2 100644

--- a/src/plugins/nvme/nvme-info.c

+++ b/src/plugins/nvme/nvme-info.c

@@ -365,15 +365,26 @@ BDNVMESanitizeLog * bd_nvme_sanitize_log_copy (BDNVMESanitizeLog *log) {

 }

-static guint64 int128_to_guint64 (__u8 *data)

+/* can't use real __int128 due to gobject-introspection */

+static guint64 int128_to_guint64 (__u8 data[16])

 {

     int i;

+    __u8 d[16];

     guint64 result = 0;

-    /* FIXME: would overflow, need to find 128-bit int */

+    /* endianness conversion */

+#if G_BYTE_ORDER == G_BIG_ENDIAN

+    for (i = 0; i < 16; i++)

+        d[i] = data[15 - i];

+#else

+    memcpy (d, data, sizeof (d));

+#endif

+

+    /* FIXME: would overflow */

+    /* https://github.com/linux-nvme/libnvme/issues/475 */

     for (i = 0; i < 16; i++) {

         result *= 256;

-        result += data[15 - i];

+        result += d[15 - i];

     }

     return result;

 }

From 5f118338e52a9096fdbac5ee9aa9c1e43f8b038b Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Fri, 23 Jun 2023 13:05:24 +0200

Subject: [PATCH] docs: Change NVMe plugin description to be consistent with

 other plugins

---

 src/plugins/nvme/nvme.c | 2 +-

 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/plugins/nvme/nvme.c b/src/plugins/nvme/nvme.c

index c0f4759de..c319f088c 100644

--- a/src/plugins/nvme/nvme.c

+++ b/src/plugins/nvme/nvme.c

@@ -36,7 +36,7 @@

 /**

  * SECTION: nvme

- * @short_description: NVMe device reporting and management.

+ * @short_description: plugin for NVMe device reporting and management

  * @title: NVMe

  * @include: nvme.h

  *

From 0f91582182f1680e979ff5b6e0d7c48a19917abc Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Thu, 29 Jun 2023 14:42:41 +0200

Subject: [PATCH] nvme: Mark private symbols as hidden

---

 src/plugins/nvme/nvme-private.h | 3 +++

 1 file changed, 3 insertions(+)

diff --git a/src/plugins/nvme/nvme-private.h b/src/plugins/nvme/nvme-private.h

index 3d4b2a996..8b6d13253 100644

--- a/src/plugins/nvme/nvme-private.h

+++ b/src/plugins/nvme/nvme-private.h

@@ -16,10 +16,13 @@

 #define _C_LOCALE (locale_t) 0

 /* nvme-error.c */

+G_GNUC_INTERNAL

 void _nvme_status_to_error (gint status, gboolean fabrics, GError **error);

+G_GNUC_INTERNAL

 void _nvme_fabrics_errno_to_gerror (int result, int _errno, GError **error);

 /* nvme-info.c */

+G_GNUC_INTERNAL

 gint _open_dev (const gchar *device, GError **error);

 #endif  /* BD_NVME_PRIVATE */

From ddfb806da578541c7a5a0947e29b81e33f594b11 Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Tue, 8 Aug 2023 16:51:26 +0200

Subject: [PATCH] nvme: Use interim buffer for nvme_get_log_sanitize()

Certain drives tend to return more data than expected resulting

in stack corruption. Use an interim buffer large enough to handle

the excess bytes.

https://github.com/storaged-project/udisks/issues/1152

https://github.com/linux-nvme/libnvme/issues/684

---

 src/plugins/nvme/nvme-info.c | 25 +++++++++++++++----------

 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/plugins/nvme/nvme-info.c b/src/plugins/nvme/nvme-info.c

index bbc7de4f2..2a3d87cff 100644

--- a/src/plugins/nvme/nvme-info.c

+++ b/src/plugins/nvme/nvme-info.c

@@ -1026,7 +1026,8 @@ BDNVMESelfTestLog * bd_nvme_get_self_test_log (const gchar *device, GError **err

 BDNVMESanitizeLog * bd_nvme_get_sanitize_log (const gchar *device, GError **error) {

     int ret;

     int fd;

-    struct nvme_sanitize_log_page sanitize_log = ZERO_INIT;

+    char buf[65536] = ZERO_INIT;

+    struct nvme_sanitize_log_page *sanitize_log;

     BDNVMESanitizeLog *log;

     __u16 sstat;

@@ -1036,7 +1037,7 @@ BDNVMESanitizeLog * bd_nvme_get_sanitize_log (const gchar *device, GError **erro

         return NULL;

     /* send the NVME_LOG_LID_SANITIZE ioctl */

-    ret = nvme_get_log_sanitize (fd, FALSE /* rae */, &sanitize_log);

+    ret = nvme_get_log_sanitize (fd, FALSE /* rae */, (struct nvme_sanitize_log_page *) &buf;;

     if (ret != 0) {

         _nvme_status_to_error (ret, FALSE, error);

         g_prefix_error (error, "NVMe Get Log Page - Sanitize Status Log command error: ");

@@ -1045,12 +1046,16 @@ BDNVMESanitizeLog * bd_nvme_get_sanitize_log (const gchar *device, GError **erro

     }

     close (fd);

-    sstat = GUINT16_FROM_LE (sanitize_log.sstat);

+    /* need to use interim buffer that is large enough for broken drives

+     * returning more data than expected

+     */

+    sanitize_log = (struct nvme_sanitize_log_page *) &buf;

     log = g_new0 (BDNVMESanitizeLog, 1);

     log->sanitize_progress = 0;

+    sstat = GUINT16_FROM_LE (sanitize_log->sstat);

     if ((sstat & NVME_SANITIZE_SSTAT_STATUS_MASK) == NVME_SANITIZE_SSTAT_STATUS_IN_PROGESS)

-        log->sanitize_progress = ((gdouble) GUINT16_FROM_LE (sanitize_log.sprog) * 100) / 0x10000;

+        log->sanitize_progress = ((gdouble) GUINT16_FROM_LE (sanitize_log->sprog) * 100) / 0x10000;

     log->global_data_erased = sstat & NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED;

     log->overwrite_passes = (sstat >> NVME_SANITIZE_SSTAT_COMPLETED_PASSES_SHIFT) & NVME_SANITIZE_SSTAT_COMPLETED_PASSES_MASK;

@@ -1073,12 +1078,12 @@ BDNVMESanitizeLog * bd_nvme_get_sanitize_log (const gchar *device, GError **erro

             break;

     }

-    log->time_for_overwrite = (GUINT32_FROM_LE (sanitize_log.eto) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log.eto);

-    log->time_for_block_erase = (GUINT32_FROM_LE (sanitize_log.etbe) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log.etbe);

-    log->time_for_crypto_erase = (GUINT32_FROM_LE (sanitize_log.etce) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log.etce);

-    log->time_for_overwrite_nd = (GUINT32_FROM_LE (sanitize_log.etond) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log.etond);

-    log->time_for_block_erase_nd = (GUINT32_FROM_LE (sanitize_log.etbend) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log.etbend);

-    log->time_for_crypto_erase_nd = (GUINT32_FROM_LE (sanitize_log.etcend) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log.etcend);

+    log->time_for_overwrite = (GUINT32_FROM_LE (sanitize_log->eto) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log->eto);

+    log->time_for_block_erase = (GUINT32_FROM_LE (sanitize_log->etbe) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log->etbe);

+    log->time_for_crypto_erase = (GUINT32_FROM_LE (sanitize_log->etce) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log->etce);

+    log->time_for_overwrite_nd = (GUINT32_FROM_LE (sanitize_log->etond) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log->etond);

+    log->time_for_block_erase_nd = (GUINT32_FROM_LE (sanitize_log->etbend) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log->etbend);

+    log->time_for_crypto_erase_nd = (GUINT32_FROM_LE (sanitize_log->etcend) == 0xffffffff) ? -1 : (gint64) GUINT32_FROM_LE (sanitize_log->etcend);

     return log;

 }

From c9c3740e20dc891bddb3cfea79e589ad2bf4419f Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Wed, 16 Aug 2023 16:03:11 +0200

Subject: [PATCH] nvme: Generate HostID when missing

Newer kernels tend to refuse connection when no HostID is supplied.

Even non-matching UUIDs within HostNQN/HostID seems to be working

fine with kernel 6.5-rc6.

This should bring us closer to the new HostNQN <--> HostID

mapping validation introduced in kernel-6.5.

---

 src/plugins/nvme/nvme-fabrics.c | 41 +++++++++++++++++++++++++--------

 1 file changed, 32 insertions(+), 9 deletions(-)

diff --git a/src/plugins/nvme/nvme-fabrics.c b/src/plugins/nvme/nvme-fabrics.c

index c79d9e6de..1877845f2 100644

--- a/src/plugins/nvme/nvme-fabrics.c

+++ b/src/plugins/nvme/nvme-fabrics.c

@@ -161,7 +161,7 @@ static void parse_extra_args (const BDExtraArg **extra, struct nvme_fabrics_conf

  * @host_iface: (nullable): The network interface used on the host to connect to the Controller (e.g. IP `eth1`, `enp2s0`). This forces the connection to be made on a specific interface instead of letting the system decide.

  * @host_nqn: (nullable): Overrides the default Host NQN that identifies the NVMe Host. If this option is %NULL, the default is read from `/etc/nvme/hostnqn` first.

  *                        If that does not exist, the autogenerated NQN value from the NVMe Host kernel module is used next. The Host NQN uniquely identifies the NVMe Host.

- * @host_id: (nullable): User-defined host UUID or %NULL to use default (as defined in `/etc/nvme/hostid`)

+ * @host_id: (nullable): User-defined host UUID or %NULL to use default (as defined in `/etc/nvme/hostid`).

  * @extra: (nullable) (array zero-terminated=1): Additional arguments.

  * @error: (out) (nullable): Place to store error (if any).

  *

@@ -244,18 +244,41 @@ gboolean bd_nvme_connect (const gchar *subsysnqn, const gchar *transport, const

         return FALSE;

     }

-    /* parse extra arguments */

-    nvmf_default_config (&cfg;;

-    parse_extra_args (extra, &cfg, &config_file, &hostkey, &ctrlkey, &hostsymname);

-

+    /* HostNQN checks */

     host_nqn_val = g_strdup (host_nqn);

+    host_id_val = g_strdup (host_id);

     if (host_nqn_val == NULL)

         host_nqn_val = nvmf_hostnqn_from_file ();

-    if (host_nqn_val == NULL)

-        host_nqn_val = nvmf_hostnqn_generate ();

-    host_id_val = g_strdup (host_id);

     if (host_id_val == NULL)

         host_id_val = nvmf_hostid_from_file ();

+    if (host_nqn_val == NULL)

+        host_nqn_val = nvmf_hostnqn_generate ();

+    if (host_nqn_val == NULL) {

+        g_set_error_literal (error, BD_NVME_ERROR, BD_NVME_ERROR_INVALID_ARGUMENT,

+                             "Could not determine HostNQN");

+        g_free (host_nqn_val);

+        g_free (host_id_val);

+        return FALSE;

+    }

+    if (host_id_val == NULL) {

+        /* derive hostid from hostnqn, newer kernels refuse empty hostid */

+        host_id_val = g_strrstr (host_nqn_val, "uuid:");

+        if (host_id_val)

+            host_id_val = g_strdup (host_id_val + strlen ("uuid:"));

+        /* TODO: in theory generating arbitrary uuid might work as a fallback */

+    }

+    if (host_id_val == NULL) {

+        g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_INVALID_ARGUMENT,

+                     "Could not determine HostID value from HostNQN '%s'",

+                     host_nqn_val);

+        g_free (host_nqn_val);

+        g_free (host_id_val);

+        return FALSE;

+    }

+

+    /* parse extra arguments */

+    nvmf_default_config (&cfg;;

+    parse_extra_args (extra, &cfg, &config_file, &hostkey, &ctrlkey, &hostsymname);

     root = nvme_scan (config_file);

     g_assert (root != NULL);

@@ -263,7 +286,7 @@ gboolean bd_nvme_connect (const gchar *subsysnqn, const gchar *transport, const

     host = nvme_lookup_host (root, host_nqn_val, host_id_val);

     if (host == NULL) {

         g_set_error (error, BD_NVME_ERROR, BD_NVME_ERROR_FAILED,

-                     "Unable to lookup host for nqn '%s' and id '%s'",

+                     "Unable to lookup host for HostNQN '%s' and HostID '%s'",

                      host_nqn_val, host_id_val);

         g_free (host_nqn_val);

         g_free (host_id_val);

From 2ae0d949eb87142b0212e5953a0e5ad1a146ed6b Mon Sep 17 00:00:00 2001

From: Tomas Bzatek <tbzatek@redhat.com>

Date: Thu, 5 Oct 2023 17:27:57 +0200

Subject: [PATCH] nvme: Rework memory allocation for device ioctls

Make sure to provide pagesize-aligned and large enough buffer

for ioctls that may involve DMA buffer mapping.

---

 src/plugins/nvme/nvme-info.c    | 311 +++++++++++++++++++-------------

 src/plugins/nvme/nvme-op.c      |  30 ++-

 src/plugins/nvme/nvme-private.h |   2 +

 3 files changed, 204 insertions(+), 139 deletions(-)

diff --git a/src/plugins/nvme/nvme-info.c b/src/plugins/nvme/nvme-info.c

index 2a3d87cff..eaf77473c 100644

--- a/src/plugins/nvme/nvme-info.c

+++ b/src/plugins/nvme/nvme-info.c

@@ -402,6 +402,21 @@ gint _open_dev (const gchar *device, GError **error) {

     return fd;

 }

+/* backported from nvme-cli: https://github.com/linux-nvme/nvme-cli/pull/2051 */

+#define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))

+

+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;

+}

+

 static gchar *decode_nvme_rev (guint32 ver) {

     guint16 mjr;

     guint8 mnr, ter = 0;

@@ -452,7 +467,7 @@ static gboolean _nvme_a_is_zero (const __u8 a[], int len) {

 BDNVMEControllerInfo * bd_nvme_get_controller_info (const gchar *device, GError **error) {

     int ret;

     int fd;

-    struct nvme_id_ctrl ctrl_id = ZERO_INIT;

+    struct nvme_id_ctrl *ctrl_id;

     BDNVMEControllerInfo *info;

     /* open the block device */

@@ -460,53 +475,56 @@ BDNVMEControllerInfo * bd_nvme_get_controller_info (const gchar *device, GError

     if (fd < 0)

         return NULL;

+    ctrl_id = _nvme_alloc (sizeof (struct nvme_id_ctrl));

+    g_warn_if_fail (ctrl_id != NULL);

     /* send the NVME_IDENTIFY_CNS_CTRL ioctl */

-    ret = nvme_identify_ctrl (fd, &ctrl_id);

+    ret = nvme_identify_ctrl (fd, ctrl_id);

     if (ret != 0) {

         _nvme_status_to_error (ret, FALSE, error);

         g_prefix_error (error, "NVMe Identify Controller command error: ");

         close (fd);

+        free (ctrl_id);

         return NULL;

     }

     close (fd);

     info = g_new0 (BDNVMEControllerInfo, 1);

-    if ((ctrl_id.cmic & NVME_CTRL_CMIC_MULTI_PORT) == NVME_CTRL_CMIC_MULTI_PORT)

+    if ((ctrl_id->cmic & NVME_CTRL_CMIC_MULTI_PORT) == NVME_CTRL_CMIC_MULTI_PORT)

         info->features |= BD_NVME_CTRL_FEAT_MULTIPORT;

-    if ((ctrl_id.cmic & NVME_CTRL_CMIC_MULTI_CTRL) == NVME_CTRL_CMIC_MULTI_CTRL)

+    if ((ctrl_id->cmic & NVME_CTRL_CMIC_MULTI_CTRL) == NVME_CTRL_CMIC_MULTI_CTRL)

         info->features |= BD_NVME_CTRL_FEAT_MULTICTRL;

-    if ((ctrl_id.cmic & NVME_CTRL_CMIC_MULTI_SRIOV) == NVME_CTRL_CMIC_MULTI_SRIOV)

+    if ((ctrl_id->cmic & NVME_CTRL_CMIC_MULTI_SRIOV) == NVME_CTRL_CMIC_MULTI_SRIOV)

         info->features |= BD_NVME_CTRL_FEAT_SRIOV;

-    if ((ctrl_id.cmic & NVME_CTRL_CMIC_MULTI_ANA_REPORTING) == NVME_CTRL_CMIC_MULTI_ANA_REPORTING)

+    if ((ctrl_id->cmic & NVME_CTRL_CMIC_MULTI_ANA_REPORTING) == NVME_CTRL_CMIC_MULTI_ANA_REPORTING)

         info->features |= BD_NVME_CTRL_FEAT_ANA_REPORTING;

-    if ((ctrl_id.nvmsr & NVME_CTRL_NVMSR_NVMESD) == NVME_CTRL_NVMSR_NVMESD)

+    if ((ctrl_id->nvmsr & NVME_CTRL_NVMSR_NVMESD) == NVME_CTRL_NVMSR_NVMESD)

         info->features |= BD_NVME_CTRL_FEAT_STORAGE_DEVICE;

-    if ((ctrl_id.nvmsr & NVME_CTRL_NVMSR_NVMEE) == NVME_CTRL_NVMSR_NVMEE)

+    if ((ctrl_id->nvmsr & NVME_CTRL_NVMSR_NVMEE) == NVME_CTRL_NVMSR_NVMEE)

         info->features |= BD_NVME_CTRL_FEAT_ENCLOSURE;

-    if ((ctrl_id.mec & NVME_CTRL_MEC_PCIEME) == NVME_CTRL_MEC_PCIEME)

+    if ((ctrl_id->mec & NVME_CTRL_MEC_PCIEME) == NVME_CTRL_MEC_PCIEME)

         info->features |= BD_NVME_CTRL_FEAT_MGMT_PCIE;

-    if ((ctrl_id.mec & NVME_CTRL_MEC_SMBUSME) == NVME_CTRL_MEC_SMBUSME)

+    if ((ctrl_id->mec & NVME_CTRL_MEC_SMBUSME) == NVME_CTRL_MEC_SMBUSME)

         info->features |= BD_NVME_CTRL_FEAT_MGMT_SMBUS;

-    info->pci_vendor_id = GUINT16_FROM_LE (ctrl_id.vid);

-    info->pci_subsys_vendor_id = GUINT16_FROM_LE (ctrl_id.ssvid);

-    info->ctrl_id = GUINT16_FROM_LE (ctrl_id.cntlid);

-    if (!_nvme_a_is_zero (ctrl_id.fguid, sizeof (ctrl_id.fguid)))

-        info->fguid = _uuid_to_str (ctrl_id.fguid);

-    info->model_number = g_strndup (ctrl_id.mn, sizeof (ctrl_id.mn));

+    info->pci_vendor_id = GUINT16_FROM_LE (ctrl_id->vid);

+    info->pci_subsys_vendor_id = GUINT16_FROM_LE (ctrl_id->ssvid);

+    info->ctrl_id = GUINT16_FROM_LE (ctrl_id->cntlid);

+    if (!_nvme_a_is_zero (ctrl_id->fguid, sizeof (ctrl_id->fguid)))

+        info->fguid = _uuid_to_str (ctrl_id->fguid);

+    info->model_number = g_strndup (ctrl_id->mn, sizeof (ctrl_id->mn));

     g_strstrip (info->model_number);

-    info->serial_number = g_strndup (ctrl_id.sn, sizeof (ctrl_id.sn));

+    info->serial_number = g_strndup (ctrl_id->sn, sizeof (ctrl_id->sn));

     g_strstrip (info->serial_number);

-    info->firmware_ver = g_strndup (ctrl_id.fr, sizeof (ctrl_id.fr));

+    info->firmware_ver = g_strndup (ctrl_id->fr, sizeof (ctrl_id->fr));

     g_strstrip (info->firmware_ver);

-    info->nvme_ver = decode_nvme_rev (GUINT32_FROM_LE (ctrl_id.ver));

+    info->nvme_ver = decode_nvme_rev (GUINT32_FROM_LE (ctrl_id->ver));

     /* TODO: vwci: VPD Write Cycle Information */

-    if ((ctrl_id.oacs & NVME_CTRL_OACS_FORMAT) == NVME_CTRL_OACS_FORMAT)

+    if ((ctrl_id->oacs & NVME_CTRL_OACS_FORMAT) == NVME_CTRL_OACS_FORMAT)

         info->features |= BD_NVME_CTRL_FEAT_FORMAT;

-    if ((ctrl_id.oacs & NVME_CTRL_OACS_NS_MGMT) == NVME_CTRL_OACS_NS_MGMT)

+    if ((ctrl_id->oacs & NVME_CTRL_OACS_NS_MGMT) == NVME_CTRL_OACS_NS_MGMT)

         info->features |= BD_NVME_CTRL_FEAT_NS_MGMT;

-    if ((ctrl_id.oacs & NVME_CTRL_OACS_SELF_TEST) == NVME_CTRL_OACS_SELF_TEST)

+    if ((ctrl_id->oacs & NVME_CTRL_OACS_SELF_TEST) == NVME_CTRL_OACS_SELF_TEST)

         info->features |= BD_NVME_CTRL_FEAT_SELFTEST;

-    switch (ctrl_id.cntrltype) {

+    switch (ctrl_id->cntrltype) {

         case NVME_CTRL_CNTRLTYPE_IO:

             info->controller_type = BD_NVME_CTRL_TYPE_IO;

             break;

@@ -519,36 +537,37 @@ BDNVMEControllerInfo * bd_nvme_get_controller_info (const gchar *device, GError

         default:

             info->controller_type = BD_NVME_CTRL_TYPE_UNKNOWN;

     }

-    info->hmb_pref_size = GUINT32_FROM_LE (ctrl_id.hmpre) * 4096LL;

-    info->hmb_min_size = GUINT32_FROM_LE (ctrl_id.hmmin) * 4096LL;

-    info->size_total = int128_to_guint64 (ctrl_id.tnvmcap);

-    info->size_unalloc = int128_to_guint64 (ctrl_id.unvmcap);

-    info->selftest_ext_time = GUINT16_FROM_LE (ctrl_id.edstt);

+    info->hmb_pref_size = GUINT32_FROM_LE (ctrl_id->hmpre) * 4096LL;

+    info->hmb_min_size = GUINT32_FROM_LE (ctrl_id->hmmin) * 4096LL;

+    info->size_total = int128_to_guint64 (ctrl_id->tnvmcap);

+    info->size_unalloc = int128_to_guint64 (ctrl_id->unvmcap);

+    info->selftest_ext_time = GUINT16_FROM_LE (ctrl_id->edstt);

     /* TODO: lpa: Log Page Attributes - NVME_CTRL_LPA_PERSETENT_EVENT: Persistent Event log */

-    if ((ctrl_id.dsto & NVME_CTRL_DSTO_ONE_DST) == NVME_CTRL_DSTO_ONE_DST)

+    if ((ctrl_id->dsto & NVME_CTRL_DSTO_ONE_DST) == NVME_CTRL_DSTO_ONE_DST)

         info->features |= BD_NVME_CTRL_FEAT_SELFTEST_SINGLE;

-    if ((ctrl_id.sanicap & NVME_CTRL_SANICAP_CES) == NVME_CTRL_SANICAP_CES)

+    if ((ctrl_id->sanicap & NVME_CTRL_SANICAP_CES) == NVME_CTRL_SANICAP_CES)

         info->features |= BD_NVME_CTRL_FEAT_SANITIZE_CRYPTO;

-    if ((ctrl_id.sanicap & NVME_CTRL_SANICAP_BES) == NVME_CTRL_SANICAP_BES)

+    if ((ctrl_id->sanicap & NVME_CTRL_SANICAP_BES) == NVME_CTRL_SANICAP_BES)

         info->features |= BD_NVME_CTRL_FEAT_SANITIZE_BLOCK;

-    if ((ctrl_id.sanicap & NVME_CTRL_SANICAP_OWS) == NVME_CTRL_SANICAP_OWS)

+    if ((ctrl_id->sanicap & NVME_CTRL_SANICAP_OWS) == NVME_CTRL_SANICAP_OWS)

         info->features |= BD_NVME_CTRL_FEAT_SANITIZE_OVERWRITE;

     /* struct nvme_id_ctrl.nn: If the &struct nvme_id_ctrl.mnan field is cleared to 0h,

      * then the struct nvme_id_ctrl.nn field also indicates the maximum number of namespaces

      * supported by the NVM subsystem.

      */

-    info->num_namespaces = GUINT32_FROM_LE (ctrl_id.mnan) == 0 ? GUINT32_FROM_LE (ctrl_id.nn) : GUINT32_FROM_LE (ctrl_id.mnan);

-    if ((ctrl_id.fna & NVME_CTRL_FNA_FMT_ALL_NAMESPACES) == NVME_CTRL_FNA_FMT_ALL_NAMESPACES)

+    info->num_namespaces = GUINT32_FROM_LE (ctrl_id->mnan) == 0 ? GUINT32_FROM_LE (ctrl_id->nn) : GUINT32_FROM_LE (ctrl_id->mnan);

+    if ((ctrl_id->fna & NVME_CTRL_FNA_FMT_ALL_NAMESPACES) == NVME_CTRL_FNA_FMT_ALL_NAMESPACES)

         info->features |= BD_NVME_CTRL_FEAT_FORMAT_ALL_NS;

-    if ((ctrl_id.fna & NVME_CTRL_FNA_SEC_ALL_NAMESPACES) == NVME_CTRL_FNA_SEC_ALL_NAMESPACES)

+    if ((ctrl_id->fna & NVME_CTRL_FNA_SEC_ALL_NAMESPACES) == NVME_CTRL_FNA_SEC_ALL_NAMESPACES)

         info->features |= BD_NVME_CTRL_FEAT_SECURE_ERASE_ALL_NS;

-    if ((ctrl_id.fna & NVME_CTRL_FNA_CRYPTO_ERASE) == NVME_CTRL_FNA_CRYPTO_ERASE)

+    if ((ctrl_id->fna & NVME_CTRL_FNA_CRYPTO_ERASE) == NVME_CTRL_FNA_CRYPTO_ERASE)

         info->features |= BD_NVME_CTRL_FEAT_SECURE_ERASE_CRYPTO;

     /* TODO: enum nvme_id_ctrl_oncs: NVME_CTRL_ONCS_WRITE_UNCORRECTABLE, NVME_CTRL_ONCS_WRITE_ZEROES... */

     /* TODO: nwpc: Namespace Write Protection Capabilities */

-    info->subsysnqn = g_strndup (ctrl_id.subnqn, sizeof (ctrl_id.subnqn));

+    info->subsysnqn = g_strndup (ctrl_id->subnqn, sizeof (ctrl_id->subnqn));

     g_strstrip (info->subsysnqn);

+    free (ctrl_id);

     return info;

 }

@@ -572,10 +591,10 @@ BDNVMENamespaceInfo *bd_nvme_get_namespace_info (const gchar *device, GError **e

     int ret_ns_ind = -1;

     int fd;

     __u32 nsid = 0;

-    struct nvme_id_ctrl ctrl_id = ZERO_INIT;

-    struct nvme_id_ns ns_info = ZERO_INIT;

-    struct nvme_id_independent_id_ns ns_info_ind = ZERO_INIT;

-    uint8_t desc[NVME_IDENTIFY_DATA_SIZE] = ZERO_INIT;

+    struct nvme_id_ctrl *ctrl_id;

+    struct nvme_id_ns *ns_info;

+    struct nvme_id_independent_id_ns *ns_info_ind = NULL;

+    struct nvme_ns_id_desc *descs = NULL;

     guint8 flbas;

     guint i;

     guint len;

@@ -597,44 +616,55 @@ BDNVMENamespaceInfo *bd_nvme_get_namespace_info (const gchar *device, GError **e

     }

     /* send the NVME_IDENTIFY_CNS_NS ioctl */

-    ret = nvme_identify_ns (fd, nsid, &ns_info);

+    ns_info = _nvme_alloc (sizeof (struct nvme_id_ns));

+    g_warn_if_fail (ns_info != NULL);