diff --git a/.libblockdev.metadata b/.libblockdev.metadata new file mode 100644 index 0000000..9edeb51 --- /dev/null +++ b/.libblockdev.metadata @@ -0,0 +1 @@ +d32fce132c75d94ad9c033a636906d63027ffba5 libblockdev-2.28.tar.gz diff --git a/0011-nvme_libblockdev-3.0.4_backport.patch b/0011-nvme_libblockdev-3.0.4_backport.patch new file mode 100644 index 0000000..fae7aae --- /dev/null +++ b/0011-nvme_libblockdev-3.0.4_backport.patch @@ -0,0 +1,1395 @@ +From 2c4324b658931882bfb664e05673cd5c9082429d Mon Sep 17 00:00:00 2001 +From: Tomas Bzatek +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 +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 +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 +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 +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 +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 +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 +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 +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 +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 +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 */ diff --git a/libblockdev.spec b/libblockdev.spec index f13bd02..aed59c6 100644 --- a/libblockdev.spec +++ b/libblockdev.spec @@ -129,7 +129,7 @@ Name: libblockdev Version: 2.28 -Release: 8%{?dist} +Release: 9%{?dist} Summary: A library for low-level manipulation with block devices License: LGPLv2+ URL: https://github.com/storaged-project/libblockdev @@ -145,6 +145,7 @@ Patch7: 0007-tests-Fix-test_swapon_pagesize-on-systems-with-64k-p.patch Patch8: 0008-part-Fix-segfault-when-adding-a-partition-too-big-fo.patch Patch9: 0009-Fix-issues-in-tests-when-running-in-FIPS-mode.patch Patch10: 0010-lvm-Add-a-function-to-activate-LVs-in-shared-mode.patch +Patch11: 0011-nvme_libblockdev-3.0.4_backport.patch BuildRequires: make BuildRequires: glib2-devel @@ -736,6 +737,7 @@ A meta-package that pulls all the libblockdev plugins as dependencies. %patch8 -p1 %patch9 -p1 %patch10 -p1 +%patch11 -p1 %build autoreconf -ivf @@ -1054,6 +1056,13 @@ find %{buildroot} -type f -name "*.la" | xargs %{__rm} %files plugins-all %changelog +* Wed Nov 01 2023 Tomas Bzatek - 2.28-9 +- nvme: HostID fixes for TP4126 + Resolves: RHEL-1375 +- nvme: Stack smashing fixes + Resolves: RHEL-13127 + Resolves: RHEL-8037 + * Tue Oct 17 2023 Vojtech Trefny - 2.28-8 - lvm: Add a function to activate LVs in shared mode Resolves: RHEL-14018