path: root/0011-nvme_libblockdev-3.0.4_backport.patch

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);
+    ret = nvme_identify_ns (fd, nsid, ns_info);
     if (ret != 0) {
         _nvme_status_to_error (ret, FALSE, error);
         g_prefix_error (error, "NVMe Identify Namespace command error: ");
         close (fd);
+        free (ns_info);
         return NULL;
     }
 
     /* send the NVME_IDENTIFY_CNS_CTRL ioctl */
-    ret_ctrl = nvme_identify_ctrl (fd, &ctrl_id);
+    ctrl_id = _nvme_alloc (sizeof (struct nvme_id_ctrl));
+    g_warn_if_fail (ctrl_id != NULL);
+    ret_ctrl = nvme_identify_ctrl (fd, ctrl_id);
 
     /* send the NVME_IDENTIFY_CNS_NS_DESC_LIST ioctl, NVMe 1.3 */
-    if (ret_ctrl == 0 && GUINT32_FROM_LE (ctrl_id.ver) >= 0x10300)
-        ret_desc = nvme_identify_ns_descs (fd, nsid, (struct nvme_ns_id_desc *) &desc);
+    if (ret_ctrl == 0 && GUINT32_FROM_LE (ctrl_id->ver) >= 0x10300) {
+        descs = _nvme_alloc (NVME_IDENTIFY_DATA_SIZE);
+        g_warn_if_fail (descs != NULL);
+        ret_desc = nvme_identify_ns_descs (fd, nsid, descs);
+    }
 
     /* send the NVME_IDENTIFY_CNS_CSI_INDEPENDENT_ID_NS ioctl, NVMe 2.0 */
-    if (ret_ctrl == 0 && GUINT32_FROM_LE (ctrl_id.ver) >= 0x20000)
-        ret_ns_ind = nvme_identify_independent_identify_ns (fd, nsid, &ns_info_ind);
+    if (ret_ctrl == 0 && GUINT32_FROM_LE (ctrl_id->ver) >= 0x20000) {
+        ns_info_ind = _nvme_alloc (sizeof (struct nvme_id_independent_id_ns));
+        g_warn_if_fail (ns_info_ind != NULL);
+        ret_ns_ind = nvme_identify_independent_identify_ns (fd, nsid, ns_info_ind);
+    }
     close (fd);
 
     info = g_new0 (BDNVMENamespaceInfo, 1);
     info->nsid = nsid;
-    info->nsize = GUINT64_FROM_LE (ns_info.nsze);
-    info->ncap = GUINT64_FROM_LE (ns_info.ncap);
-    info->nuse = GUINT64_FROM_LE (ns_info.nuse);
-    if ((ns_info.nsfeat & NVME_NS_FEAT_THIN) == NVME_NS_FEAT_THIN)
+    info->nsize = GUINT64_FROM_LE (ns_info->nsze);
+    info->ncap = GUINT64_FROM_LE (ns_info->ncap);
+    info->nuse = GUINT64_FROM_LE (ns_info->nuse);
+    if ((ns_info->nsfeat & NVME_NS_FEAT_THIN) == NVME_NS_FEAT_THIN)
         info->features |= BD_NVME_NS_FEAT_THIN;
-    if ((ns_info.nmic & NVME_NS_NMIC_SHARED) == NVME_NS_NMIC_SHARED)
+    if ((ns_info->nmic & NVME_NS_NMIC_SHARED) == NVME_NS_NMIC_SHARED)
         info->features |= BD_NVME_NS_FEAT_MULTIPATH_SHARED;
-    if ((ns_info.fpi & NVME_NS_FPI_SUPPORTED) == NVME_NS_FPI_SUPPORTED)
+    if ((ns_info->fpi & NVME_NS_FPI_SUPPORTED) == NVME_NS_FPI_SUPPORTED)
         info->features |= BD_NVME_NS_FEAT_FORMAT_PROGRESS;
-    info->format_progress_remaining = ns_info.fpi & NVME_NS_FPI_REMAINING;
-    /* TODO: what the ns_info.nvmcap really stands for? */
-    info->write_protected = (ns_info.nsattr & NVME_NS_NSATTR_WRITE_PROTECTED) == NVME_NS_NSATTR_WRITE_PROTECTED;
+    info->format_progress_remaining = ns_info->fpi & NVME_NS_FPI_REMAINING;
+    /* TODO: what the ns_info->nvmcap really stands for? */
+    info->write_protected = (ns_info->nsattr & NVME_NS_NSATTR_WRITE_PROTECTED) == NVME_NS_NSATTR_WRITE_PROTECTED;
 
     if (ret_desc == 0) {
         for (i = 0; i < NVME_IDENTIFY_DATA_SIZE; i += len) {
-            struct nvme_ns_id_desc *d = (void *) desc + i;
+            struct nvme_ns_id_desc *d = descs + i;
 
             if (!d->nidl)
                 break;
@@ -661,29 +691,29 @@ BDNVMENamespaceInfo *bd_nvme_get_namespace_info (const gchar *device, GError **e
         }
     }
 
-    if (info->nguid == NULL && !_nvme_a_is_zero (ns_info.nguid, sizeof (ns_info.nguid))) {
-        info->nguid = g_malloc0 (sizeof (ns_info.nguid) * 2 + 1);
-        for (i = 0; i < sizeof (ns_info.nguid); i++)
-            snprintf (info->nguid + i * 2, 3, "%02x", ns_info.nguid[i]);
+    if (info->nguid == NULL && !_nvme_a_is_zero (ns_info->nguid, sizeof (ns_info->nguid))) {
+        info->nguid = g_malloc0 (sizeof (ns_info->nguid) * 2 + 1);
+        for (i = 0; i < sizeof (ns_info->nguid); i++)
+            snprintf (info->nguid + i * 2, 3, "%02x", ns_info->nguid[i]);
     }
-    if (info->eui64 == NULL && !_nvme_a_is_zero (ns_info.eui64, sizeof (ns_info.eui64))) {
-        info->eui64 = g_malloc0 (sizeof (ns_info.eui64) * 2 + 1);
-        for (i = 0; i < sizeof (ns_info.eui64); i++)
-            snprintf (info->eui64 + i * 2, 3, "%02x", ns_info.eui64[i]);
+    if (info->eui64 == NULL && !_nvme_a_is_zero (ns_info->eui64, sizeof (ns_info->eui64))) {
+        info->eui64 = g_malloc0 (sizeof (ns_info->eui64) * 2 + 1);
+        for (i = 0; i < sizeof (ns_info->eui64); i++)
+            snprintf (info->eui64 + i * 2, 3, "%02x", ns_info->eui64[i]);
     }
     if (ret_ns_ind == 0) {
-        if ((ns_info_ind.nsfeat & 1 << 4) == 1 << 4)
+        if ((ns_info_ind->nsfeat & 1 << 4) == 1 << 4)
             info->features |= BD_NVME_NS_FEAT_ROTATIONAL;
     }
 
     /* translate the LBA Format array */
     ptr_array = g_ptr_array_new ();
-    nvme_id_ns_flbas_to_lbaf_inuse (ns_info.flbas, &flbas);
-    for (i = 0; i <= ns_info.nlbaf + ns_info.nulbaf; i++) {
+    nvme_id_ns_flbas_to_lbaf_inuse (ns_info->flbas, &flbas);
+    for (i = 0; i <= ns_info->nlbaf + ns_info->nulbaf; i++) {
         BDNVMELBAFormat *lbaf = g_new0 (BDNVMELBAFormat, 1);
-        lbaf->data_size = 1 << ns_info.lbaf[i].ds;
-        lbaf->metadata_size = GUINT16_FROM_LE (ns_info.lbaf[i].ms);
-        lbaf->relative_performance = ns_info.lbaf[i].rp + 1;
+        lbaf->data_size = 1 << ns_info->lbaf[i].ds;
+        lbaf->metadata_size = GUINT16_FROM_LE (ns_info->lbaf[i].ms);
+        lbaf->relative_performance = ns_info->lbaf[i].rp + 1;
         g_ptr_array_add (ptr_array, lbaf);
         if (i == flbas) {
             info->current_lba_format.data_size = lbaf->data_size;
@@ -694,6 +724,10 @@ BDNVMENamespaceInfo *bd_nvme_get_namespace_info (const gchar *device, GError **e
     g_ptr_array_add (ptr_array, NULL);  /* trailing NULL element */
     info->lba_formats = (BDNVMELBAFormat **) g_ptr_array_free (ptr_array, FALSE);
 
+    free (ctrl_id);
+    free (ns_info);
+    free (ns_info_ind);
+    free (descs);
     return info;
 }
 
@@ -714,8 +748,8 @@ BDNVMESmartLog * bd_nvme_get_smart_log (const gchar *device, GError **error) {
     int ret;
     int ret_identify;
     int fd;
-    struct nvme_id_ctrl ctrl_id = ZERO_INIT;
-    struct nvme_smart_log smart_log = ZERO_INIT;
+    struct nvme_id_ctrl *ctrl_id;
+    struct nvme_smart_log *smart_log;
     BDNVMESmartLog *log;
     guint i;
 
@@ -724,59 +758,66 @@ BDNVMESmartLog * bd_nvme_get_smart_log (const gchar *device, GError **error) {
     if (fd < 0)
         return NULL;
 
-    /* send the NVME_IDENTIFY_CNS_NS + NVME_IDENTIFY_CNS_CTRL ioctl */
-    ret_identify = nvme_identify_ctrl (fd, &ctrl_id);
+    /* send the NVME_IDENTIFY_CNS_CTRL ioctl */
+    ctrl_id = _nvme_alloc (sizeof (struct nvme_id_ctrl));
+    g_warn_if_fail (ctrl_id != NULL);
+    ret_identify = nvme_identify_ctrl (fd, ctrl_id);
     if (ret_identify != 0) {
         _nvme_status_to_error (ret_identify, FALSE, error);
         g_prefix_error (error, "NVMe Identify Controller command error: ");
         close (fd);
+        free (ctrl_id);
         return NULL;
     }
 
     /* send the NVME_LOG_LID_SMART ioctl */
-    ret = nvme_get_log_smart (fd, NVME_NSID_ALL, FALSE /* rae */, &smart_log);
+    smart_log = _nvme_alloc (sizeof (struct nvme_smart_log));
+    g_warn_if_fail (smart_log != NULL);
+    ret = nvme_get_log_smart (fd, NVME_NSID_ALL, FALSE /* rae */, smart_log);
     if (ret != 0) {
         _nvme_status_to_error (ret, FALSE, error);
         g_prefix_error (error, "NVMe Get Log Page - SMART / Health Information Log command error: ");
         close (fd);
+        free (ctrl_id);
+        free (smart_log);
         return NULL;
     }
     close (fd);
 
     log = g_new0 (BDNVMESmartLog, 1);
-    if ((smart_log.critical_warning & NVME_SMART_CRIT_SPARE) == NVME_SMART_CRIT_SPARE)
+    if ((smart_log->critical_warning & NVME_SMART_CRIT_SPARE) == NVME_SMART_CRIT_SPARE)
         log->critical_warning |= BD_NVME_SMART_CRITICAL_WARNING_SPARE;
-    if ((smart_log.critical_warning & NVME_SMART_CRIT_TEMPERATURE) == NVME_SMART_CRIT_TEMPERATURE)
+    if ((smart_log->critical_warning & NVME_SMART_CRIT_TEMPERATURE) == NVME_SMART_CRIT_TEMPERATURE)
         log->critical_warning |= BD_NVME_SMART_CRITICAL_WARNING_TEMPERATURE;
-    if ((smart_log.critical_warning & NVME_SMART_CRIT_DEGRADED) == NVME_SMART_CRIT_DEGRADED)
+    if ((smart_log->critical_warning & NVME_SMART_CRIT_DEGRADED) == NVME_SMART_CRIT_DEGRADED)
         log->critical_warning |= BD_NVME_SMART_CRITICAL_WARNING_DEGRADED;
-    if ((smart_log.critical_warning & NVME_SMART_CRIT_MEDIA) == NVME_SMART_CRIT_MEDIA)
+    if ((smart_log->critical_warning & NVME_SMART_CRIT_MEDIA) == NVME_SMART_CRIT_MEDIA)
         log->critical_warning |= BD_NVME_SMART_CRITICAL_WARNING_READONLY;
-    if ((smart_log.critical_warning & NVME_SMART_CRIT_VOLATILE_MEMORY) == NVME_SMART_CRIT_VOLATILE_MEMORY)
+    if ((smart_log->critical_warning & NVME_SMART_CRIT_VOLATILE_MEMORY) == NVME_SMART_CRIT_VOLATILE_MEMORY)
         log->critical_warning |= BD_NVME_SMART_CRITICAL_WARNING_VOLATILE_MEM;
-    if ((smart_log.critical_warning & NVME_SMART_CRIT_PMR_RO) == NVME_SMART_CRIT_PMR_RO)
+    if ((smart_log->critical_warning & NVME_SMART_CRIT_PMR_RO) == NVME_SMART_CRIT_PMR_RO)
         log->critical_warning |= BD_NVME_SMART_CRITICAL_WARNING_PMR_READONLY;
-    log->avail_spare = smart_log.avail_spare;
-    log->spare_thresh = smart_log.spare_thresh;
-    log->percent_used = smart_log.percent_used;
-    log->total_data_read = int128_to_guint64 (smart_log.data_units_read) * 1000 * 512;
-    log->total_data_written = int128_to_guint64 (smart_log.data_units_written) * 1000 * 512;
-    log->ctrl_busy_time = int128_to_guint64 (smart_log.ctrl_busy_time);
-    log->power_cycles = int128_to_guint64 (smart_log.power_cycles);
-    log->power_on_hours = int128_to_guint64 (smart_log.power_on_hours);
-    log->unsafe_shutdowns = int128_to_guint64 (smart_log.unsafe_shutdowns);
-    log->media_errors = int128_to_guint64 (smart_log.media_errors);
-    log->num_err_log_entries = int128_to_guint64 (smart_log.num_err_log_entries);
-
-    log->temperature = (smart_log.temperature[1] << 8) | smart_log.temperature[0];
-    for (i = 0; i < G_N_ELEMENTS (smart_log.temp_sensor); i++)
-        log->temp_sensors[i] = GUINT16_FROM_LE (smart_log.temp_sensor[i]);
-    log->warning_temp_time = GUINT32_FROM_LE (smart_log.warning_temp_time);
-    log->critical_temp_time = GUINT32_FROM_LE (smart_log.critical_comp_time);
+    log->avail_spare = smart_log->avail_spare;
+    log->spare_thresh = smart_log->spare_thresh;
+    log->percent_used = smart_log->percent_used;
+    log->total_data_read = int128_to_guint64 (smart_log->data_units_read) * 1000 * 512;
+    log->total_data_written = int128_to_guint64 (smart_log->data_units_written) * 1000 * 512;
+    log->ctrl_busy_time = int128_to_guint64 (smart_log->ctrl_busy_time);
+    log->power_cycles = int128_to_guint64 (smart_log->power_cycles);
+    log->power_on_hours = int128_to_guint64 (smart_log->power_on_hours);
+    log->unsafe_shutdowns = int128_to_guint64 (smart_log->unsafe_shutdowns);
+    log->media_errors = int128_to_guint64 (smart_log->media_errors);
+    log->num_err_log_entries = int128_to_guint64 (smart_log->num_err_log_entries);
+
+    log->temperature = (smart_log->temperature[1] << 8) | smart_log->temperature[0];
+    for (i = 0; i < G_N_ELEMENTS (smart_log->temp_sensor); i++)
+        log->temp_sensors[i] = GUINT16_FROM_LE (smart_log->temp_sensor[i]);
+    log->warning_temp_time = GUINT32_FROM_LE (smart_log->warning_temp_time);
+    log->critical_temp_time = GUINT32_FROM_LE (smart_log->critical_comp_time);
 
     if (ret_identify == 0) {
-        log->wctemp = GUINT16_FROM_LE (ctrl_id.wctemp);
-        log->cctemp = GUINT16_FROM_LE (ctrl_id.cctemp);
+        log->wctemp = GUINT16_FROM_LE (ctrl_id->wctemp);
+        log->cctemp = GUINT16_FROM_LE (ctrl_id->cctemp);
     }
 
     /* FIXME: intentionally not providing Host Controlled Thermal Management attributes
@@ -784,6 +825,8 @@ BDNVMESmartLog * bd_nvme_get_smart_log (const gchar *device, GError **error) {
      *        Power State attributes. Subject to re-evaluation in the future.
      */
 
+    free (ctrl_id);
+    free (smart_log);
     return log;
 }
 
@@ -810,7 +853,7 @@ BDNVMEErrorLogEntry ** bd_nvme_get_error_log_entries (const gchar *device, GErro
     int ret;
     int fd;
     guint elpe;
-    struct nvme_id_ctrl ctrl_id = ZERO_INIT;
+    struct nvme_id_ctrl *ctrl_id;
     struct nvme_error_log_page *err_log;
     GPtrArray *ptr_array;
     guint i;
@@ -821,23 +864,29 @@ BDNVMEErrorLogEntry ** bd_nvme_get_error_log_entries (const gchar *device, GErro
         return NULL;
 
     /* find out the maximum number of error log entries as reported by the controller */
-    ret = nvme_identify_ctrl (fd, &ctrl_id);
+    ctrl_id = _nvme_alloc (sizeof (struct nvme_id_ctrl));
+    g_warn_if_fail (ctrl_id != NULL);
+    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;
     }
 
+    elpe = ctrl_id->elpe + 1;
+    free (ctrl_id);
+
     /* send the NVME_LOG_LID_ERROR ioctl */
-    elpe = ctrl_id.elpe + 1;
-    err_log = g_new0 (struct nvme_error_log_page, elpe);
+    err_log = _nvme_alloc (sizeof (struct nvme_error_log_page) * elpe);
+    g_warn_if_fail (err_log != NULL);
     ret = nvme_get_log_error (fd, elpe, FALSE /* rae */, err_log);
     if (ret != 0) {
         _nvme_status_to_error (ret, FALSE, error);
         g_prefix_error (error, "NVMe Get Log Page - Error Information Log Entry command error: ");
-        g_free (err_log);
         close (fd);
+        free (err_log);
         return NULL;
     }
     close (fd);
@@ -863,7 +912,7 @@ BDNVMEErrorLogEntry ** bd_nvme_get_error_log_entries (const gchar *device, GErro
         }
     }
     g_ptr_array_add (ptr_array, NULL);  /* trailing NULL element */
-    g_free (err_log);
+    free (err_log);
 
     return (BDNVMEErrorLogEntry **) g_ptr_array_free (ptr_array, FALSE);
 }
@@ -885,7 +934,7 @@ BDNVMEErrorLogEntry ** bd_nvme_get_error_log_entries (const gchar *device, GErro
 BDNVMESelfTestLog * bd_nvme_get_self_test_log (const gchar *device, GError **error) {
     int ret;
     int fd;
-    struct nvme_self_test_log self_test_log = ZERO_INIT;
+    struct nvme_self_test_log *self_test_log;
     BDNVMESelfTestLog *log;
     GPtrArray *ptr_array;
     guint i;
@@ -896,17 +945,20 @@ BDNVMESelfTestLog * bd_nvme_get_self_test_log (const gchar *device, GError **err
         return NULL;
 
     /* send the NVME_LOG_LID_DEVICE_SELF_TEST ioctl */
-    ret = nvme_get_log_device_self_test (fd, &self_test_log);
+    self_test_log = _nvme_alloc (sizeof (struct nvme_self_test_log));
+    g_warn_if_fail (self_test_log != NULL);
+    ret = nvme_get_log_device_self_test (fd, self_test_log);
     if (ret != 0) {
         _nvme_status_to_error (ret, FALSE, error);
         g_prefix_error (error, "NVMe Get Log Page - Device Self-test Log command error: ");
         close (fd);
+        free (self_test_log);
         return NULL;
     }
     close (fd);
 
     log = g_new0 (BDNVMESelfTestLog, 1);
-    switch (self_test_log.current_operation & NVME_ST_CURR_OP_MASK) {
+    switch (self_test_log->current_operation & NVME_ST_CURR_OP_MASK) {
         case NVME_ST_CURR_OP_NOT_RUNNING:
             log->current_operation = BD_NVME_SELF_TEST_ACTION_NOT_RUNNING;
             break;
@@ -921,8 +973,8 @@ BDNVMESelfTestLog * bd_nvme_get_self_test_log (const gchar *device, GError **err
         default:
             log->current_operation = BD_NVME_SELF_TEST_ACTION_VENDOR_SPECIFIC;
     }
-    if ((self_test_log.current_operation & NVME_ST_CURR_OP_MASK) > 0)
-        log->current_operation_completion = self_test_log.completion & NVME_ST_CURR_OP_CMPL_MASK;
+    if ((self_test_log->current_operation & NVME_ST_CURR_OP_MASK) > 0)
+        log->current_operation_completion = self_test_log->completion & NVME_ST_CURR_OP_CMPL_MASK;
 
     ptr_array = g_ptr_array_new ();
     for (i = 0; i < NVME_LOG_ST_MAX_RESULTS; i++) {
@@ -930,8 +982,8 @@ BDNVMESelfTestLog * bd_nvme_get_self_test_log (const gchar *device, GError **err
         guint8 dsts;
         guint8 code;
 
-        dsts = self_test_log.result[i].dsts & NVME_ST_RESULT_MASK;
-        code = self_test_log.result[i].dsts >> NVME_ST_CODE_SHIFT;
+        dsts = self_test_log->result[i].dsts & NVME_ST_RESULT_MASK;
+        code = self_test_log->result[i].dsts >> NVME_ST_CODE_SHIFT;
         if (dsts == NVME_ST_RESULT_NOT_USED)
             continue;
 
@@ -987,21 +1039,22 @@ BDNVMESelfTestLog * bd_nvme_get_self_test_log (const gchar *device, GError **err
                 g_warning ("Unhandled self-test log entry action code: %d", code);
                 entry->action = BD_NVME_SELF_TEST_ACTION_VENDOR_SPECIFIC;
         }
-        entry->segment = self_test_log.result[i].seg;
-        entry->power_on_hours = GUINT64_FROM_LE (self_test_log.result[i].poh);
-        if (self_test_log.result[i].vdi & NVME_ST_VALID_DIAG_INFO_NSID)
-            entry->nsid = GUINT32_FROM_LE (self_test_log.result[i].nsid);
-        if (self_test_log.result[i].vdi & NVME_ST_VALID_DIAG_INFO_FLBA)
-            entry->failing_lba = GUINT64_FROM_LE (self_test_log.result[i].flba);
-        if ((self_test_log.result[i].vdi & NVME_ST_VALID_DIAG_INFO_SC) &&
-            (self_test_log.result[i].vdi & NVME_ST_VALID_DIAG_INFO_SCT))
-            _nvme_status_to_error ((self_test_log.result[i].sct & 7) << 8 | self_test_log.result[i].sc,
+        entry->segment = self_test_log->result[i].seg;
+        entry->power_on_hours = GUINT64_FROM_LE (self_test_log->result[i].poh);
+        if (self_test_log->result[i].vdi & NVME_ST_VALID_DIAG_INFO_NSID)
+            entry->nsid = GUINT32_FROM_LE (self_test_log->result[i].nsid);
+        if (self_test_log->result[i].vdi & NVME_ST_VALID_DIAG_INFO_FLBA)
+            entry->failing_lba = GUINT64_FROM_LE (self_test_log->result[i].flba);
+        if ((self_test_log->result[i].vdi & NVME_ST_VALID_DIAG_INFO_SC) &&
+            (self_test_log->result[i].vdi & NVME_ST_VALID_DIAG_INFO_SCT))
+            _nvme_status_to_error ((self_test_log->result[i].sct & 7) << 8 | self_test_log->result[i].sc,
                                    FALSE, &entry->status_code_error);
 
         g_ptr_array_add (ptr_array, entry);
     }
     g_ptr_array_add (ptr_array, NULL);
     log->entries = (BDNVMESelfTestLogEntry **) g_ptr_array_free (ptr_array, FALSE);
+    free (self_test_log);
 
     return log;
 }
@@ -1026,7 +1079,6 @@ 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;
-    char buf[65536] = ZERO_INIT;
     struct nvme_sanitize_log_page *sanitize_log;
     BDNVMESanitizeLog *log;
     __u16 sstat;
@@ -1037,20 +1089,18 @@ 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 */, (struct nvme_sanitize_log_page *) &buf);
+    sanitize_log = _nvme_alloc (sizeof (struct nvme_sanitize_log_page));
+    g_warn_if_fail (sanitize_log != NULL);
+    ret = nvme_get_log_sanitize (fd, FALSE /* rae */, sanitize_log);
     if (ret != 0) {
         _nvme_status_to_error (ret, FALSE, error);
         g_prefix_error (error, "NVMe Get Log Page - Sanitize Status Log command error: ");
         close (fd);
+        free (sanitize_log);
         return NULL;
     }
     close (fd);
 
-    /* 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);
@@ -1085,5 +1135,6 @@ BDNVMESanitizeLog * bd_nvme_get_sanitize_log (const gchar *device, GError **erro
     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);
 
+    free (sanitize_log);
     return log;
 }
diff --git a/src/plugins/nvme/nvme-op.c b/src/plugins/nvme/nvme-op.c
index c9e92697c..dbef4f3a2 100644
--- a/src/plugins/nvme/nvme-op.c
+++ b/src/plugins/nvme/nvme-op.c
@@ -116,30 +116,37 @@ gboolean bd_nvme_device_self_test (const gchar *device, BDNVMESelfTestAction act
 /* returns 0xff in case of error (the NVMe standard defines total of 16 flba records) */
 static __u8 find_lbaf_for_size (int fd, __u32 nsid, guint16 lba_data_size, guint16 metadata_size, GError **error) {
     int ret;
-    struct nvme_id_ns ns_info = ZERO_INIT;
+    struct nvme_id_ns *ns_info;
     __u8 flbas = 0;
     guint i;
 
     /* TODO: find first attached namespace instead of hardcoding NSID = 1 */
-    ret = nvme_identify_ns (fd, nsid == 0xffffffff ? 1 : nsid, &ns_info);
+    ns_info = _nvme_alloc (sizeof (struct nvme_id_ns));
+    g_warn_if_fail (ns_info != NULL);
+    ret = nvme_identify_ns (fd, nsid == 0xffffffff ? 1 : nsid, ns_info);
     if (ret != 0) {
         _nvme_status_to_error (ret, FALSE, error);
         g_prefix_error (error, "NVMe Identify Namespace command error: ");
+        free (ns_info);
         return 0xff;
     }
 
     /* return currently used lbaf */
     if (lba_data_size == 0) {
-       nvme_id_ns_flbas_to_lbaf_inuse (ns_info.flbas, &flbas);
-       return flbas;
+        nvme_id_ns_flbas_to_lbaf_inuse (ns_info->flbas, &flbas);
+        free (ns_info);
+        return flbas;
     }
 
-    for (i = 0; i <= ns_info.nlbaf + ns_info.nulbaf; i++)
-        if (1UL << ns_info.lbaf[i].ds == lba_data_size && GUINT16_FROM_LE (ns_info.lbaf[i].ms) == metadata_size)
+    for (i = 0; i <= ns_info->nlbaf + ns_info->nulbaf; i++)
+        if (1UL << ns_info->lbaf[i].ds == lba_data_size && GUINT16_FROM_LE (ns_info->lbaf[i].ms) == metadata_size) {
+            free (ns_info);
             return i;
+        }
 
     g_set_error_literal (error, BD_NVME_ERROR, BD_NVME_ERROR_INVALID_ARGUMENT,
                          "Couldn't match desired LBA data block size in a device supported LBA format data sizes");
+    free (ns_info);
     return 0xff;
 }
 
@@ -176,7 +183,7 @@ static __u8 find_lbaf_for_size (int fd, __u32 nsid, guint16 lba_data_size, guint
 gboolean bd_nvme_format (const gchar *device, guint16 lba_data_size, guint16 metadata_size, BDNVMEFormatSecureErase secure_erase, GError **error) {
     int ret;
     gboolean ctrl_device = FALSE;
-    struct nvme_id_ctrl ctrl_id = ZERO_INIT;
+    struct nvme_id_ctrl *ctrl_id;
     struct nvme_format_nvm_args args = {
         .args_size = sizeof(args),
         .result = NULL,
@@ -207,11 +214,14 @@ gboolean bd_nvme_format (const gchar *device, guint16 lba_data_size, guint16 met
 
     /* check the FNA controller bit when formatting a single namespace */
     if (! ctrl_device) {
-        ret = nvme_identify_ctrl (args.fd, &ctrl_id);
+        ctrl_id = _nvme_alloc (sizeof (struct nvme_id_ctrl));
+        g_warn_if_fail (ctrl_id != NULL);
+        ret = nvme_identify_ctrl (args.fd, ctrl_id);
         if (ret != 0) {
             _nvme_status_to_error (ret, FALSE, error);
             g_prefix_error (error, "NVMe Identify Controller command error: ");
             close (args.fd);
+            free (ctrl_id);
             return FALSE;
         }
         /* from nvme-cli:
@@ -219,14 +229,16 @@ gboolean bd_nvme_format (const gchar *device, guint16 lba_data_size, guint16 met
          * attributes and a format (excluding secure erase) of any namespace results in a
          * format of all namespaces.
          */
-        if ((ctrl_id.fna & NVME_CTRL_FNA_FMT_ALL_NAMESPACES) == NVME_CTRL_FNA_FMT_ALL_NAMESPACES) {
+        if ((ctrl_id->fna & NVME_CTRL_FNA_FMT_ALL_NAMESPACES) == NVME_CTRL_FNA_FMT_ALL_NAMESPACES) {
             /* tell user that it would format other namespaces and that bd_nvme_format()
              * should be called on a controller device instead */
             g_set_error_literal (error, BD_NVME_ERROR, BD_NVME_ERROR_WOULD_FORMAT_ALL_NS,
                          "The NVMe controller indicates it would format all namespaces.");
             close (args.fd);
+            free (ctrl_id);
             return FALSE;
         }
+        free (ctrl_id);
     }
 
     /* find out the desired LBA data format index */
diff --git a/src/plugins/nvme/nvme-private.h b/src/plugins/nvme/nvme-private.h
index 8b6d13253..0d15fbb64 100644
--- a/src/plugins/nvme/nvme-private.h
+++ b/src/plugins/nvme/nvme-private.h
@@ -24,5 +24,7 @@ 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);
+G_GNUC_INTERNAL
+void *_nvme_alloc (size_t len);
 
 #endif  /* BD_NVME_PRIVATE */