diff --git a/nvme-cli-2.5-nbft-make-lookup_ctrl-function-public.patch b/nvme-cli-2.5-nbft-make-lookup_ctrl-function-public.patch
new file mode 100644
index 0000000..78529b9
--- /dev/null
+++ b/nvme-cli-2.5-nbft-make-lookup_ctrl-function-public.patch
@@ -0,0 +1,75 @@
+From 34c197e0ac2d57734ab775f00b2d0758aca7b82f Mon Sep 17 00:00:00 2001
+From: John Meneghini <jmeneghi@redhat.com>
+Date: Fri, 14 Apr 2023 10:53:58 -0400
+Subject: [PATCH 01/11] nbft: make lookup_ctrl function public
+
+To prepare for the addition of nbft functionality fixup the fabrics
+declarations.
+
+Signed-off-by: John Meneghini <jmeneghi@redhat.com>
+---
+ fabrics.c | 12 ++----------
+ fabrics.h | 10 ++++++++++
+ 2 files changed, 12 insertions(+), 10 deletions(-)
+
+diff --git a/fabrics.c b/fabrics.c
+index f8078e59..80827b16 100644
+--- a/fabrics.c
++++ b/fabrics.c
+@@ -43,6 +43,7 @@
+ #include "libnvme.h"
+ #include "nvme-print.h"
+ #include "nvme-print-json.h"
++#include "fabrics.h"
+
+ #define PATH_NVMF_DISC SYSCONFDIR "/nvme/discovery.conf"
+ #define PATH_NVMF_CONFIG SYSCONFDIR "/nvme/config.json"
+@@ -110,15 +111,6 @@ static const char *nvmf_config_file = "Use specified JSON configuration file or
+ OPT_FLAG("data-digest", 'G', &c.data_digest, nvmf_data_digest), \
+ OPT_FLAG("tls", 0, &c.tls, nvmf_tls) \
+
+-struct tr_config {
+- const char *subsysnqn;
+- const char *transport;
+- const char *traddr;
+- const char *host_traddr;
+- const char *host_iface;
+- const char *trsvcid;
+-};
+-
+ /*
+ * Compare two C strings and handle NULL pointers gracefully.
+ * If either of the two strings is NULL, return 0
+@@ -202,7 +194,7 @@ static nvme_ctrl_t lookup_discovery_ctrl(nvme_root_t r, struct tr_config *trcfg)
+ return __lookup_ctrl(r, trcfg, disc_ctrl_config_match);
+ }
+
+-static nvme_ctrl_t lookup_ctrl(nvme_root_t r, struct tr_config *trcfg)
++nvme_ctrl_t lookup_ctrl(nvme_root_t r, struct tr_config *trcfg)
+ {
+ return __lookup_ctrl(r, trcfg, ctrl_config_match);
+ }
+diff --git a/fabrics.h b/fabrics.h
+index d1e16fc5..02cebf5d 100644
+--- a/fabrics.h
++++ b/fabrics.h
+@@ -2,6 +2,16 @@
+ #ifndef _FABRICS_H
+ #define _FABRICS_H
+
++struct tr_config {
++ const char *subsysnqn;
++ const char *transport;
++ const char *traddr;
++ const char *host_traddr;
++ const char *host_iface;
++ const char *trsvcid;
++};
++
++extern nvme_ctrl_t lookup_ctrl(nvme_root_t r, struct tr_config *trcfg);
+ extern int nvmf_discover(const char *desc, int argc, char **argv, bool connect);
+ extern int nvmf_connect(const char *desc, int argc, char **argv);
+ extern int nvmf_disconnect(const char *desc, int argc, char **argv);
+--
+2.39.2
+
diff --git a/nvme-cli-2.5-nbft.patch b/nvme-cli-2.5-nbft.patch
new file mode 100644
index 0000000..e54da19
--- /dev/null
+++ b/nvme-cli-2.5-nbft.patch
@@ -0,0 +1,451 @@
+From a71a08532b5f06ee19ee2ff118a23cec4ecb6719 Mon Sep 17 00:00:00 2001
+From: Stuart Hayes <stuart_hayes@dell.com>
+Date: Wed, 15 Jun 2022 11:42:50 -0500
+Subject: [PATCH 02/11] nbft: added NBFT v1.0 table support
+
+Added support for parsing the contents of the NBFT table (per NVMe-oF
+boot specification v1.0) with the connect-all and discover commands.
+
+nvme discover/connect-all --nbft ignore /etc/nvme config and use NBFT tables
+nvme discover/connect-all --no-nbft ignore NBFT tables and use /etc/nvme config
+nvme discover/connect-all --nbft-path=<STR> user-defined path for NBFT tables
+
+Signed-off-by: Stuart Hayes <stuart_hayes@dell.com>
+Signed-off-by: Martin Belanger <martin.belanger@dell.com>
+
+Use the new nbft public API.
+
+Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>
+Signed-off-by: Martin Wilck <mwilck@suse.com>
+Signed-off-by: John Meneghini <jmeneghi@redhat.com>
+---
+ Documentation/nvme-connect-all.txt | 25 ++++
+ Documentation/nvme-discover.txt | 27 +++-
+ fabrics.c | 17 +++
+ meson.build | 1 +
+ nbft.c | 202 +++++++++++++++++++++++++++++
+ nbft.h | 19 +++
+ 6 files changed, 290 insertions(+), 1 deletion(-)
+ create mode 100644 nbft.c
+ create mode 100644 nbft.h
+
+diff --git a/Documentation/nvme-connect-all.txt b/Documentation/nvme-connect-all.txt
+index 44bb4f94..cbb7ca6c 100644
+--- a/Documentation/nvme-connect-all.txt
++++ b/Documentation/nvme-connect-all.txt
+@@ -35,6 +35,9 @@ SYNOPSIS
+ [--tls ]
+ [--quiet | -S]
+ [--dump-config | -O]
++ [--nbft]
++ [--no-nbft]
++ [--nbft-path=<STR>]
+
+ DESCRIPTION
+ -----------
+@@ -198,6 +201,16 @@ OPTIONS
+ --dump-config::
+ Print out resulting JSON configuration file to stdout.
+
++--nbft::
++ Only look at NBFT tables
++
++--no-nbft::
++ Do not look at NBFT tables
++
++--nbft-path=<STR>::
++ Use a user-defined path to the NBFT tables
++
++
+
+ EXAMPLES
+ --------
+@@ -210,6 +223,18 @@ the RDMA network. Port 4420 is used by default:
+ --hostnqn=host1-rogue-nqn
+ ------------
+ +
++* Issue a 'nvme connect-all' command using the default system defined NBFT tables:
+++
++-----------
++# nvme connect-all --nbft
++------------
+++
++* Issue a 'nvme connect-all' command with a user-defined path for the NBFT table:
+++
++-----------
++# nvme connet-all --nbft-path=/sys/firmware/acpi/tables/NBFT1
++------------
+++
+ * Issue a 'nvme connect-all' command using a @SYSCONFDIR@/nvme/discovery.conf file:
+ +
+ -----------
+diff --git a/Documentation/nvme-discover.txt b/Documentation/nvme-discover.txt
+index d4df75c2..b040c688 100644
+--- a/Documentation/nvme-discover.txt
++++ b/Documentation/nvme-discover.txt
+@@ -37,6 +37,9 @@ SYNOPSIS
+ [--dump-config | -O]
+ [--output-format=<fmt> | -o <fmt>]
+ [--force]
++ [--nbft]
++ [--no-nbft]
++ [--nbft-path=<STR>]
+
+ DESCRIPTION
+ -----------
+@@ -68,7 +71,7 @@ Note that the base NVMe specification defines the NQN (NVMe Qualified
+ Name) format which an NVMe endpoint (device, subsystem, etc) must
+ follow to guarantee a unique name under the NVMe standard.
+ In particular, the Host NQN uniquely identifies the NVMe Host, and
+-may be used by the the Discovery Controller to control what NVMe Target
++may be used by the Discovery Controller to control what NVMe Target
+ resources are allocated to the NVMe Host for a connection.
+
+ A Discovery Controller has it's own NQN defined in the NVMe-over-Fabrics
+@@ -229,6 +232,16 @@ OPTIONS
+ Combined with --persistent flag, always create new
+ persistent discovery connection.
+
++--nbft::
++ Only look at NBFT tables
++
++--no-nbft::
++ Do not look at NBFT tables
++
++--nbft-path=<STR>::
++ Use a user-defined path to the NBFT tables
++
++
+ EXAMPLES
+ --------
+ * Query the Discover Controller with IP4 address 192.168.1.3 for all
+@@ -240,6 +253,18 @@ Port 4420 is used by default:
+ --hostnqn=host1-rogue-nqn
+ ------------
+ +
++* Issue a 'nvme discover' command using the default system defined NBFT tables:
+++
++-----------
++# nvme discover --nbft
++------------
+++
++* Issue a 'nvme discover' command with a user-defined path for the NBFT table:
+++
++-----------
++# nvme discover --nbft-path=/sys/firmware/acpi/tables/NBFT1
++------------
+++
+ * Issue a 'nvme discover' command using a @SYSCONFDIR@/nvme/discovery.conf file:
+ +
+ -----------
+diff --git a/fabrics.c b/fabrics.c
+index 80827b16..0edbd299 100644
+--- a/fabrics.c
++++ b/fabrics.c
+@@ -40,6 +40,7 @@
+
+ #include "common.h"
+ #include "nvme.h"
++#include "nbft.h"
+ #include "libnvme.h"
+ #include "nvme-print.h"
+ #include "nvme-print-json.h"
+@@ -710,6 +711,7 @@ int nvmf_discover(const char *desc, int argc, char **argv, bool connect)
+ {
+ char *subsysnqn = NVME_DISC_SUBSYS_NAME;
+ char *hostnqn = NULL, *hostid = NULL, *hostkey = NULL;
++ char *hostnqn_arg, *hostid_arg;
+ char *transport = NULL, *traddr = NULL, *trsvcid = NULL;
+ char *config_file = PATH_NVMF_CONFIG;
+ char *hnqn = NULL, *hid = NULL;
+@@ -724,6 +726,8 @@ int nvmf_discover(const char *desc, int argc, char **argv, bool connect)
+ char *device = NULL;
+ bool force = false;
+ bool json_config = false;
++ bool nbft = false, nonbft = false;
++ char *nbft_path = NBFT_SYSFS_PATH;
+
+ OPT_ARGS(opts) = {
+ OPT_STRING("device", 'd', "DEV", &device, "use existing discovery controller device"),
+@@ -736,6 +740,9 @@ int nvmf_discover(const char *desc, int argc, char **argv, bool connect)
+ OPT_INCR("verbose", 'v', &verbose, "Increase logging verbosity"),
+ OPT_FLAG("dump-config", 'O', &dump_config, "Dump configuration file to stdout"),
+ OPT_FLAG("force", 0, &force, "Force persistent discovery controller creation"),
++ OPT_FLAG("nbft", 0, &nbft, "Only look at NBFT tables"),
++ OPT_FLAG("no-nbft", 0, &nonbft, "Do not look at NBFT tables"),
++ OPT_STRING("nbft-path", 0, "STR", &nbft_path, "user-defined path for NBFT tables"),
+ OPT_END()
+ };
+
+@@ -768,6 +775,8 @@ int nvmf_discover(const char *desc, int argc, char **argv, bool connect)
+ if (!nvme_read_config(r, config_file))
+ json_config = true;
+
++ hostnqn_arg = hostnqn;
++ hostid_arg = hostid;
+ if (!hostnqn)
+ hostnqn = hnqn = nvmf_hostnqn_from_file();
+ if (!hostnqn)
+@@ -789,6 +798,14 @@ int nvmf_discover(const char *desc, int argc, char **argv, bool connect)
+ nvme_host_set_dhchap_key(h, hostkey);
+
+ if (!device && !transport && !traddr) {
++ if (!nonbft)
++ discover_from_nbft(r, hostnqn_arg, hostid_arg,
++ hostnqn, hostid, desc, connect,
++ &cfg, nbft_path, flags, verbose);
++
++ if (nbft)
++ goto out_free;
++
+ if (json_config)
+ ret = discover_from_json_config_file(r, h, desc,
+ connect, &cfg,
+diff --git a/meson.build b/meson.build
+index 43ce5f9b..7ec357a9 100644
+--- a/meson.build
++++ b/meson.build
+@@ -240,6 +240,7 @@ incdir = include_directories(['ccan'])
+
+ ################################################################################
+ sources = [
++ 'nbft.c',
+ 'fabrics.c',
+ 'nvme.c',
+ 'nvme-models.c',
+diff --git a/nbft.c b/nbft.c
+new file mode 100644
+index 00000000..14347287
+--- /dev/null
++++ b/nbft.c
+@@ -0,0 +1,202 @@
++// SPDX-License-Identifier: GPL-2.0-or-later
++
++#include <errno.h>
++#include <stdio.h>
++#include <fnmatch.h>
++
++#include "nvme.h"
++#include "nbft.h"
++#include "libnvme.h"
++#include "fabrics.h"
++
++#define NBFT_SYSFS_FILENAME "NBFT*"
++
++static void print_connect_msg(nvme_ctrl_t c)
++{
++ printf("device: %s\n", nvme_ctrl_get_name(c));
++}
++
++static void json_connect_msg(nvme_ctrl_t c)
++{
++ struct json_object *root;
++
++ root = json_create_object();
++ json_object_add_value_string(root, "device", nvme_ctrl_get_name(c));
++
++ json_print_object(root, NULL);
++ printf("\n");
++ json_free_object(root);
++}
++
++int nbft_filter(const struct dirent *dent)
++{
++ return !fnmatch(NBFT_SYSFS_FILENAME, dent->d_name, FNM_PATHNAME);
++}
++
++int read_nbft_files(struct list_head *nbft_list, char *path)
++{
++ struct dirent **dent;
++ char filename[PATH_MAX];
++ int i, count, ret;
++ struct nbft_file_entry *entry;
++ struct nbft_info *nbft;
++
++ count = scandir(path, &dent, nbft_filter, NULL);
++ if (count < 0) {
++ fprintf(stderr, "Failed to open %s.\n", path);
++ return -1;
++ }
++
++ for (i = 0; i < count; i++) {
++ snprintf(filename, sizeof(filename), "%s/%s", path, dent[i]->d_name);
++ ret = nvme_nbft_read(&nbft, filename);
++ if (!ret) {
++ entry = calloc(1, sizeof(*entry));
++ entry->nbft = nbft;
++ list_add_tail(nbft_list, &entry->node);
++ }
++ free(dent[i]);
++ }
++ free(dent);
++ return 0;
++}
++
++void free_nbfts(struct list_head *nbft_list)
++{
++ struct nbft_file_entry *entry;
++
++ while ((entry = list_pop(nbft_list, struct nbft_file_entry, node))) {
++ nvme_nbft_free(entry->nbft);
++ free(entry);
++ }
++}
++
++int discover_from_nbft(nvme_root_t r, char *hostnqn_arg, char *hostid_arg,
++ char *hostnqn_sys, char *hostid_sys,
++ const char *desc, bool connect,
++ const struct nvme_fabrics_config *cfg, char *nbft_path,
++ enum nvme_print_flags flags, bool verbose)
++{
++ char *hostnqn = NULL, *hostid = NULL, *host_traddr = NULL;
++ nvme_host_t h;
++ nvme_ctrl_t c;
++ int ret, i;
++ struct list_head nbft_list;
++ struct nbft_file_entry *entry;
++ struct nbft_info_subsystem_ns **ss;
++ struct nbft_info_hfi *hfi;
++
++ if (!connect)
++ /* to do: print discovery-type info from NBFT tables */
++ return 0;
++
++ list_head_init(&nbft_list);
++ ret = read_nbft_files(&nbft_list, nbft_path);
++ if (ret)
++ goto out_free_2;
++
++ list_for_each(&nbft_list, entry, node)
++ for (ss = entry->nbft->subsystem_ns_list; ss && *ss; ss++)
++ for (i = 0; i < (*ss)->num_hfis; i++) {
++ nvme_ctrl_t cl;
++
++ hfi = (*ss)->hfis[i];
++ if (hostnqn_arg)
++ hostnqn = hostnqn_arg;
++ else {
++ hostnqn = entry->nbft->host.nqn;
++ if (!hostnqn)
++ hostnqn = hostnqn_sys;
++ }
++
++ if (hostid_arg)
++ hostid = hostid_arg;
++ else if (*entry->nbft->host.id) {
++ hostid = (char *)util_uuid_to_string(entry->nbft->host.id);
++ if (!hostid)
++ hostid = hostid_sys;
++ }
++
++ h = nvme_lookup_host(r, hostnqn, hostid);
++ if (!h) {
++ errno = ENOMEM;
++ goto out_free;
++ }
++
++ if (!cfg->host_traddr) {
++ host_traddr = NULL;
++ if (!strncmp((*ss)->transport, "tcp", 3))
++ host_traddr = hfi->tcp_info.ipaddr;
++ }
++
++ struct tr_config trcfg = {
++ .subsysnqn = (*ss)->subsys_nqn,
++ .transport = (*ss)->transport,
++ .traddr = (*ss)->traddr,
++ .host_traddr = host_traddr,
++ .host_iface = NULL,
++ .trsvcid = (*ss)->trsvcid,
++ };
++
++ /* Already connected ? */
++ cl = lookup_ctrl(r, &trcfg);
++ if (cl && nvme_ctrl_get_name(cl))
++ continue;
++
++ c = nvme_create_ctrl(r, (*ss)->subsys_nqn, (*ss)->transport,
++ (*ss)->traddr, host_traddr, NULL,
++ (*ss)->trsvcid);
++ if (!c) {
++ errno = ENOMEM;
++ goto out_free;
++ }
++
++ errno = 0;
++ ret = nvmf_add_ctrl(h, c, cfg);
++
++ /*
++ * With TCP/DHCP, it can happen that the OS
++ * obtains a different local IP address than the
++ * firmware had. Retry without host_traddr.
++ */
++ if (ret == -1 && errno == ENVME_CONNECT_WRITE &&
++ !strcmp((*ss)->transport, "tcp") &&
++ strlen(hfi->tcp_info.dhcp_server_ipaddr) > 0) {
++ nvme_free_ctrl(c);
++
++ trcfg.host_traddr = NULL;
++ cl = lookup_ctrl(r, &trcfg);
++ if (cl && nvme_ctrl_get_name(cl))
++ continue;
++
++ c = nvme_create_ctrl(r, (*ss)->subsys_nqn, (*ss)->transport,
++ (*ss)->traddr,
++ NULL, NULL, (*ss)->trsvcid);
++ if (!c) {
++ errno = ENOMEM;
++ goto out_free;
++ }
++ errno = 0;
++ ret = nvmf_add_ctrl(h, c, cfg);
++ if (ret == 0 && verbose >= 1)
++ fprintf(stderr,
++ "connect with host_traddr=\"%s\" failed, success after omitting host_traddr\n",
++ host_traddr);
++ }
++
++ if (ret)
++ fprintf(stderr, "no controller found\n");
++ else {
++ if (flags == NORMAL)
++ print_connect_msg(c);
++ else if (flags == JSON)
++ json_connect_msg(c);
++ }
++out_free:
++ if (errno == ENOMEM)
++ goto out_free_2;
++ }
++out_free_2:
++ free_nbfts(&nbft_list);
++ return errno;
++}
+diff --git a/nbft.h b/nbft.h
+new file mode 100644
+index 00000000..0e09733f
+--- /dev/null
++++ b/nbft.h
+@@ -0,0 +1,19 @@
++/* SPDX-License-Identifier: GPL-2.0-or-later */
++
++#include <ccan/list/list.h>
++
++#define NBFT_SYSFS_PATH "/sys/firmware/acpi/tables"
++
++struct nbft_file_entry {
++ struct list_node node;
++ struct nbft_info *nbft;
++};
++
++int read_nbft_files(struct list_head *nbft_list, char *path);
++void free_nbfts(struct list_head *nbft_list);
++
++extern int discover_from_nbft(nvme_root_t r, char *hostnqn_arg, char *hostid_arg,
++ char *hostnqn_sys, char *hostid_sys,
++ const char *desc, bool connect,
++ const struct nvme_fabrics_config *cfg, char *nbft_path,
++ enum nvme_print_flags flags, bool verbose);
+--
+2.39.2
+
diff --git a/nvme-cli-2.5-nbft_plugin.patch b/nvme-cli-2.5-nbft_plugin.patch
new file mode 100644
index 0000000..b70d26e
--- /dev/null
+++ b/nvme-cli-2.5-nbft_plugin.patch
@@ -0,0 +1,640 @@
+From 23daeedc53be9b5225cc6806434888c0a7a8e9bf Mon Sep 17 00:00:00 2001
+From: Stuart Hayes <stuart_hayes@dell.com>
+Date: Fri, 14 Apr 2023 22:01:07 -0400
+Subject: [PATCH 03/11] nbft: add the nbft show plugin
+
+Display contents of the ACPI NBFT files.
+
+Usage: nvme nbft show <device> [OPTIONS]
+
+Options:
+ [ --output-format=<FMT>, -o <FMT> ] --- Output format: normal|json
+ [ --subsystem, -s ] --- show NBFT subsystems
+ [ --hfi, -H ] --- show NBFT HFIs
+ [ --discovery, -d ] --- show NBFT discovery controllers
+ [ --nbft-path=<STR> ] --- user-defined path for NBFT tables
+
+Signed-off-by: Stuart Hayes <stuart_hayes@dell.com>
+Signed-off-by: Martin Wilck <mwilck@suse.com>
+Signed-off-by: John Meneghini <jmeneghi@redhat.com>
+---
+ plugins/meson.build | 1 +
+ plugins/nbft/nbft-plugin.c | 568 +++++++++++++++++++++++++++++++++++++
+ plugins/nbft/nbft-plugin.h | 18 ++
+ 3 files changed, 587 insertions(+)
+ create mode 100644 plugins/nbft/nbft-plugin.c
+ create mode 100644 plugins/nbft/nbft-plugin.h
+
+diff --git a/plugins/meson.build b/plugins/meson.build
+index 2cf2486f..38b7cded 100644
+--- a/plugins/meson.build
++++ b/plugins/meson.build
+@@ -12,6 +12,7 @@ if json_c_dep.found()
+ 'plugins/intel/intel-nvme.c',
+ 'plugins/memblaze/memblaze-nvme.c',
+ 'plugins/micron/micron-nvme.c',
++ 'plugins/nbft/nbft-plugin.c',
+ 'plugins/netapp/netapp-nvme.c',
+ 'plugins/nvidia/nvidia-nvme.c',
+ 'plugins/scaleflux/sfx-nvme.c',
+diff --git a/plugins/nbft/nbft-plugin.c b/plugins/nbft/nbft-plugin.c
+new file mode 100644
+index 00000000..6ae2525a
+--- /dev/null
++++ b/plugins/nbft/nbft-plugin.c
+@@ -0,0 +1,568 @@
++// SPDX-License-Identifier: GPL-2.0-or-later
++
++#include <errno.h>
++#include <stdio.h>
++#include <fnmatch.h>
++
++#include "nvme-print.h"
++#include "nvme.h"
++#include "nbft.h"
++#include "libnvme.h"
++#include "fabrics.h"
++
++#define CREATE_CMD
++#include "nbft-plugin.h"
++
++static const char dash[100] = {[0 ... 98] = '-', [99] = '\0'};
++
++#define PCI_SEGMENT(sbdf) ((sbdf & 0xffff0000) >> 16)
++#define PCI_BUS(sbdf) ((sbdf & 0x0000ff00) >> 8)
++#define PCI_DEV(sbdf) ((sbdf & 0x000000f8) >> 3)
++#define PCI_FUNC(sbdf) ((sbdf & 0x00000007) >> 0)
++
++static const char *pci_sbdf_to_string(__u16 pci_sbdf)
++{
++ static char pcidev[13];
++
++ snprintf(pcidev, sizeof(pcidev), "%x:%x:%x.%x",
++ PCI_SEGMENT(pci_sbdf),
++ PCI_BUS(pci_sbdf),
++ PCI_DEV(pci_sbdf),
++ PCI_FUNC(pci_sbdf));
++ return pcidev;
++}
++
++static char *mac_addr_to_string(unsigned char mac_addr[6])
++{
++ static char mac_string[18];
++
++ snprintf(mac_string, sizeof(mac_string), "%02x:%02x:%02x:%02x:%02x:%02x",
++ mac_addr[0],
++ mac_addr[1],
++ mac_addr[2],
++ mac_addr[3],
++ mac_addr[4],
++ mac_addr[5]);
++ return mac_string;
++}
++
++static json_object *hfi_to_json(struct nbft_info_hfi *hfi)
++{
++ struct json_object *hfi_json;
++
++ hfi_json = json_create_object();
++ if (!hfi_json)
++ return NULL;
++
++ if (json_object_add_value_int(hfi_json, "index", hfi->index)
++ || json_object_add_value_string(hfi_json, "transport", hfi->transport))
++ goto fail;
++
++ if (strcmp(hfi->transport, "tcp") == 0) {
++ if (json_object_add_value_string(hfi_json, "pcidev",
++ pci_sbdf_to_string(hfi->tcp_info.pci_sbdf))
++ || json_object_add_value_string(hfi_json, "mac_addr",
++ mac_addr_to_string(hfi->tcp_info.mac_addr))
++ || json_object_add_value_int(hfi_json, "vlan",
++ hfi->tcp_info.vlan)
++ || json_object_add_value_int(hfi_json, "ip_origin",
++ hfi->tcp_info.ip_origin)
++ || json_object_add_value_string(hfi_json, "ipaddr",
++ hfi->tcp_info.ipaddr)
++ || json_object_add_value_int(hfi_json, "subnet_mask_prefix",
++ hfi->tcp_info.subnet_mask_prefix)
++ || json_object_add_value_string(hfi_json, "gateway_ipaddr",
++ hfi->tcp_info.gateway_ipaddr)
++ || json_object_add_value_int(hfi_json, "route_metric",
++ hfi->tcp_info.route_metric)
++ || json_object_add_value_string(hfi_json, "primary_dns_ipaddr",
++ hfi->tcp_info.primary_dns_ipaddr)
++ || json_object_add_value_string(hfi_json, "secondary_dns_ipaddr",
++ hfi->tcp_info.secondary_dns_ipaddr)
++ || json_object_add_value_string(hfi_json, "dhcp_server_ipaddr",
++ hfi->tcp_info.dhcp_server_ipaddr)
++ || (hfi->tcp_info.host_name
++ && json_object_add_value_string(hfi_json, "host_name",
++ hfi->tcp_info.host_name))
++ || json_object_add_value_int(hfi_json, "this_hfi_is_default_route",
++ hfi->tcp_info.this_hfi_is_default_route)
++ || json_object_add_value_int(hfi_json, "dhcp_override",
++ hfi->tcp_info.dhcp_override))
++ goto fail;
++ else
++ return hfi_json;
++ }
++fail:
++ json_free_object(hfi_json);
++ return NULL;
++}
++
++static json_object *ssns_to_json(struct nbft_info_subsystem_ns *ss)
++{
++ struct json_object *ss_json;
++ struct json_object *hfi_array_json;
++ char json_str[40];
++ char *json_str_p;
++ int i;
++
++ ss_json = json_create_object();
++ if (!ss_json)
++ return NULL;
++
++ hfi_array_json = json_create_array();
++ if (!hfi_array_json)
++ goto fail;
++
++ for (i = 0; i < ss->num_hfis; i++)
++ if (json_array_add_value_object(hfi_array_json,
++ json_object_new_int(ss->hfis[i]->index)))
++ goto fail;
++
++ if (json_object_add_value_int(ss_json, "index", ss->index)
++ || json_object_add_value_int(ss_json, "num_hfis", ss->num_hfis)
++ || json_object_object_add(ss_json, "hfis", hfi_array_json)
++ || json_object_add_value_string(ss_json, "transport", ss->transport)
++ || json_object_add_value_string(ss_json, "traddr", ss->traddr)
++ || json_object_add_value_string(ss_json, "trsvcid", ss->trsvcid)
++ || json_object_add_value_int(ss_json, "subsys_port_id", ss->subsys_port_id)
++ || json_object_add_value_int(ss_json, "nsid", ss->nsid))
++ goto fail;
++
++ memset(json_str, 0, sizeof(json_str));
++ json_str_p = json_str;
++
++ switch (ss->nid_type) {
++ case NBFT_INFO_NID_TYPE_EUI64:
++ if (json_object_add_value_string(ss_json, "nid_type", "eui64"))
++ goto fail;
++ for (i = 0; i < 8; i++)
++ json_str_p += sprintf(json_str_p, "%02x", ss->nid[i]);
++ break;
++
++ case NBFT_INFO_NID_TYPE_NGUID:
++ if (json_object_add_value_string(ss_json, "nid_type", "nguid"))
++ goto fail;
++ for (i = 0; i < 16; i++)
++ json_str_p += sprintf(json_str_p, "%02x", ss->nid[i]);
++ break;
++
++ case NBFT_INFO_NID_TYPE_NS_UUID:
++ if (json_object_add_value_string(ss_json, "nid_type", "uuid"))
++ goto fail;
++ nvme_uuid_to_string(ss->nid, json_str);
++ break;
++
++ default:
++ break;
++ }
++ if (json_object_add_value_string(ss_json, "nid", json_str))
++ goto fail;
++
++ if ((ss->subsys_nqn
++ && json_object_add_value_string(ss_json, "subsys_nqn", ss->subsys_nqn))
++ || json_object_add_value_int(ss_json, "controller_id", ss->controller_id)
++ || json_object_add_value_int(ss_json, "asqsz", ss->asqsz)
++ || (ss->dhcp_root_path_string
++ && json_object_add_value_string(ss_json, "dhcp_root_path_string",
++ ss->dhcp_root_path_string))
++ || json_object_add_value_int(ss_json, "pdu_header_digest_required",
++ ss->pdu_header_digest_required)
++ || json_object_add_value_int(ss_json, "data_digest_required",
++ ss->data_digest_required))
++ goto fail;
++
++ return ss_json;
++fail:
++ json_free_object(ss_json);
++ return NULL;
++}
++
++static json_object *discovery_to_json(struct nbft_info_discovery *disc)
++{
++ struct json_object *disc_json;
++
++ disc_json = json_create_object();
++ if (!disc_json)
++ return NULL;
++
++ if (json_object_add_value_int(disc_json, "index", disc->index)
++ || (disc->security
++ && json_object_add_value_int(disc_json, "security", disc->security->index))
++ || (disc->hfi
++ && json_object_add_value_int(disc_json, "hfi", disc->hfi->index))
++ || (disc->uri
++ && json_object_add_value_string(disc_json, "uri", disc->uri))
++ || (disc->nqn
++ && json_object_add_value_string(disc_json, "nqn", disc->nqn))) {
++ json_free_object(disc_json);
++ return NULL;
++ } else
++ return disc_json;
++}
++
++static const char *primary_admin_host_flag_to_str(unsigned int primary)
++{
++ static const char * const str[] = {
++ [NBFT_INFO_PRIMARY_ADMIN_HOST_FLAG_NOT_INDICATED] = "not indicated",
++ [NBFT_INFO_PRIMARY_ADMIN_HOST_FLAG_UNSELECTED] = "unselected",
++ [NBFT_INFO_PRIMARY_ADMIN_HOST_FLAG_SELECTED] = "selected",
++ [NBFT_INFO_PRIMARY_ADMIN_HOST_FLAG_RESERVED] = "reserved",
++ };
++
++ if (primary > NBFT_INFO_PRIMARY_ADMIN_HOST_FLAG_RESERVED)
++ return "INVALID";
++ return str[primary];
++}
++
++static struct json_object *nbft_to_json(struct nbft_info *nbft, bool show_subsys,
++ bool show_hfi, bool show_discovery)
++{
++ struct json_object *nbft_json, *host_json;
++
++ nbft_json = json_create_object();
++ if (!nbft_json)
++ return NULL;
++
++ if (json_object_add_value_string(nbft_json, "filename", nbft->filename))
++ goto fail;
++
++ host_json = json_create_object();
++ if (!host_json)
++ goto fail;
++ if ((nbft->host.nqn
++ && json_object_add_value_string(host_json, "nqn", nbft->host.nqn))
++ || (nbft->host.id
++ && json_object_add_value_string(host_json, "id",
++ util_uuid_to_string(nbft->host.id))))
++ goto fail;
++ json_object_add_value_int(host_json, "host_id_configured",
++ nbft->host.host_id_configured);
++ json_object_add_value_int(host_json, "host_nqn_configured",
++ nbft->host.host_nqn_configured);
++ json_object_add_value_string(host_json, "primary_admin_host_flag",
++ primary_admin_host_flag_to_str(nbft->host.primary));
++ if (json_object_object_add(nbft_json, "host", host_json)) {
++ json_free_object(host_json);
++ goto fail;
++ }
++
++ if (show_subsys) {
++ struct json_object *subsys_array_json, *subsys_json;
++ struct nbft_info_subsystem_ns **ss;
++
++ subsys_array_json = json_create_array();
++ if (!subsys_array_json)
++ goto fail;
++ for (ss = nbft->subsystem_ns_list; ss && *ss; ss++) {
++ subsys_json = ssns_to_json(*ss);
++ if (!subsys_json)
++ goto fail;
++ if (json_object_array_add(subsys_array_json, subsys_json)) {
++ json_free_object(subsys_json);
++ goto fail;
++ }
++ }
++ if (json_object_object_add(nbft_json, "subsystem", subsys_array_json)) {
++ json_free_object(subsys_array_json);
++ goto fail;
++ }
++ }
++ if (show_hfi) {
++ struct json_object *hfi_array_json, *hfi_json;
++ struct nbft_info_hfi **hfi;
++
++ hfi_array_json = json_create_array();
++ if (!hfi_array_json)
++ goto fail;
++ for (hfi = nbft->hfi_list; hfi && *hfi; hfi++) {
++ hfi_json = hfi_to_json(*hfi);
++ if (!hfi_json)
++ goto fail;
++ if (json_object_array_add(hfi_array_json, hfi_json)) {
++ json_free_object(hfi_json);
++ goto fail;
++ }
++ }
++ if (json_object_object_add(nbft_json, "hfi", hfi_array_json)) {
++ json_free_object(hfi_array_json);
++ goto fail;
++ }
++ }
++ if (show_discovery) {
++ struct json_object *discovery_array_json, *discovery_json;
++ struct nbft_info_discovery **disc;
++
++ discovery_array_json = json_create_array();
++ if (!discovery_array_json)
++ goto fail;
++ for (disc = nbft->discovery_list; disc && *disc; disc++) {
++ discovery_json = discovery_to_json(*disc);
++ if (!discovery_json)
++ goto fail;
++ if (json_object_array_add(discovery_array_json, discovery_json)) {
++ json_free_object(discovery_json);
++ goto fail;
++ }
++ }
++ if (json_object_object_add(nbft_json, "discovery", discovery_array_json)) {
++ json_free_object(discovery_array_json);
++ goto fail;
++ }
++ }
++ return nbft_json;
++fail:
++ json_free_object(nbft_json);
++ return NULL;
++}
++
++static int json_show_nbfts(struct list_head *nbft_list, bool show_subsys,
++ bool show_hfi, bool show_discovery)
++{
++ struct json_object *nbft_json_array, *nbft_json;
++ struct nbft_file_entry *entry;
++
++ nbft_json_array = json_create_array();
++ if (!nbft_json_array)
++ return ENOMEM;
++
++ list_for_each(nbft_list, entry, node) {
++ nbft_json = nbft_to_json(entry->nbft, show_subsys, show_hfi, show_discovery);
++ if (!nbft_json)
++ goto fail;
++ if (json_object_array_add(nbft_json_array, nbft_json)) {
++ json_free_object(nbft_json);
++ goto fail;
++ }
++ }
++
++ json_print_object(nbft_json_array, NULL);
++ printf("\n");
++ json_free_object(nbft_json_array);
++ return 0;
++fail:
++ json_free_object(nbft_json_array);
++ return ENOMEM;
++}
++
++static void print_nbft_hfi_info(struct nbft_info *nbft)
++{
++ struct nbft_info_hfi **hfi;
++ unsigned int ip_width = 8, gw_width = 8, dns_width = 8;
++
++ hfi = nbft->hfi_list;
++ if (!hfi || !*hfi)
++ return;
++
++ for (; *hfi; hfi++) {
++ unsigned int len;
++
++ len = strlen((*hfi)->tcp_info.ipaddr);
++ if (len > ip_width)
++ ip_width = len;
++ len = strlen((*hfi)->tcp_info.gateway_ipaddr);
++ if (len > gw_width)
++ gw_width = len;
++ len = strlen((*hfi)->tcp_info.primary_dns_ipaddr);
++ if (len > dns_width)
++ dns_width = len;
++ }
++
++ printf("\nNBFT HFIs:\n\n");
++ printf("%-3.3s|%-4.4s|%-10.10s|%-17.17s|%-4.4s|%-*.*s|%-4.4s|%-*.*s|%-*.*s\n",
++ "Idx", "Trsp", "PCI Addr", "MAC Addr", "DHCP",
++ ip_width, ip_width, "IP Addr", "Mask",
++ gw_width, gw_width, "Gateway", dns_width, dns_width, "DNS");
++ printf("%-.3s+%-.4s+%-.10s+%-.17s+%-.4s+%-.*s+%-.4s+%-.*s+%-.*s\n",
++ dash, dash, dash, dash, dash, ip_width, dash, dash,
++ gw_width, dash, dns_width, dash);
++ for (hfi = nbft->hfi_list; *hfi; hfi++)
++ printf("%-3d|%-4.4s|%-10.10s|%-17.17s|%-4.4s|%-*.*s|%-4d|%-*.*s|%-*.*s\n",
++ (*hfi)->index,
++ (*hfi)->transport,
++ pci_sbdf_to_string((*hfi)->tcp_info.pci_sbdf),
++ mac_addr_to_string((*hfi)->tcp_info.mac_addr),
++ (*hfi)->tcp_info.dhcp_override ? "yes" : "no",
++ ip_width, ip_width, (*hfi)->tcp_info.ipaddr,
++ (*hfi)->tcp_info.subnet_mask_prefix,
++ gw_width, gw_width, (*hfi)->tcp_info.gateway_ipaddr,
++ dns_width, dns_width, (*hfi)->tcp_info.primary_dns_ipaddr);
++}
++
++static void print_nbft_discovery_info(struct nbft_info *nbft)
++{
++ struct nbft_info_discovery **disc;
++ unsigned int nqn_width = 20, uri_width = 12;
++
++ disc = nbft->discovery_list;
++ if (!disc || !*disc)
++ return;
++
++ for (; *disc; disc++) {
++ size_t len;
++
++ len = strlen((*disc)->uri);
++ if (len > uri_width)
++ uri_width = len;
++ len = strlen((*disc)->nqn);
++ if (len > nqn_width)
++ nqn_width = len;
++ }
++
++ printf("\nNBFT Discovery Controllers:\n\n");
++ printf("%-3.3s|%-*.*s|%-*.*s\n", "Idx", uri_width, uri_width, "URI",
++ nqn_width, nqn_width, "NQN");
++ printf("%-.3s+%-.*s+%-.*s\n", dash, uri_width, dash, nqn_width, dash);
++ for (disc = nbft->discovery_list; *disc; disc++)
++ printf("%-3d|%-*.*s|%-*.*s\n", (*disc)->index,
++ uri_width, uri_width, (*disc)->uri,
++ nqn_width, nqn_width, (*disc)->nqn);
++}
++
++#define HFIS_LEN 20
++static size_t print_hfis(const struct nbft_info_subsystem_ns *ss, char buf[HFIS_LEN])
++{
++ char hfi_buf[HFIS_LEN];
++ size_t len, ofs;
++ int i;
++
++ len = snprintf(hfi_buf, sizeof(hfi_buf), "%d", ss->hfis[0]->index);
++ for (i = 1; i < ss->num_hfis; i++) {
++ ofs = len;
++ len += snprintf(hfi_buf + ofs, sizeof(hfi_buf) - ofs, ",%d",
++ ss->hfis[i]->index);
++ /*
++ * If the list doesn't fit in HFIS_LEN characters,
++ * truncate and end with "..."
++ */
++ if (len >= sizeof(hfi_buf)) {
++ while (ofs < sizeof(hfi_buf) - 1)
++ hfi_buf[ofs++] = '.';
++ hfi_buf[ofs] = '\0';
++ len = sizeof(hfi_buf) - 1;
++ break;
++ }
++ }
++ if (buf)
++ memcpy(buf, hfi_buf, len + 1);
++ return len;
++}
++
++
++static void print_nbft_subsys_info(struct nbft_info *nbft)
++{
++ struct nbft_info_subsystem_ns **ss;
++ unsigned int nqn_width = 20, adr_width = 8, hfi_width = 4;
++
++ ss = nbft->subsystem_ns_list;
++ if (!ss || !*ss)
++ return;
++ for (; *ss; ss++) {
++ size_t len;
++
++ len = strlen((*ss)->subsys_nqn);
++ if (len > nqn_width)
++ nqn_width = len;
++ len = strlen((*ss)->traddr);
++ if (len > adr_width)
++ adr_width = len;
++ len = print_hfis(*ss, NULL);
++ if (len > hfi_width)
++ hfi_width = len;
++ }
++
++ printf("\nNBFT Subsystems:\n\n");
++ printf("%-3.3s|%-*.*s|%-4.4s|%-*.*s|%-5.5s|%-*.*s\n",
++ "Idx", nqn_width, nqn_width, "NQN",
++ "Trsp", adr_width, adr_width, "Address", "SvcId", hfi_width, hfi_width, "HFIs");
++ printf("%-.3s+%-.*s+%-.4s+%-.*s+%-.5s+%-.*s\n",
++ dash, nqn_width, dash, dash, adr_width, dash, dash, hfi_width, dash);
++ for (ss = nbft->subsystem_ns_list; *ss; ss++) {
++ char hfi_buf[HFIS_LEN];
++
++ print_hfis(*ss, hfi_buf);
++ printf("%-3d|%-*.*s|%-4.4s|%-*.*s|%-5.5s|%-*.*s\n",
++ (*ss)->index, nqn_width, nqn_width, (*ss)->subsys_nqn,
++ (*ss)->transport, adr_width, adr_width, (*ss)->traddr,
++ (*ss)->trsvcid, hfi_width, hfi_width, hfi_buf);
++ }
++}
++
++static void normal_show_nbft(struct nbft_info *nbft, bool show_subsys,
++ bool show_hfi, bool show_discovery)
++{
++ printf("%s:\n", nbft->filename);
++ if ((!nbft->hfi_list || !*nbft->hfi_list) &&
++ (!nbft->security_list || !*nbft->security_list) &&
++ (!nbft->discovery_list || !*nbft->discovery_list) &&
++ (!nbft->subsystem_ns_list || !*nbft->subsystem_ns_list))
++ printf("(empty)\n");
++ else {
++ if (show_subsys)
++ print_nbft_subsys_info(nbft);
++ if (show_hfi)
++ print_nbft_hfi_info(nbft);
++ if (show_discovery)
++ print_nbft_discovery_info(nbft);
++ }
++}
++
++static void normal_show_nbfts(struct list_head *nbft_list, bool show_subsys,
++ bool show_hfi, bool show_discovery)
++{
++ bool not_first = false;
++ struct nbft_file_entry *entry;
++
++ list_for_each(nbft_list, entry, node) {
++ if (not_first)
++ printf("\n");
++ normal_show_nbft(entry->nbft, show_subsys, show_hfi, show_discovery);
++ not_first = true;
++ }
++}
++
++int show_nbft(int argc, char **argv, struct command *cmd, struct plugin *plugin)
++{
++ const char *desc = "Display contents of the ACPI NBFT files.";
++ struct list_head nbft_list;
++ char *format = "normal";
++ char *nbft_path = NBFT_SYSFS_PATH;
++ enum nvme_print_flags flags = -1;
++ int ret;
++ bool show_subsys = false, show_hfi = false, show_discovery = false;
++
++ OPT_ARGS(opts) = {
++ OPT_FMT("output-format", 'o', &format, "Output format: normal|json"),
++ OPT_FLAG("subsystem", 's', &show_subsys, "show NBFT subsystems"),
++ OPT_FLAG("hfi", 'H', &show_hfi, "show NBFT HFIs"),
++ OPT_FLAG("discovery", 'd', &show_discovery, "show NBFT discovery controllers"),
++ OPT_STRING("nbft-path", 0, "STR", &nbft_path, "user-defined path for NBFT tables"),
++ OPT_END()
++ };
++
++ ret = argconfig_parse(argc, argv, desc, opts);
++ if (ret)
++ return ret;
++
++ if (!(show_subsys || show_hfi || show_discovery))
++ show_subsys = show_hfi = show_discovery = true;
++
++ if (!strcmp(format, ""))
++ flags = -1;
++ else if (!strcmp(format, "normal"))
++ flags = NORMAL;
++ else if (!strcmp(format, "json"))
++ flags = JSON;
++ else
++ return EINVAL;
++
++ list_head_init(&nbft_list);
++ ret = read_nbft_files(&nbft_list, nbft_path);
++ if (!ret) {
++ if (flags == NORMAL)
++ normal_show_nbfts(&nbft_list, show_subsys, show_hfi, show_discovery);
++ else if (flags == JSON)
++ ret = json_show_nbfts(&nbft_list, show_subsys, show_hfi, show_discovery);
++ free_nbfts(&nbft_list);
++ }
++ return ret;
++}
+diff --git a/plugins/nbft/nbft-plugin.h b/plugins/nbft/nbft-plugin.h
+new file mode 100644
+index 00000000..018349d9
+--- /dev/null
++++ b/plugins/nbft/nbft-plugin.h
+@@ -0,0 +1,18 @@
++/* SPDX-License-Identifier: GPL-2.0-or-later */
++#undef CMD_INC_FILE
++#define CMD_INC_FILE plugins/nbft/nbft-plugin
++
++#if !defined(NBFT) || defined(CMD_HEADER_MULTI_READ)
++#define NBFT
++
++#include "cmd.h"
++
++PLUGIN(NAME("nbft", "ACPI NBFT table extensions", NVME_VERSION),
++ COMMAND_LIST(
++ ENTRY("show", "Show contents of ACPI NBFT tables", show_nbft)
++ )
++);
++
++#endif
++
++#include "define_cmd.h"
+--
+2.39.2
+
diff --git a/nvme-cli.spec b/nvme-cli.spec
index fd84a01..06bb083 100644
--- a/nvme-cli.spec
+++ b/nvme-cli.spec
@@ -3,13 +3,17 @@
Name: nvme-cli
Version: 2.4
-Release: 1%{?dist}
+Release: 2%{?dist}
Summary: NVMe management command line interface
License: GPLv2
URL: https://github.com/linux-nvme/nvme-cli
Source0: %{url}/archive/v%{version_no_tilde}/%{name}-%{version_no_tilde}.tar.gz
+Patch100: nvme-cli-2.5-nbft-make-lookup_ctrl-function-public.patch
+Patch101: nvme-cli-2.5-nbft.patch
+Patch102: nvme-cli-2.5-nbft_plugin.patch
+
BuildRequires: meson >= 0.50.0
BuildRequires: gcc gcc-c++
BuildRequires: systemd-devel
@@ -17,7 +21,7 @@ BuildRequires: systemd-rpm-macros
BuildRequires: zlib-devel
BuildRequires: openssl-devel
-BuildRequires: libnvme-devel >= 1.4
+BuildRequires: libnvme-devel >= 1.4-2
BuildRequires: json-c-devel >= 0.13
%if (0%{?rhel} == 0)
@@ -83,6 +87,9 @@ rm -rf %{buildroot}%{_pkgdocdir}/nvme
%changelog
+* Thu Apr 20 2023 Tomas Bzatek <tbzatek@redhat.com> - 2.4-2
+- Backport the NBFT support from git master
+
* Mon Apr 03 2023 Tomas Bzatek <tbzatek@redhat.com> - 2.4-1
- Update to 2.4