From 28ad0e9f6ff0bdd56c6afae73072299c4cd71c3a Mon Sep 17 00:00:00 2001

From: Stuart Hayes <stuart_hayes@dell.com>

Date: Thu, 31 Mar 2022 13:47:11 -0500

Subject: [PATCH 01/18] nbft: add NBFT v1.0 table support

Added support for parsing and printing the contents

of the NBFT table (per NVMe-oF boot specification v1.0).

Signed-off-by: Stuart Hayes <stuart_hayes@dell.com>

Signed-off-by: Martin Belanger <martin.belanger@dell.com>

Signed-off-by: Martin Wilck <mwilck@suse.com>

Signed-off-by: Tomas Bzatek <tbzatek@redhat.com>

Signed-off-by: John Meneghini <jmeneghi@redhat.com>

---

 doc/meson.build |    3 +-

 src/libnvme.h   |    1 +

 src/libnvme.map |    2 +

 src/meson.build |    2 +

 src/nvme/nbft.c |  739 ++++++++++++++++++++++++++++

 src/nvme/nbft.h | 1238 +++++++++++++++++++++++++++++++++++++++++++++++

 6 files changed, 1984 insertions(+), 1 deletion(-)

 create mode 100644 src/nvme/nbft.c

 create mode 100644 src/nvme/nbft.h

diff --git a/doc/meson.build b/doc/meson.build

index edbc3be..480db17 100644

--- a/doc/meson.build

+++ b/doc/meson.build

@@ -9,14 +9,15 @@

 #

 api_files = [

+  'fabrics.h',

   'filters.h',

   'ioctl.h',

   'linux.h',

   'log.h',

   'mi.h',

+  'nbft.h',

   'tree.h',

   'types.h',

-  'fabrics.h',

   'util.h'

 ]

diff --git a/src/libnvme.h b/src/libnvme.h

index 6be9058..2c7fe3a 100644

--- a/src/libnvme.h

+++ b/src/libnvme.h

@@ -17,6 +17,7 @@ extern "C" {

 #include "nvme/types.h"

 #include "nvme/linux.h"

 #include "nvme/ioctl.h"

+#include "nvme/nbft.h"

 #include "nvme/fabrics.h"

 #include "nvme/filters.h"

 #include "nvme/tree.h"

diff --git a/src/libnvme.map b/src/libnvme.map

index a1294f4..6aa9fd0 100644

--- a/src/libnvme.map

+++ b/src/libnvme.map

@@ -7,6 +7,8 @@ LIBNVME_1_4 {

 		nvme_lookup_key;

 		nvme_set_keyring;

 		nvme_insert_tls_key;

+		nvme_nbft_read;

+		nvme_nbft_free;

 };

 LIBNVME_1_3 {

diff --git a/src/meson.build b/src/meson.build

index 3732f8c..e8b667c 100644

--- a/src/meson.build

+++ b/src/meson.build

@@ -7,6 +7,7 @@

 #

 sources = [

     'nvme/cleanup.c',

+    'nvme/nbft.c',

     'nvme/fabrics.c',

     'nvme/filters.c',

     'nvme/ioctl.c',

@@ -125,6 +126,7 @@ install_headers([

         'nvme/ioctl.h',

         'nvme/linux.h',

         'nvme/log.h',

+        'nvme/nbft.h',

         'nvme/tree.h',

         'nvme/types.h',

         'nvme/util.h',

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

new file mode 100644

index 0000000..f91d21b

--- /dev/null

+++ b/src/nvme/nbft.c

@@ -0,0 +1,739 @@

+// SPDX-License-Identifier: LGPL-2.1-or-later

+/*

+ * This file is part of libnvme.

+ * Copyright (c) 2021-2022, Dell Inc. or its subsidiaries.  All Rights Reserved.

+ *

+ * Authors: Stuart Hayes <Stuart_Hayes@Dell.com>

+ *

+ */

+

+#include <errno.h>

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <arpa/inet.h>

+#include <ccan/endian/endian.h>

+

+#include "private.h"

+#include "nbft.h"

+#include "log.h"

+

+

+#define MIN(a, b) (((a) < (b)) ? (a) : (b))

+

+static __u8 csum(const __u8 *buffer, ssize_t length)

+{

+	int n;

+	__u8 sum = 0;

+

+	for (n = 0; n < length; n++)

+		sum = (__u8)(sum + ((__u8 *)buffer)[n]);

+	return sum;

+}

+

+static void format_ip_addr(char *buf, size_t buflen, __u8 *addr)

+{

+	struct in6_addr *addr_ipv6;

+

+	addr_ipv6 = (struct in6_addr *)addr;

+	if (addr_ipv6->s6_addr32[0] == 0 &&

+	    addr_ipv6->s6_addr32[1] == 0 &&

+	    ntohl(addr_ipv6->s6_addr32[2]) == 0xffff)

+		/* ipv4 */

+		inet_ntop(AF_INET, &(addr_ipv6->s6_addr32[3]), buf, buflen);

+	else

+		/* ipv6 */

+		inet_ntop(AF_INET6, addr_ipv6, buf, buflen);

+}

+

+static bool in_heap(struct nbft_header *header, struct nbft_heap_obj obj)

+{

+	if (le16_to_cpu(obj.length) == 0)

+		return true;

+	if (le32_to_cpu(obj.offset) < le32_to_cpu(header->heap_offset))

+		return false;

+	if (le32_to_cpu(obj.offset) >

+	    le32_to_cpu(header->heap_offset) + le32_to_cpu(header->heap_length))

+		return false;

+	if (le32_to_cpu(obj.offset) + le16_to_cpu(obj.length) >

+	    le32_to_cpu(header->heap_offset) + le32_to_cpu(header->heap_length))

+		return false;

+	return true;

+}

+

+/*

+ *  Return transport_type string (NBFT Table 2)

+ */

+static char *trtype_to_string(__u8 transport_type)

+{

+	switch (transport_type) {

+	case 3:

+		return "tcp";

+	default:

+		return "invalid";

+	}

+}

+

+#define verify(condition, message)					\

+	do {								\

+		if (!(condition)) {					\

+			nvme_msg(NULL, LOG_DEBUG, "file %s: " message "\n", \

+				 nbft->filename);			\

+			return -EINVAL;					\

+		}							\

+	} while (0)

+

+static int __get_heap_obj(struct nbft_header *header, const char *filename,

+			  const char *descriptorname, const char *fieldname,

+			  struct nbft_heap_obj obj, bool is_string,

+			  char **output)

+{

+	if (le16_to_cpu(obj.length) == 0)

+		return -ENOENT;

+

+	if (!in_heap(header, obj)) {

+		nvme_msg(NULL, LOG_DEBUG,

+			 "file %s: field '%s' in descriptor '%s' has invalid offset or length\n",

+			 filename, fieldname, descriptorname);

+		return -EINVAL;

+	}

+

+	/* check that string is zero terminated correctly */

+	*output = (char *)header + le32_to_cpu(obj.offset);

+

+	if (is_string) {

+		if (strnlen(*output, le16_to_cpu(obj.length) + 1) < le16_to_cpu(obj.length))

+			nvme_msg(NULL, LOG_DEBUG,

+				"file %s: string '%s' in descriptor '%s' is shorter (%zd) than specified length (%d)\n",

+				filename, fieldname, descriptorname,

+				strnlen(*output, le16_to_cpu(obj.length) + 1),

+					le16_to_cpu(obj.length));

+		else if (strnlen(*output, le16_to_cpu(obj.length) + 1) >

+			le16_to_cpu(obj.length)) {

+			nvme_msg(NULL, LOG_DEBUG,

+				 "file %s: string '%s' in descriptor '%s' is not zero terminated\n",

+				 filename, fieldname, descriptorname);

+			return -EINVAL;

+		}

+	}

+

+	return 0;

+}

+

+#define get_heap_obj(descriptor, obj, is_string, output)	\

+	__get_heap_obj(header, nbft->filename,			\

+		       stringify(descriptor), stringify(obj),	\

+		       descriptor->obj, is_string,		\

+		       output)

+

+static struct nbft_info_discovery *discovery_from_index(struct nbft_info *nbft, int i)

+{

+	struct nbft_info_discovery **d;

+

+	for (d = nbft->discovery_list; d && *d; d++) {

+		if ((*d)->index == i)

+			return *d;

+	}

+	return NULL;

+}

+

+static struct nbft_info_hfi *hfi_from_index(struct nbft_info *nbft, int i)

+{

+	struct nbft_info_hfi **h;

+

+	for (h = nbft->hfi_list; h && *h; h++) {

+		if ((*h)->index == i)

+			return *h;

+	}

+	return NULL;

+}

+

+static struct nbft_info_security *security_from_index(struct nbft_info *nbft, int i)

+{

+	struct nbft_info_security **s;

+

+	for (s = nbft->security_list; s && *s; s++) {

+		if ((*s)->index == i)

+			return *s;

+	}

+	return NULL;

+}

+

+static int read_ssns_exended_info(struct nbft_info *nbft,

+				  struct nbft_info_subsystem_ns *ssns,

+				  struct nbft_ssns_ext_info *raw_ssns_ei)

+{

+	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;

+

+	verify(raw_ssns_ei->structure_id == NBFT_DESC_SSNS_EXT_INFO,

+	       "invalid ID in SSNS extended info descriptor");

+	verify(raw_ssns_ei->version == 1,

+	       "invalid version in SSNS extended info descriptor");

+	verify(le16_to_cpu(raw_ssns_ei->ssns_index) == le16_to_cpu(ssns->index),

+	       "SSNS index doesn't match extended info descriptor index");

+

+	if (!(le32_to_cpu(raw_ssns_ei->flags) & NBFT_SSNS_EXT_INFO_VALID))

+		return -EINVAL;

+

+	if (le32_to_cpu(raw_ssns_ei->flags) & NBFT_SSNS_EXT_INFO_ADMIN_ASQSZ)

+		ssns->asqsz = le16_to_cpu(raw_ssns_ei->asqsz);

+	ssns->controller_id = le16_to_cpu(raw_ssns_ei->cntlid);

+	get_heap_obj(raw_ssns_ei, dhcp_root_path_str_obj, 1, &ssns->dhcp_root_path_string);

+

+	return 0;

+}

+

+static int read_ssns(struct nbft_info *nbft,

+		     struct nbft_ssns *raw_ssns,

+		     struct nbft_info_subsystem_ns **s)

+{

+	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;

+	struct nbft_info_subsystem_ns *ssns;

+	__u8 *ss_hfi_indexes = NULL;

+	__u8 *tmp = NULL;

+	int i, ret;

+

+	if (!(le16_to_cpu(raw_ssns->flags) & NBFT_SSNS_VALID))

+		return -EINVAL;

+

+	verify(raw_ssns->structure_id == NBFT_DESC_SSNS,

+	       "invalid ID in SSNS descriptor");

+

+	ssns = calloc(1, sizeof(*ssns));

+	if (!ssns)

+		return -ENOMEM;

+

+	ssns->index = le16_to_cpu(raw_ssns->index);

+

+	/* transport type */

+	verify(raw_ssns->trtype == NBFT_TRTYPE_TCP,

+	       "invalid transport type in SSNS descriptor");

+	strncpy(ssns->transport, trtype_to_string(raw_ssns->trtype), sizeof(ssns->transport));

+

+	/* transport specific flags */

+	if (raw_ssns->trtype == NBFT_TRTYPE_TCP) {

+		if (le16_to_cpu(raw_ssns->trflags) & NBFT_SSNS_PDU_HEADER_DIGEST)

+			ssns->pdu_header_digest_required = true;

+		if (le16_to_cpu(raw_ssns->trflags) & NBFT_SSNS_DATA_DIGEST)

+			ssns->data_digest_required = true;

+	}

+

+	/* primary discovery controller */

+	if (raw_ssns->primary_discovery_ctrl_index) {

+		ssns->discovery = discovery_from_index(nbft,

+						       raw_ssns->primary_discovery_ctrl_index);

+		if (!ssns->discovery)

+			nvme_msg(NULL, LOG_DEBUG,

+				 "file %s: namespace %d discovery controller not found\n",

+				 nbft->filename, ssns->index);

+	}

+

+	/* subsystem transport address */

+	ret = get_heap_obj(raw_ssns, subsys_traddr_obj, 0, (char **)&tmp);

+	if (ret)

+		goto fail;

+

+	format_ip_addr(ssns->traddr, sizeof(ssns->traddr), tmp);

+

+	/* subsystem transport service identifier */

+	ret = get_heap_obj(raw_ssns, subsys_trsvcid_obj, 1, &ssns->trsvcid);

+	if (ret)

+		goto fail;

+

+	/* subsystem port ID */

+	ssns->subsys_port_id = le16_to_cpu(raw_ssns->subsys_port_id);

+

+	/* NSID, NID type, & NID */

+	ssns->nsid = le32_to_cpu(raw_ssns->nsid);

+	ssns->nid_type = raw_ssns->nidt;

+	ssns->nid = raw_ssns->nid;

+

+	/* security profile */

+	if (raw_ssns->security_desc_index) {

+		ssns->security = security_from_index(nbft, raw_ssns->security_desc_index);

+		if (!ssns->security)

+			nvme_msg(NULL, LOG_DEBUG,

+				 "file %s: namespace %d security controller not found\n",

+				 nbft->filename, ssns->index);

+	}

+

+	/* HFI descriptors */

+	ret = get_heap_obj(raw_ssns, secondary_hfi_assoc_obj, 0, (char **)&ss_hfi_indexes);

+	if (ret)

+		goto fail;

+

+	ssns->hfis = calloc(le16_to_cpu(raw_ssns->secondary_hfi_assoc_obj.length) + 2,

+			    sizeof(*ssns->hfis));

+	if (!ssns->hfis) {

+		ret = -ENOMEM;

+		goto fail;

+	}

+	ssns->hfis[0] = hfi_from_index(nbft, raw_ssns->primary_hfi_desc_index);

+	if (!ssns->hfis[0]) {

+		nvme_msg(NULL, LOG_DEBUG,

+			 "file %s: SSNS %d: HFI %d not found\n",

+			 nbft->filename, ssns->index, raw_ssns->primary_hfi_desc_index);

+		ret = -EINVAL;

+		goto fail;

+	}

+	for (i = 0; i < le16_to_cpu(raw_ssns->secondary_hfi_assoc_obj.length); i++) {

+		ssns->hfis[i + 1] = hfi_from_index(nbft, ss_hfi_indexes[i]);

+		if (ss_hfi_indexes[i] && !ssns->hfis[i + 1])

+			nvme_msg(NULL, LOG_DEBUG,

+				 "file %s: SSNS %d HFI %d not found\n",

+				 nbft->filename, ssns->index, ss_hfi_indexes[i]);

+		else

+			ssns->num_hfis++;

+	}

+

+	/* SSNS NQN */

+	ret = get_heap_obj(raw_ssns, subsys_ns_nqn_obj, 1, &ssns->subsys_nqn);

+	if (ret)

+		goto fail;

+

+	/* SSNS extended info */

+	if (raw_ssns->flags & NBFT_SSNS_EXTENDED_INFO_IN_USE) {

+		struct nbft_ssns_ext_info *ssns_extended_info;

+

+		if (!get_heap_obj(raw_ssns, ssns_extended_info_desc_obj, 0,

+				  (char **)&ssns_extended_info))

+			read_ssns_exended_info(nbft, ssns, ssns_extended_info);

+	}

+

+	*s = ssns;

+	return 0;

+

+fail:

+	free(ssns);

+	return ret;

+}

+

+static int read_hfi_info_tcp(struct nbft_info *nbft,

+			     struct nbft_hfi_info_tcp *raw_hfi_info_tcp,

+			     struct nbft_info_hfi *hfi)

+{

+	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;

+

+	if ((raw_hfi_info_tcp->flags & NBFT_HFI_INFO_TCP_VALID) == 0)

+		return -EINVAL;

+

+	verify(raw_hfi_info_tcp->structure_id == NBFT_DESC_HFI_TRINFO,

+	       "invalid ID in HFI transport descriptor");

+	verify(raw_hfi_info_tcp->version == 1,

+	       "invalid version in HFI transport descriptor");

+	if (le16_to_cpu(raw_hfi_info_tcp->hfi_index) != hfi->index)

+		nvme_msg(NULL, LOG_DEBUG,

+			 "file %s: HFI descriptor index %d does not match index in HFI transport descriptor\n",

+			 nbft->filename, hfi->index);

+

+	hfi->tcp_info.pci_sbdf = le32_to_cpu(raw_hfi_info_tcp->pci_sbdf);

+	memcpy(hfi->tcp_info.mac_addr, raw_hfi_info_tcp->mac_addr,

+	       sizeof(raw_hfi_info_tcp->mac_addr));

+	hfi->tcp_info.vlan = le16_to_cpu(raw_hfi_info_tcp->vlan);

+	hfi->tcp_info.ip_origin = raw_hfi_info_tcp->ip_origin;

+	format_ip_addr(hfi->tcp_info.ipaddr, sizeof(hfi->tcp_info.ipaddr),

+		       raw_hfi_info_tcp->ip_address);

+	hfi->tcp_info.subnet_mask_prefix = raw_hfi_info_tcp->subnet_mask_prefix;

+	format_ip_addr(hfi->tcp_info.gateway_ipaddr, sizeof(hfi->tcp_info.ipaddr),

+		       raw_hfi_info_tcp->ip_gateway);

+	hfi->tcp_info.route_metric = le16_to_cpu(raw_hfi_info_tcp->route_metric);

+	format_ip_addr(hfi->tcp_info.primary_dns_ipaddr,

+		       sizeof(hfi->tcp_info.primary_dns_ipaddr),

+		       raw_hfi_info_tcp->primary_dns);

+	format_ip_addr(hfi->tcp_info.secondary_dns_ipaddr,

+		       sizeof(hfi->tcp_info.secondary_dns_ipaddr),

+		       raw_hfi_info_tcp->secondary_dns);

+	if (raw_hfi_info_tcp->flags & NBFT_HFI_INFO_TCP_DHCP_OVERRIDE) {

+		hfi->tcp_info.dhcp_override = true;

+		format_ip_addr(hfi->tcp_info.dhcp_server_ipaddr,

+			       sizeof(hfi->tcp_info.dhcp_server_ipaddr),

+			       raw_hfi_info_tcp->dhcp_server);

+	}

+	get_heap_obj(raw_hfi_info_tcp, host_name_obj, 1, &hfi->tcp_info.host_name);

+	if (raw_hfi_info_tcp->flags & NBFT_HFI_INFO_TCP_GLOBAL_ROUTE)

+		hfi->tcp_info.this_hfi_is_default_route = true;

+

+	return 0;

+}

+

+static int read_hfi(struct nbft_info *nbft,

+		    struct nbft_hfi *raw_hfi,

+		    struct nbft_info_hfi **h)

+{

+	int ret;

+	struct nbft_info_hfi *hfi;

+	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;

+

+	if (!(raw_hfi->flags & NBFT_HFI_VALID))

+		return -EINVAL;

+

+	verify(raw_hfi->structure_id == NBFT_DESC_HFI,

+	       "invalid ID in HFI descriptor");

+

+	hfi = calloc(1, sizeof(struct nbft_info_hfi));

+	if (!hfi)

+		return -ENOMEM;

+

+	hfi->index = raw_hfi->index;

+

+	/*

+	 * read HFI transport descriptor for this HFI

+	 */

+	if (raw_hfi->trtype == NBFT_TRTYPE_TCP) {

+		/* TCP */

+		struct nbft_hfi_info_tcp *raw_hfi_info_tcp;

+

+		strncpy(hfi->transport, trtype_to_string(raw_hfi->trtype),

+			sizeof(hfi->transport));

+

+		ret = get_heap_obj(raw_hfi, trinfo_obj, 0, (char **)&raw_hfi_info_tcp);

+		if (ret)

+			goto fail;

+

+		ret = read_hfi_info_tcp(nbft, raw_hfi_info_tcp, hfi);

+		if (ret)

+			goto fail;

+	} else {

+		nvme_msg(NULL, LOG_DEBUG,

+			 "file %s: invalid transport type %d\n",

+			 nbft->filename, raw_hfi->trtype);

+		ret = -EINVAL;

+		goto fail;

+	}

+

+	*h = hfi;

+	return 0;

+

+fail:

+	free(hfi);

+	return ret;

+}

+

+static int read_discovery(struct nbft_info *nbft,

+			  struct nbft_discovery *raw_discovery,

+			  struct nbft_info_discovery **d)

+{

+	struct nbft_info_discovery *discovery;

+	struct nbft_header *header = (struct nbft_header *)nbft->raw_nbft;

+

+	if (!(raw_discovery->flags & NBFT_DISCOVERY_VALID))

+		return -EINVAL;

+

+	verify(raw_discovery->structure_id == NBFT_DESC_DISCOVERY,

+	       "invalid ID in discovery descriptor");

+

+	discovery = calloc(1, sizeof(struct nbft_info_discovery));

+	if (!discovery)

+		return -ENOMEM;

+

+	discovery->index = raw_discovery->index;

+

+	if (get_heap_obj(raw_discovery, discovery_ctrl_addr_obj, 1, &discovery->uri))

+		return -EINVAL;

+

+	if (get_heap_obj(raw_discovery, discovery_ctrl_nqn_obj, 1, &discovery->nqn))

+		return -EINVAL;

+

+	discovery->hfi = hfi_from_index(nbft, raw_discovery->hfi_index);

+	if (raw_discovery->hfi_index && !discovery->hfi)

+		nvme_msg(NULL, LOG_DEBUG,

+			 "file %s: discovery %d HFI not found\n",

+			 nbft->filename, discovery->index);

+

+	discovery->security = security_from_index(nbft, raw_discovery->sec_index);

+	if (raw_discovery->sec_index && !discovery->security)

+		nvme_msg(NULL, LOG_DEBUG,

+			 "file %s: discovery %d security descriptor not found\n",

+			 nbft->filename, discovery->index);

+

+	*d = discovery;

+	return 0;

+}

+

+static int read_security(struct nbft_info *nbft,

+			 struct nbft_security *raw_security,

+			 struct nbft_info_security **s)

+{

+	return -EINVAL;

+}

+

+static void read_hfi_descriptors(struct nbft_info *nbft, int num_hfi,

+				 struct nbft_hfi *raw_hfi_array, int hfi_len)

+{

+	int i, cnt;

+

+	nbft->hfi_list = calloc(num_hfi + 1, sizeof(struct nbft_info_hfi));

+	for (i = 0, cnt = 0; i < num_hfi; i++) {

+		if (read_hfi(nbft, &raw_hfi_array[i], &nbft->hfi_list[cnt]) == 0)

+			cnt++;

+	}

+}

+

+static void read_security_descriptors(struct nbft_info *nbft, int num_sec,

+				      struct nbft_security *raw_sec_array, int sec_len)

+{

+	int i, cnt;

+

+	nbft->security_list = calloc(num_sec + 1, sizeof(struct nbft_info_security));

+	for (i = 0, cnt = 0; i < num_sec; i++) {

+		if (read_security(nbft, &raw_sec_array[i], &nbft->security_list[cnt]) == 0)

+			cnt++;

+	}

+}

+

+static void read_discovery_descriptors(struct nbft_info *nbft, int num_disc,

+				       struct nbft_discovery *raw_disc_array, int disc_len)

+{

+	int i, cnt;

+

+	nbft->discovery_list = calloc(num_disc + 1, sizeof(struct nbft_info_discovery));

+	for (i = 0, cnt = 0; i < num_disc; i++) {

+		if (read_discovery(nbft, &raw_disc_array[i], &nbft->discovery_list[cnt]) == 0)

+			cnt++;

+	}

+}

+

+static void read_ssns_descriptors(struct nbft_info *nbft, int num_ssns,

+				  struct nbft_ssns *raw_ssns_array, int ssns_len)

+{

+	int i, cnt;

+

+	nbft->subsystem_ns_list = calloc(num_ssns + 1, sizeof(struct nbft_info_subsystem_ns));

+	for (i = 0, cnt = 0; i < num_ssns; i++) {

+		if (read_ssns(nbft, &raw_ssns_array[i], &nbft->subsystem_ns_list[cnt]) == 0)

+			cnt++;

+	}

+}

+

+/**

+ * parse_raw_nbft - parses raw ACPI NBFT table and fill in abstracted nbft_info structure

+ * @nbft: nbft_info struct containing only raw_nbft and raw_nbft_size

+ *

+ * Returns 0 on success, errno otherwise.

+ */

+static int parse_raw_nbft(struct nbft_info *nbft)

+{

+	__u8 *raw_nbft = nbft->raw_nbft;

+	int raw_nbft_size = nbft->raw_nbft_size;

+

+	struct nbft_header *header;

+	struct nbft_control *control;

+	struct nbft_host *host;

+

+	verify(raw_nbft_size >= sizeof(struct nbft_header) + sizeof(struct nbft_control),

+	       "table is too short");

+	verify(csum(raw_nbft, raw_nbft_size) == 0, "invalid checksum");

+

+	/*

+	 * header

+	 */

+	header = (struct nbft_header *)raw_nbft;

+

+	verify(strncmp(header->signature, NBFT_HEADER_SIG, 4) == 0, "invalid signature");

+	verify(le32_to_cpu(header->length) <= raw_nbft_size, "length in header exceeds table length");

+	verify(header->major_revision == 1, "unsupported major revision");

+	verify(header->minor_revision == 0, "unsupported minor revision");

+	verify(le32_to_cpu(header->heap_length) + le32_to_cpu(header->heap_offset) <=

+	       le32_to_cpu(header->length), "heap exceeds table length");

+

+	/*

+	 * control

+	 */

+	control = (struct nbft_control *)(raw_nbft + sizeof(struct nbft_header));

+

+	if ((control->flags & NBFT_CONTROL_VALID) == 0)

+		return 0;

+	verify(control->structure_id == NBFT_DESC_CONTROL,

+	       "invalid ID in control structure");

+

+	/*

+	 * host

+	 */

+	verify(le32_to_cpu(control->hdesc.offset) + sizeof(struct nbft_host) <=

+	       le32_to_cpu(header->length) &&

+	       le32_to_cpu(control->hdesc.offset) >= sizeof(struct nbft_host),

+	       "host descriptor offset/length is invalid");

+	host = (struct nbft_host *)(raw_nbft + le32_to_cpu(control->hdesc.offset));

+

+	verify(host->flags & NBFT_HOST_VALID, "host descriptor valid flag not set");

+	verify(host->structure_id == NBFT_DESC_HOST, "invalid ID in HOST descriptor");

+	nbft->host.id = (unsigned char *) &(host->host_id);

+	if (get_heap_obj(host, host_nqn_obj, 1, &nbft->host.nqn) != 0)

+		return -EINVAL;

+

+	/*

+	 * HFI

+	 */

+	if (control->num_hfi > 0) {

+		struct nbft_hfi *raw_hfi_array;

+

+		verify(le32_to_cpu(control->hfio) + sizeof(struct nbft_hfi) *

+		       control->num_hfi <= le32_to_cpu(header->length),

+		       "invalid hfi descriptor list offset");

+		raw_hfi_array = (struct nbft_hfi *)(raw_nbft + le32_to_cpu(control->hfio));

+		read_hfi_descriptors(nbft, control->num_hfi, raw_hfi_array,

+				     le16_to_cpu(control->hfil));

+	}

+

+	/*

+	 * security

+	 */

+	if (control->num_sec > 0) {

+		struct nbft_security *raw_security_array;

+

+		verify(le32_to_cpu(control->seco) + le16_to_cpu(control->secl) *

+		       control->num_sec <= le32_to_cpu(header->length),

+		       "invalid security profile desciptor list offset");

+		raw_security_array = (struct nbft_security *)(raw_nbft +

+				     le32_to_cpu(control->seco));

+		read_security_descriptors(nbft, control->num_sec,

+					  raw_security_array,

+					  le16_to_cpu(control->secl));

+	}

+

+	/*

+	 * discovery

+	 */

+	if (control->num_disc > 0) {

+		struct nbft_discovery *raw_discovery_array;

+

+		verify(le32_to_cpu(control->disco) + le16_to_cpu(control->discl) *

+		       control->num_disc <= le32_to_cpu(header->length),

+		       "invalid discovery profile descriptor list offset");

+		raw_discovery_array = (struct nbft_discovery *)(raw_nbft +

+				      le32_to_cpu(control->disco));

+		read_discovery_descriptors(nbft, control->num_disc, raw_discovery_array,

+					   le16_to_cpu(control->discl));

+	}

+

+	/*

+	 * subsystem namespace

+	 */

+	if (control->num_ssns > 0) {

+		struct nbft_ssns *raw_ssns_array;

+

+		verify(le32_to_cpu(control->ssnso) + le16_to_cpu(control->ssnsl) *

+		       control->num_ssns <= le32_to_cpu(header->length),

+		       "invalid subsystem namespace descriptor list offset");

+		raw_ssns_array = (struct nbft_ssns *)(raw_nbft +

+				 le32_to_cpu(control->ssnso));

+		read_ssns_descriptors(nbft, control->num_ssns, raw_ssns_array,

+				      le16_to_cpu(control->ssnsl));

+	}

+

+	return 0;

+}

+

+/**

+ * nvme_nbft_free() - Free the struct nbft_info and its contents

+ * @nbft: Parsed NBFT table data.

+ */

+void nvme_nbft_free(struct nbft_info *nbft)

+{

+	struct nbft_info_hfi **hfi;

+	struct nbft_info_security **sec;

+	struct nbft_info_discovery **disc;

+	struct nbft_info_subsystem_ns **ns;

+

+	for (hfi = nbft->hfi_list; hfi && *hfi; hfi++)

+		free(*hfi);

+	free(nbft->hfi_list);

+	for (disc = nbft->discovery_list; disc && *disc; disc++)

+		free(*disc);

+	free(nbft->discovery_list);

+	for (sec = nbft->security_list; sec && *sec; sec++)

+		free(*sec);

+	free(nbft->security_list);

+	for (ns = nbft->subsystem_ns_list; ns && *ns; ns++) {

+		free((*ns)->hfis);

+		free(*ns);

+	}

+	free(nbft->subsystem_ns_list);

+	free(nbft->raw_nbft);

+	free(nbft->filename);

+	free(nbft);

+}

+

+/**

+ * nvme_nbft_read() - Read and parse contents of an ACPI NBFT table

+ *

+ * @nbft:     Parsed NBFT table data.

+ * @filename: Filename of the raw NBFT table to read.

+ *

+ * Read and parse the specified NBFT file into a struct nbft_info.

+ * Free with nbft_free().

+ *

+ * Return: 0 on success, errno otherwise.

+ */

+int nvme_nbft_read(struct nbft_info **nbft, const char *filename)

+{

+	__u8 *raw_nbft = NULL;

+	size_t raw_nbft_size;

+	FILE *raw_nbft_fp = NULL;

+	int i;

+

+	/*

+	 * read in raw nbft file

+	 */

+	raw_nbft_fp = fopen(filename, "rb");

+	if (raw_nbft_fp == NULL) {

+		nvme_msg(NULL, LOG_ERR, "Failed to open %s: %s\n",

+			 filename, strerror(errno));

+		errno = EINVAL;

+		return 1;

+	}

+

+	i = fseek(raw_nbft_fp, 0L, SEEK_END);

+	if (i) {

+		nvme_msg(NULL, LOG_ERR, "Failed to read from %s: %s\n",

+			 filename, strerror(errno));

+		fclose(raw_nbft_fp);

+		errno = EINVAL;

+		return 1;

+	}

+

+	raw_nbft_size = ftell(raw_nbft_fp);

+	rewind(raw_nbft_fp);

+

+	raw_nbft = malloc(raw_nbft_size);

+	if (!raw_nbft) {

+		nvme_msg(NULL, LOG_ERR, "Failed to allocate memory for NBFT table");

+		fclose(raw_nbft_fp);

+		errno = ENOMEM;

+		return 1;

+	}

+

+	i = fread(raw_nbft, sizeof(*raw_nbft), raw_nbft_size, raw_nbft_fp);

+	if (i != raw_nbft_size) {

+		nvme_msg(NULL, LOG_ERR, "Failed to read from %s: %s\n",

+			 filename, strerror(errno));

+		fclose(raw_nbft_fp);

+		free(raw_nbft);

+		errno = EINVAL;

+		return 1;

+	}

+	fclose(raw_nbft_fp);

+

+	/*

+	 * alloc new struct nbft_info, add raw nbft & filename to it, and add it to the list

+	 */

+	*nbft = calloc(1, sizeof(struct nbft_info));

+	if (!*nbft) {

+		nvme_msg(NULL, LOG_ERR, "Could not allocate memory for NBFT\n");

+		free(raw_nbft);

+		errno = ENOMEM;

+		return 1;

+	}

+

+	(*nbft)->filename = strdup(filename);

+	(*nbft)->raw_nbft = raw_nbft;

+	(*nbft)->raw_nbft_size = raw_nbft_size;

+

+	if (parse_raw_nbft(*nbft)) {

+		nvme_msg(NULL, LOG_ERR, "Failed to parse %s\n", filename);

+		nvme_nbft_free(*nbft);

+		errno = EINVAL;

+		return 1;

+	}

+	return 0;

+}

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

new file mode 100644

index 0000000..c3caa85

--- /dev/null

+++ b/src/nvme/nbft.h

@@ -0,0 +1,1238 @@

+/* SPDX-License-Identifier: LGPL-2.1-or-later */

+/*

+ * This file is part of libnvme.

+ * Copyright (c) 2021-2022, Dell Inc. or its subsidiaries.  All Rights Reserved.

+ *

+ * Authors: Stuart Hayes <Stuart_Hayes@Dell.com>

+ *

+ */

+#ifndef _NBFT_H

+#define _NBFT_H

+

+#include <sys/types.h>

+#include "util.h"

+

+/*

+ *  ACPI NBFT table structures (TP8012 Boot Specification rev. 1.0)

+ */

+

+/**

+ * enum nbft_desc_type - NBFT Elements - Descriptor Types (Figure 5)

+ * @NBFT_DESC_HEADER:	     Header: an ACPI structure header with some additional

+ *			     NBFT specific info.

+ * @NBFT_DESC_CONTROL:	     Control Descriptor: indicates the location of host,

+ *			     HFI, SSNS, security, and discovery descriptors.

+ * @NBFT_DESC_HOST:	     Host Descriptor: host information.

+ * @NBFT_DESC_HFI:	     HFI Descriptor: an indexable table of HFI Descriptors,

+ *			     one for each fabric interface on the host.

+ * @NBFT_DESC_SSNS:	     Subsystem Namespace Descriptor: an indexable table

+ *			     of SSNS Descriptors.

+ * @NBFT_DESC_SECURITY:	     Security Descriptor: an indexable table of Security

+ *			     descriptors.

+ * @NBFT_DESC_DISCOVERY:     Discovery Descriptor: an indexable table of Discovery

+ *			     Descriptors.

+ * @NBFT_DESC_HFI_TRINFO:    HFI Transport Descriptor: indicated by an HFI Descriptor,

+ *			     corresponds to a specific transport for a single HFI.

+ * @NBFT_DESC_RESERVED_8:    Reserved.

+ * @NBFT_DESC_SSNS_EXT_INFO: SSNS Extended Info Descriptor: indicated by an SSNS

+ *			     Descriptor if required.

+ */