diff --git a/libnvme/src/meson.build b/libnvme/src/meson.build
index 1fcd1aa533..53732077f5 100644
--- a/libnvme/src/meson.build
+++ b/libnvme/src/meson.build
@@ -96,6 +96,7 @@ libnvme = library(
     'nvme', # produces libnvme.so
     sources,
     version: libnvme_so_version,
+    c_args: ['-fvisibility=hidden'],
     link_args: link_args,
     dependencies: deps,
     install: true,
diff --git a/libnvme/src/nvme/accessors.c b/libnvme/src/nvme/accessors.c
index 7f529b3206..d3c507d7ed 100644
--- a/libnvme/src/nvme/accessors.c
+++ b/libnvme/src/nvme/accessors.c
@@ -22,61 +22,68 @@
 #include "accessors.h"
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 /****************************************************************************
  * Accessors for: struct nvme_path
  ****************************************************************************/
 
-void nvme_path_set_name(struct nvme_path *p, const char *name)
+__public void nvme_path_set_name(struct nvme_path *p, const char *name)
 {
 	free(p->name);
 	p->name = name ? strdup(name) : NULL;
 }
 
-const char *nvme_path_get_name(const struct nvme_path *p)
+__public const char *nvme_path_get_name(const struct nvme_path *p)
 {
 	return p->name;
 }
 
-void nvme_path_set_sysfs_dir(struct nvme_path *p, const char *sysfs_dir)
+__public void nvme_path_set_sysfs_dir(
+		struct nvme_path *p,
+		const char *sysfs_dir)
 {
 	free(p->sysfs_dir);
 	p->sysfs_dir = sysfs_dir ? strdup(sysfs_dir) : NULL;
 }
 
-const char *nvme_path_get_sysfs_dir(const struct nvme_path *p)
+__public const char *nvme_path_get_sysfs_dir(const struct nvme_path *p)
 {
 	return p->sysfs_dir;
 }
 
-void nvme_path_set_ana_state(struct nvme_path *p, const char *ana_state)
+__public void nvme_path_set_ana_state(
+		struct nvme_path *p,
+		const char *ana_state)
 {
 	free(p->ana_state);
 	p->ana_state = ana_state ? strdup(ana_state) : NULL;
 }
 
-const char *nvme_path_get_ana_state(const struct nvme_path *p)
+__public const char *nvme_path_get_ana_state(const struct nvme_path *p)
 {
 	return p->ana_state;
 }
 
-void nvme_path_set_numa_nodes(struct nvme_path *p, const char *numa_nodes)
+__public void nvme_path_set_numa_nodes(
+		struct nvme_path *p,
+		const char *numa_nodes)
 {
 	free(p->numa_nodes);
 	p->numa_nodes = numa_nodes ? strdup(numa_nodes) : NULL;
 }
 
-const char *nvme_path_get_numa_nodes(const struct nvme_path *p)
+__public const char *nvme_path_get_numa_nodes(const struct nvme_path *p)
 {
 	return p->numa_nodes;
 }
 
-void nvme_path_set_grpid(struct nvme_path *p, int grpid)
+__public void nvme_path_set_grpid(struct nvme_path *p, int grpid)
 {
 	p->grpid = grpid;
 }
 
-int nvme_path_get_grpid(const struct nvme_path *p)
+__public int nvme_path_get_grpid(const struct nvme_path *p)
 {
 	return p->grpid;
 }
@@ -85,84 +92,84 @@ int nvme_path_get_grpid(const struct nvme_path *p)
  * Accessors for: struct nvme_ns
  ****************************************************************************/
 
-void nvme_ns_set_nsid(struct nvme_ns *p, __u32 nsid)
+__public void nvme_ns_set_nsid(struct nvme_ns *p, __u32 nsid)
 {
 	p->nsid = nsid;
 }
 
-__u32 nvme_ns_get_nsid(const struct nvme_ns *p)
+__public __u32 nvme_ns_get_nsid(const struct nvme_ns *p)
 {
 	return p->nsid;
 }
 
-void nvme_ns_set_name(struct nvme_ns *p, const char *name)
+__public void nvme_ns_set_name(struct nvme_ns *p, const char *name)
 {
 	free(p->name);
 	p->name = name ? strdup(name) : NULL;
 }
 
-const char *nvme_ns_get_name(const struct nvme_ns *p)
+__public const char *nvme_ns_get_name(const struct nvme_ns *p)
 {
 	return p->name;
 }
 
-void nvme_ns_set_sysfs_dir(struct nvme_ns *p, const char *sysfs_dir)
+__public void nvme_ns_set_sysfs_dir(struct nvme_ns *p, const char *sysfs_dir)
 {
 	free(p->sysfs_dir);
 	p->sysfs_dir = sysfs_dir ? strdup(sysfs_dir) : NULL;
 }
 
-const char *nvme_ns_get_sysfs_dir(const struct nvme_ns *p)
+__public const char *nvme_ns_get_sysfs_dir(const struct nvme_ns *p)
 {
 	return p->sysfs_dir;
 }
 
-void nvme_ns_set_lba_shift(struct nvme_ns *p, int lba_shift)
+__public void nvme_ns_set_lba_shift(struct nvme_ns *p, int lba_shift)
 {
 	p->lba_shift = lba_shift;
 }
 
-int nvme_ns_get_lba_shift(const struct nvme_ns *p)
+__public int nvme_ns_get_lba_shift(const struct nvme_ns *p)
 {
 	return p->lba_shift;
 }
 
-void nvme_ns_set_lba_size(struct nvme_ns *p, int lba_size)
+__public void nvme_ns_set_lba_size(struct nvme_ns *p, int lba_size)
 {
 	p->lba_size = lba_size;
 }
 
-int nvme_ns_get_lba_size(const struct nvme_ns *p)
+__public int nvme_ns_get_lba_size(const struct nvme_ns *p)
 {
 	return p->lba_size;
 }
 
-void nvme_ns_set_meta_size(struct nvme_ns *p, int meta_size)
+__public void nvme_ns_set_meta_size(struct nvme_ns *p, int meta_size)
 {
 	p->meta_size = meta_size;
 }
 
-int nvme_ns_get_meta_size(const struct nvme_ns *p)
+__public int nvme_ns_get_meta_size(const struct nvme_ns *p)
 {
 	return p->meta_size;
 }
 
-void nvme_ns_set_lba_count(struct nvme_ns *p, uint64_t lba_count)
+__public void nvme_ns_set_lba_count(struct nvme_ns *p, uint64_t lba_count)
 {
 	p->lba_count = lba_count;
 }
 
-uint64_t nvme_ns_get_lba_count(const struct nvme_ns *p)
+__public uint64_t nvme_ns_get_lba_count(const struct nvme_ns *p)
 {
 	return p->lba_count;
 }
 
-void nvme_ns_set_lba_util(struct nvme_ns *p, uint64_t lba_util)
+__public void nvme_ns_set_lba_util(struct nvme_ns *p, uint64_t lba_util)
 {
 	p->lba_util = lba_util;
 }
 
-uint64_t nvme_ns_get_lba_util(const struct nvme_ns *p)
+__public uint64_t nvme_ns_get_lba_util(const struct nvme_ns *p)
 {
 	return p->lba_util;
 }
@@ -171,67 +178,67 @@ uint64_t nvme_ns_get_lba_util(const struct nvme_ns *p)
  * Accessors for: struct nvme_ctrl
  ****************************************************************************/
 
-const char *nvme_ctrl_get_name(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_name(const struct nvme_ctrl *p)
 {
 	return p->name;
 }
 
-const char *nvme_ctrl_get_sysfs_dir(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_sysfs_dir(const struct nvme_ctrl *p)
 {
 	return p->sysfs_dir;
 }
 
-const char *nvme_ctrl_get_firmware(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_firmware(const struct nvme_ctrl *p)
 {
 	return p->firmware;
 }
 
-const char *nvme_ctrl_get_model(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_model(const struct nvme_ctrl *p)
 {
 	return p->model;
 }
 
-const char *nvme_ctrl_get_numa_node(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_numa_node(const struct nvme_ctrl *p)
 {
 	return p->numa_node;
 }
 
-const char *nvme_ctrl_get_queue_count(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_queue_count(const struct nvme_ctrl *p)
 {
 	return p->queue_count;
 }
 
-const char *nvme_ctrl_get_serial(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_serial(const struct nvme_ctrl *p)
 {
 	return p->serial;
 }
 
-const char *nvme_ctrl_get_sqsize(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_sqsize(const struct nvme_ctrl *p)
 {
 	return p->sqsize;
 }
 
-const char *nvme_ctrl_get_transport(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_transport(const struct nvme_ctrl *p)
 {
 	return p->transport;
 }
 
-const char *nvme_ctrl_get_subsysnqn(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_subsysnqn(const struct nvme_ctrl *p)
 {
 	return p->subsysnqn;
 }
 
-const char *nvme_ctrl_get_traddr(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_traddr(const struct nvme_ctrl *p)
 {
 	return p->traddr;
 }
 
-const char *nvme_ctrl_get_trsvcid(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_trsvcid(const struct nvme_ctrl *p)
 {
 	return p->trsvcid;
 }
 
-void nvme_ctrl_set_dhchap_host_key(
+__public void nvme_ctrl_set_dhchap_host_key(
 		struct nvme_ctrl *p,
 		const char *dhchap_host_key)
 {
@@ -239,12 +246,12 @@ void nvme_ctrl_set_dhchap_host_key(
 	p->dhchap_host_key = dhchap_host_key ? strdup(dhchap_host_key) : NULL;
 }
 
-const char *nvme_ctrl_get_dhchap_host_key(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_dhchap_host_key(const struct nvme_ctrl *p)
 {
 	return p->dhchap_host_key;
 }
 
-void nvme_ctrl_set_dhchap_ctrl_key(
+__public void nvme_ctrl_set_dhchap_ctrl_key(
 		struct nvme_ctrl *p,
 		const char *dhchap_ctrl_key)
 {
@@ -252,23 +259,23 @@ void nvme_ctrl_set_dhchap_ctrl_key(
 	p->dhchap_ctrl_key = dhchap_ctrl_key ? strdup(dhchap_ctrl_key) : NULL;
 }
 
-const char *nvme_ctrl_get_dhchap_ctrl_key(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_dhchap_ctrl_key(const struct nvme_ctrl *p)
 {
 	return p->dhchap_ctrl_key;
 }
 
-void nvme_ctrl_set_keyring(struct nvme_ctrl *p, const char *keyring)
+__public void nvme_ctrl_set_keyring(struct nvme_ctrl *p, const char *keyring)
 {
 	free(p->keyring);
 	p->keyring = keyring ? strdup(keyring) : NULL;
 }
 
-const char *nvme_ctrl_get_keyring(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_keyring(const struct nvme_ctrl *p)
 {
 	return p->keyring;
 }
 
-void nvme_ctrl_set_tls_key_identity(
+__public void nvme_ctrl_set_tls_key_identity(
 		struct nvme_ctrl *p,
 		const char *tls_key_identity)
 {
@@ -277,90 +284,92 @@ void nvme_ctrl_set_tls_key_identity(
 		tls_key_identity ? strdup(tls_key_identity) : NULL;
 }
 
-const char *nvme_ctrl_get_tls_key_identity(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_tls_key_identity(const struct nvme_ctrl *p)
 {
 	return p->tls_key_identity;
 }
 
-void nvme_ctrl_set_tls_key(struct nvme_ctrl *p, const char *tls_key)
+__public void nvme_ctrl_set_tls_key(struct nvme_ctrl *p, const char *tls_key)
 {
 	free(p->tls_key);
 	p->tls_key = tls_key ? strdup(tls_key) : NULL;
 }
 
-const char *nvme_ctrl_get_tls_key(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_tls_key(const struct nvme_ctrl *p)
 {
 	return p->tls_key;
 }
 
-const char *nvme_ctrl_get_cntrltype(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_cntrltype(const struct nvme_ctrl *p)
 {
 	return p->cntrltype;
 }
 
-const char *nvme_ctrl_get_cntlid(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_cntlid(const struct nvme_ctrl *p)
 {
 	return p->cntlid;
 }
 
-const char *nvme_ctrl_get_dctype(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_dctype(const struct nvme_ctrl *p)
 {
 	return p->dctype;
 }
 
-const char *nvme_ctrl_get_phy_slot(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_phy_slot(const struct nvme_ctrl *p)
 {
 	return p->phy_slot;
 }
 
-const char *nvme_ctrl_get_host_traddr(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_host_traddr(const struct nvme_ctrl *p)
 {
 	return p->host_traddr;
 }
 
-const char *nvme_ctrl_get_host_iface(const struct nvme_ctrl *p)
+__public const char *nvme_ctrl_get_host_iface(const struct nvme_ctrl *p)
 {
 	return p->host_iface;
 }
 
-void nvme_ctrl_set_discovery_ctrl(struct nvme_ctrl *p, bool discovery_ctrl)
+__public void nvme_ctrl_set_discovery_ctrl(
+		struct nvme_ctrl *p,
+		bool discovery_ctrl)
 {
 	p->discovery_ctrl = discovery_ctrl;
 }
 
-bool nvme_ctrl_get_discovery_ctrl(const struct nvme_ctrl *p)
+__public bool nvme_ctrl_get_discovery_ctrl(const struct nvme_ctrl *p)
 {
 	return p->discovery_ctrl;
 }
 
-void nvme_ctrl_set_unique_discovery_ctrl(
+__public void nvme_ctrl_set_unique_discovery_ctrl(
 		struct nvme_ctrl *p,
 		bool unique_discovery_ctrl)
 {
 	p->unique_discovery_ctrl = unique_discovery_ctrl;
 }
 
-bool nvme_ctrl_get_unique_discovery_ctrl(const struct nvme_ctrl *p)
+__public bool nvme_ctrl_get_unique_discovery_ctrl(const struct nvme_ctrl *p)
 {
 	return p->unique_discovery_ctrl;
 }
 
-void nvme_ctrl_set_discovered(struct nvme_ctrl *p, bool discovered)
+__public void nvme_ctrl_set_discovered(struct nvme_ctrl *p, bool discovered)
 {
 	p->discovered = discovered;
 }
 
-bool nvme_ctrl_get_discovered(const struct nvme_ctrl *p)
+__public bool nvme_ctrl_get_discovered(const struct nvme_ctrl *p)
 {
 	return p->discovered;
 }
 
-void nvme_ctrl_set_persistent(struct nvme_ctrl *p, bool persistent)
+__public void nvme_ctrl_set_persistent(struct nvme_ctrl *p, bool persistent)
 {
 	p->persistent = persistent;
 }
 
-bool nvme_ctrl_get_persistent(const struct nvme_ctrl *p)
+__public bool nvme_ctrl_get_persistent(const struct nvme_ctrl *p)
 {
 	return p->persistent;
 }
@@ -369,42 +378,45 @@ bool nvme_ctrl_get_persistent(const struct nvme_ctrl *p)
  * Accessors for: struct nvme_subsystem
  ****************************************************************************/
 
-const char *nvme_subsystem_get_name(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_name(const struct nvme_subsystem *p)
 {
 	return p->name;
 }
 
-const char *nvme_subsystem_get_sysfs_dir(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_sysfs_dir(
+		const struct nvme_subsystem *p)
 {
 	return p->sysfs_dir;
 }
 
-const char *nvme_subsystem_get_subsysnqn(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_subsysnqn(
+		const struct nvme_subsystem *p)
 {
 	return p->subsysnqn;
 }
 
-const char *nvme_subsystem_get_model(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_model(const struct nvme_subsystem *p)
 {
 	return p->model;
 }
 
-const char *nvme_subsystem_get_serial(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_serial(const struct nvme_subsystem *p)
 {
 	return p->serial;
 }
 
-const char *nvme_subsystem_get_firmware(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_firmware(const struct nvme_subsystem *p)
 {
 	return p->firmware;
 }
 
-const char *nvme_subsystem_get_subsystype(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_subsystype(
+		const struct nvme_subsystem *p)
 {
 	return p->subsystype;
 }
 
-void nvme_subsystem_set_application(
+__public void nvme_subsystem_set_application(
 		struct nvme_subsystem *p,
 		const char *application)
 {
@@ -412,18 +424,21 @@ void nvme_subsystem_set_application(
 	p->application = application ? strdup(application) : NULL;
 }
 
-const char *nvme_subsystem_get_application(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_application(
+		const struct nvme_subsystem *p)
 {
 	return p->application;
 }
 
-void nvme_subsystem_set_iopolicy(struct nvme_subsystem *p, const char *iopolicy)
+__public void nvme_subsystem_set_iopolicy(
+		struct nvme_subsystem *p,
+		const char *iopolicy)
 {
 	free(p->iopolicy);
 	p->iopolicy = iopolicy ? strdup(iopolicy) : NULL;
 }
 
-const char *nvme_subsystem_get_iopolicy(const struct nvme_subsystem *p)
+__public const char *nvme_subsystem_get_iopolicy(const struct nvme_subsystem *p)
 {
 	return p->iopolicy;
 }
@@ -432,17 +447,17 @@ const char *nvme_subsystem_get_iopolicy(const struct nvme_subsystem *p)
  * Accessors for: struct nvme_host
  ****************************************************************************/
 
-const char *nvme_host_get_hostnqn(const struct nvme_host *p)
+__public const char *nvme_host_get_hostnqn(const struct nvme_host *p)
 {
 	return p->hostnqn;
 }
 
-const char *nvme_host_get_hostid(const struct nvme_host *p)
+__public const char *nvme_host_get_hostid(const struct nvme_host *p)
 {
 	return p->hostid;
 }
 
-void nvme_host_set_dhchap_host_key(
+__public void nvme_host_set_dhchap_host_key(
 		struct nvme_host *p,
 		const char *dhchap_host_key)
 {
@@ -450,30 +465,32 @@ void nvme_host_set_dhchap_host_key(
 	p->dhchap_host_key = dhchap_host_key ? strdup(dhchap_host_key) : NULL;
 }
 
-const char *nvme_host_get_dhchap_host_key(const struct nvme_host *p)
+__public const char *nvme_host_get_dhchap_host_key(const struct nvme_host *p)
 {
 	return p->dhchap_host_key;
 }
 
-void nvme_host_set_hostsymname(struct nvme_host *p, const char *hostsymname)
+__public void nvme_host_set_hostsymname(
+		struct nvme_host *p,
+		const char *hostsymname)
 {
 	free(p->hostsymname);
 	p->hostsymname = hostsymname ? strdup(hostsymname) : NULL;
 }
 
-const char *nvme_host_get_hostsymname(const struct nvme_host *p)
+__public const char *nvme_host_get_hostsymname(const struct nvme_host *p)
 {
 	return p->hostsymname;
 }
 
-void nvme_host_set_pdc_enabled_valid(
+__public void nvme_host_set_pdc_enabled_valid(
 		struct nvme_host *p,
 		bool pdc_enabled_valid)
 {
 	p->pdc_enabled_valid = pdc_enabled_valid;
 }
 
-bool nvme_host_get_pdc_enabled_valid(const struct nvme_host *p)
+__public bool nvme_host_get_pdc_enabled_valid(const struct nvme_host *p)
 {
 	return p->pdc_enabled_valid;
 }
@@ -482,353 +499,389 @@ bool nvme_host_get_pdc_enabled_valid(const struct nvme_host *p)
  * Accessors for: struct nvme_fabric_options
  ****************************************************************************/
 
-void nvme_fabric_options_set_cntlid(struct nvme_fabric_options *p, bool cntlid)
+__public void nvme_fabric_options_set_cntlid(
+		struct nvme_fabric_options *p,
+		bool cntlid)
 {
 	p->cntlid = cntlid;
 }
 
-bool nvme_fabric_options_get_cntlid(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_cntlid(
+		const struct nvme_fabric_options *p)
 {
 	return p->cntlid;
 }
 
-void nvme_fabric_options_set_concat(struct nvme_fabric_options *p, bool concat)
+__public void nvme_fabric_options_set_concat(
+		struct nvme_fabric_options *p,
+		bool concat)
 {
 	p->concat = concat;
 }
 
-bool nvme_fabric_options_get_concat(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_concat(
+		const struct nvme_fabric_options *p)
 {
 	return p->concat;
 }
 
-void nvme_fabric_options_set_ctrl_loss_tmo(
+__public void nvme_fabric_options_set_ctrl_loss_tmo(
 		struct nvme_fabric_options *p,
 		bool ctrl_loss_tmo)
 {
 	p->ctrl_loss_tmo = ctrl_loss_tmo;
 }
 
-bool nvme_fabric_options_get_ctrl_loss_tmo(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_ctrl_loss_tmo(
+		const struct nvme_fabric_options *p)
 {
 	return p->ctrl_loss_tmo;
 }
 
-void nvme_fabric_options_set_data_digest(
+__public void nvme_fabric_options_set_data_digest(
 		struct nvme_fabric_options *p,
 		bool data_digest)
 {
 	p->data_digest = data_digest;
 }
 
-bool nvme_fabric_options_get_data_digest(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_data_digest(
+		const struct nvme_fabric_options *p)
 {
 	return p->data_digest;
 }
 
-void nvme_fabric_options_set_dhchap_ctrl_secret(
+__public void nvme_fabric_options_set_dhchap_ctrl_secret(
 		struct nvme_fabric_options *p,
 		bool dhchap_ctrl_secret)
 {
 	p->dhchap_ctrl_secret = dhchap_ctrl_secret;
 }
 
-bool nvme_fabric_options_get_dhchap_ctrl_secret(
+__public bool nvme_fabric_options_get_dhchap_ctrl_secret(
 		const struct nvme_fabric_options *p)
 {
 	return p->dhchap_ctrl_secret;
 }
 
-void nvme_fabric_options_set_dhchap_secret(
+__public void nvme_fabric_options_set_dhchap_secret(
 		struct nvme_fabric_options *p,
 		bool dhchap_secret)
 {
 	p->dhchap_secret = dhchap_secret;
 }
 
-bool nvme_fabric_options_get_dhchap_secret(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_dhchap_secret(
+		const struct nvme_fabric_options *p)
 {
 	return p->dhchap_secret;
 }
 
-void nvme_fabric_options_set_disable_sqflow(
+__public void nvme_fabric_options_set_disable_sqflow(
 		struct nvme_fabric_options *p,
 		bool disable_sqflow)
 {
 	p->disable_sqflow = disable_sqflow;
 }
 
-bool nvme_fabric_options_get_disable_sqflow(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_disable_sqflow(
+		const struct nvme_fabric_options *p)
 {
 	return p->disable_sqflow;
 }
 
-void nvme_fabric_options_set_discovery(
+__public void nvme_fabric_options_set_discovery(
 		struct nvme_fabric_options *p,
 		bool discovery)
 {
 	p->discovery = discovery;
 }
 
-bool nvme_fabric_options_get_discovery(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_discovery(
+		const struct nvme_fabric_options *p)
 {
 	return p->discovery;
 }
 
-void nvme_fabric_options_set_duplicate_connect(
+__public void nvme_fabric_options_set_duplicate_connect(
 		struct nvme_fabric_options *p,
 		bool duplicate_connect)
 {
 	p->duplicate_connect = duplicate_connect;
 }
 
-bool nvme_fabric_options_get_duplicate_connect(
+__public bool nvme_fabric_options_get_duplicate_connect(
 		const struct nvme_fabric_options *p)
 {
 	return p->duplicate_connect;
 }
 
-void nvme_fabric_options_set_fast_io_fail_tmo(
+__public void nvme_fabric_options_set_fast_io_fail_tmo(
 		struct nvme_fabric_options *p,
 		bool fast_io_fail_tmo)
 {
 	p->fast_io_fail_tmo = fast_io_fail_tmo;
 }
 
-bool nvme_fabric_options_get_fast_io_fail_tmo(
+__public bool nvme_fabric_options_get_fast_io_fail_tmo(
 		const struct nvme_fabric_options *p)
 {
 	return p->fast_io_fail_tmo;
 }
 
-void nvme_fabric_options_set_hdr_digest(
+__public void nvme_fabric_options_set_hdr_digest(
 		struct nvme_fabric_options *p,
 		bool hdr_digest)
 {
 	p->hdr_digest = hdr_digest;
 }
 
-bool nvme_fabric_options_get_hdr_digest(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_hdr_digest(
+		const struct nvme_fabric_options *p)
 {
 	return p->hdr_digest;
 }
 
-void nvme_fabric_options_set_host_iface(
+__public void nvme_fabric_options_set_host_iface(
 		struct nvme_fabric_options *p,
 		bool host_iface)
 {
 	p->host_iface = host_iface;
 }
 
-bool nvme_fabric_options_get_host_iface(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_host_iface(
+		const struct nvme_fabric_options *p)
 {
 	return p->host_iface;
 }
 
-void nvme_fabric_options_set_host_traddr(
+__public void nvme_fabric_options_set_host_traddr(
 		struct nvme_fabric_options *p,
 		bool host_traddr)
 {
 	p->host_traddr = host_traddr;
 }
 
-bool nvme_fabric_options_get_host_traddr(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_host_traddr(
+		const struct nvme_fabric_options *p)
 {
 	return p->host_traddr;
 }
 
-void nvme_fabric_options_set_hostid(struct nvme_fabric_options *p, bool hostid)
+__public void nvme_fabric_options_set_hostid(
+		struct nvme_fabric_options *p,
+		bool hostid)
 {
 	p->hostid = hostid;
 }
 
-bool nvme_fabric_options_get_hostid(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_hostid(
+		const struct nvme_fabric_options *p)
 {
 	return p->hostid;
 }
 
-void nvme_fabric_options_set_hostnqn(
+__public void nvme_fabric_options_set_hostnqn(
 		struct nvme_fabric_options *p,
 		bool hostnqn)
 {
 	p->hostnqn = hostnqn;
 }
 
-bool nvme_fabric_options_get_hostnqn(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_hostnqn(
+		const struct nvme_fabric_options *p)
 {
 	return p->hostnqn;
 }
 
-void nvme_fabric_options_set_instance(
+__public void nvme_fabric_options_set_instance(
 		struct nvme_fabric_options *p,
 		bool instance)
 {
 	p->instance = instance;
 }
 
-bool nvme_fabric_options_get_instance(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_instance(
+		const struct nvme_fabric_options *p)
 {
 	return p->instance;
 }
 
-void nvme_fabric_options_set_keep_alive_tmo(
+__public void nvme_fabric_options_set_keep_alive_tmo(
 		struct nvme_fabric_options *p,
 		bool keep_alive_tmo)
 {
 	p->keep_alive_tmo = keep_alive_tmo;
 }
 
-bool nvme_fabric_options_get_keep_alive_tmo(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_keep_alive_tmo(
+		const struct nvme_fabric_options *p)
 {
 	return p->keep_alive_tmo;
 }
 
-void nvme_fabric_options_set_keyring(
+__public void nvme_fabric_options_set_keyring(
 		struct nvme_fabric_options *p,
 		bool keyring)
 {
 	p->keyring = keyring;
 }
 
-bool nvme_fabric_options_get_keyring(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_keyring(
+		const struct nvme_fabric_options *p)
 {
 	return p->keyring;
 }
 
-void nvme_fabric_options_set_nqn(struct nvme_fabric_options *p, bool nqn)
+__public void nvme_fabric_options_set_nqn(
+		struct nvme_fabric_options *p,
+		bool nqn)
 {
 	p->nqn = nqn;
 }
 
-bool nvme_fabric_options_get_nqn(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_nqn(const struct nvme_fabric_options *p)
 {
 	return p->nqn;
 }
 
-void nvme_fabric_options_set_nr_io_queues(
+__public void nvme_fabric_options_set_nr_io_queues(
 		struct nvme_fabric_options *p,
 		bool nr_io_queues)
 {
 	p->nr_io_queues = nr_io_queues;
 }
 
-bool nvme_fabric_options_get_nr_io_queues(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_nr_io_queues(
+		const struct nvme_fabric_options *p)
 {
 	return p->nr_io_queues;
 }
 
-void nvme_fabric_options_set_nr_poll_queues(
+__public void nvme_fabric_options_set_nr_poll_queues(
 		struct nvme_fabric_options *p,
 		bool nr_poll_queues)
 {
 	p->nr_poll_queues = nr_poll_queues;
 }
 
-bool nvme_fabric_options_get_nr_poll_queues(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_nr_poll_queues(
+		const struct nvme_fabric_options *p)
 {
 	return p->nr_poll_queues;
 }
 
-void nvme_fabric_options_set_nr_write_queues(
+__public void nvme_fabric_options_set_nr_write_queues(
 		struct nvme_fabric_options *p,
 		bool nr_write_queues)
 {
 	p->nr_write_queues = nr_write_queues;
 }
 
-bool nvme_fabric_options_get_nr_write_queues(
+__public bool nvme_fabric_options_get_nr_write_queues(
 		const struct nvme_fabric_options *p)
 {
 	return p->nr_write_queues;
 }
 
-void nvme_fabric_options_set_queue_size(
+__public void nvme_fabric_options_set_queue_size(
 		struct nvme_fabric_options *p,
 		bool queue_size)
 {
 	p->queue_size = queue_size;
 }
 
-bool nvme_fabric_options_get_queue_size(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_queue_size(
+		const struct nvme_fabric_options *p)
 {
 	return p->queue_size;
 }
 
-void nvme_fabric_options_set_reconnect_delay(
+__public void nvme_fabric_options_set_reconnect_delay(
 		struct nvme_fabric_options *p,
 		bool reconnect_delay)
 {
 	p->reconnect_delay = reconnect_delay;
 }
 
-bool nvme_fabric_options_get_reconnect_delay(
+__public bool nvme_fabric_options_get_reconnect_delay(
 		const struct nvme_fabric_options *p)
 {
 	return p->reconnect_delay;
 }
 
-void nvme_fabric_options_set_tls(struct nvme_fabric_options *p, bool tls)
+__public void nvme_fabric_options_set_tls(
+		struct nvme_fabric_options *p,
+		bool tls)
 {
 	p->tls = tls;
 }
 
-bool nvme_fabric_options_get_tls(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_tls(const struct nvme_fabric_options *p)
 {
 	return p->tls;
 }
 
-void nvme_fabric_options_set_tls_key(
+__public void nvme_fabric_options_set_tls_key(
 		struct nvme_fabric_options *p,
 		bool tls_key)
 {
 	p->tls_key = tls_key;
 }
 
-bool nvme_fabric_options_get_tls_key(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_tls_key(
+		const struct nvme_fabric_options *p)
 {
 	return p->tls_key;
 }
 
-void nvme_fabric_options_set_tos(struct nvme_fabric_options *p, bool tos)
+__public void nvme_fabric_options_set_tos(
+		struct nvme_fabric_options *p,
+		bool tos)
 {
 	p->tos = tos;
 }
 
-bool nvme_fabric_options_get_tos(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_tos(const struct nvme_fabric_options *p)
 {
 	return p->tos;
 }
 
-void nvme_fabric_options_set_traddr(struct nvme_fabric_options *p, bool traddr)
+__public void nvme_fabric_options_set_traddr(
+		struct nvme_fabric_options *p,
+		bool traddr)
 {
 	p->traddr = traddr;
 }
 
-bool nvme_fabric_options_get_traddr(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_traddr(
+		const struct nvme_fabric_options *p)
 {
 	return p->traddr;
 }
 
-void nvme_fabric_options_set_transport(
+__public void nvme_fabric_options_set_transport(
 		struct nvme_fabric_options *p,
 		bool transport)
 {
 	p->transport = transport;
 }
 
-bool nvme_fabric_options_get_transport(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_transport(
+		const struct nvme_fabric_options *p)
 {
 	return p->transport;
 }
 
-void nvme_fabric_options_set_trsvcid(
+__public void nvme_fabric_options_set_trsvcid(
 		struct nvme_fabric_options *p,
 		bool trsvcid)
 {
 	p->trsvcid = trsvcid;
 }
 
-bool nvme_fabric_options_get_trsvcid(const struct nvme_fabric_options *p)
+__public bool nvme_fabric_options_get_trsvcid(
+		const struct nvme_fabric_options *p)
 {
 	return p->trsvcid;
 }
diff --git a/libnvme/src/nvme/cmds.c b/libnvme/src/nvme/cmds.c
index 3ef8523bfb..d5de75ca5d 100644
--- a/libnvme/src/nvme/cmds.c
+++ b/libnvme/src/nvme/cmds.c
@@ -14,6 +14,7 @@
 
 #include "cleanup.h"
 #include "private.h"
+#include "compiler_attributes.h"
 
 static bool force_4k;
 
@@ -31,7 +32,7 @@ static void nvme_init_env(void)
 		force_4k = true;
 }
 
-int nvme_get_log(struct nvme_transport_handle *hdl,
+__public int nvme_get_log(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd, bool rae,
 		__u32 xfer_len)
 {
@@ -175,7 +176,7 @@ static int try_read_ana(struct nvme_transport_handle *hdl,
 	return 0;
 }
 
-int nvme_get_ana_log_atomic(struct nvme_transport_handle *hdl,
+__public int nvme_get_ana_log_atomic(struct nvme_transport_handle *hdl,
 		bool rae, bool rgo, struct nvme_ana_log *log, __u32 *len,
 		unsigned int retries)
 {
@@ -231,7 +232,7 @@ int nvme_get_ana_log_atomic(struct nvme_transport_handle *hdl,
 	return -EAGAIN;
 }
 
-int nvme_set_etdas(struct nvme_transport_handle *hdl, bool *changed)
+__public int nvme_set_etdas(struct nvme_transport_handle *hdl, bool *changed)
 {
 	struct nvme_feat_host_behavior da4;
 	struct nvme_passthru_cmd cmd;
@@ -258,7 +259,7 @@ int nvme_set_etdas(struct nvme_transport_handle *hdl, bool *changed)
 	return 0;
 }
 
-int nvme_clear_etdas(struct nvme_transport_handle *hdl, bool *changed)
+__public int nvme_clear_etdas(struct nvme_transport_handle *hdl, bool *changed)
 {
 	struct nvme_feat_host_behavior da4;
 	struct nvme_passthru_cmd cmd;
@@ -284,7 +285,7 @@ int nvme_clear_etdas(struct nvme_transport_handle *hdl, bool *changed)
 	return 0;
 }
 
-int nvme_get_uuid_list(struct nvme_transport_handle *hdl,
+__public int nvme_get_uuid_list(struct nvme_transport_handle *hdl,
 		struct nvme_id_uuid_list *uuid_list)
 {
 	struct nvme_passthru_cmd cmd;
@@ -309,7 +310,7 @@ int nvme_get_uuid_list(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-int nvme_get_telemetry_max(struct nvme_transport_handle *hdl,
+__public int nvme_get_telemetry_max(struct nvme_transport_handle *hdl,
 		enum nvme_telemetry_da *da, size_t *data_tx)
 {
 	_cleanup_free_ struct nvme_id_ctrl *id_ctrl = NULL;
@@ -345,7 +346,7 @@ int nvme_get_telemetry_max(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-int nvme_get_telemetry_log(struct nvme_transport_handle *hdl, bool create,
+__public int nvme_get_telemetry_log(struct nvme_transport_handle *hdl, bool create,
 		bool ctrl, bool rae, size_t max_data_tx,
 		enum nvme_telemetry_da da, struct nvme_telemetry_log **buf,
 		size_t *size)
@@ -449,7 +450,7 @@ static int nvme_check_get_telemetry_log(struct nvme_transport_handle *hdl,
 }
 
 
-int nvme_get_ctrl_telemetry(struct nvme_transport_handle *hdl, bool rae,
+__public int nvme_get_ctrl_telemetry(struct nvme_transport_handle *hdl, bool rae,
 		struct nvme_telemetry_log **log,
 		enum nvme_telemetry_da da, size_t *size)
 {
@@ -457,7 +458,7 @@ int nvme_get_ctrl_telemetry(struct nvme_transport_handle *hdl, bool rae,
 		da, size);
 }
 
-int nvme_get_host_telemetry(struct nvme_transport_handle *hdl,
+__public int nvme_get_host_telemetry(struct nvme_transport_handle *hdl,
 		struct nvme_telemetry_log **log,
 		enum nvme_telemetry_da da, size_t *size)
 {
@@ -465,7 +466,7 @@ int nvme_get_host_telemetry(struct nvme_transport_handle *hdl,
 		da, size);
 }
 
-int nvme_get_new_host_telemetry(struct nvme_transport_handle *hdl,
+__public int nvme_get_new_host_telemetry(struct nvme_transport_handle *hdl,
 		struct nvme_telemetry_log **log,
 		enum nvme_telemetry_da da, size_t *size)
 {
@@ -519,7 +520,7 @@ int nvme_get_lba_status_log(struct nvme_transport_handle *hdl, bool rae,
 	return 0;
 }
 
-size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,
+__public size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,
 					 bool rgo)
 {
 	__u32 nanagrpid = le32_to_cpu(id_ctrl->nanagrpid);
@@ -529,7 +530,7 @@ size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,
 	return rgo ? size : size + le32_to_cpu(id_ctrl->mnan) * sizeof(__le32);
 }
 
-int nvme_get_ana_log_len(struct nvme_transport_handle *hdl, size_t *analen)
+__public int nvme_get_ana_log_len(struct nvme_transport_handle *hdl, size_t *analen)
 {
 	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
 	struct nvme_passthru_cmd cmd;
@@ -548,7 +549,7 @@ int nvme_get_ana_log_len(struct nvme_transport_handle *hdl, size_t *analen)
 	return 0;
 }
 
-int nvme_get_logical_block_size(struct nvme_transport_handle *hdl,
+__public int nvme_get_logical_block_size(struct nvme_transport_handle *hdl,
 		__u32 nsid, int *blksize)
 {
 	_cleanup_free_ struct nvme_id_ns *ns = NULL;
@@ -571,7 +572,7 @@ int nvme_get_logical_block_size(struct nvme_transport_handle *hdl,
 	return 0;
 }
 
-int nvme_get_feature_length(int fid, __u32 cdw11, enum nvme_data_tfr dir,
+__public int nvme_get_feature_length(int fid, __u32 cdw11, enum nvme_data_tfr dir,
 			     __u32 *len)
 {
 	switch (fid) {
@@ -644,7 +645,7 @@ int nvme_get_feature_length(int fid, __u32 cdw11, enum nvme_data_tfr dir,
 	return 0;
 }
 
-int nvme_get_directive_receive_length(enum nvme_directive_dtype dtype,
+__public int nvme_get_directive_receive_length(enum nvme_directive_dtype dtype,
 		enum nvme_directive_receive_doper doper, __u32 *len)
 {
 	switch (dtype) {
diff --git a/libnvme/src/nvme/compiler_attributes.h b/libnvme/src/nvme/compiler_attributes.h
new file mode 100644
index 0000000000..b0c800d162
--- /dev/null
+++ b/libnvme/src/nvme/compiler_attributes.h
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * This file is part of libnvme.
+ * Copyright (c) 2026, Dell Technologies Inc. or its subsidiaries.
+ *
+ * Authors: Martin Belanger <Martin.Belanger@dell.com>
+ */
+#pragma once
+
+/**
+ * __public - mark a symbol as part of the public API.
+ *
+ * When the library is built with -fvisibility=hidden all symbols are hidden
+ * by default.  Annotating a function with __public overrides that and makes
+ * the symbol visible in the shared library ABI.
+ */
+#define __public __attribute__((visibility("default")))
+
+/**
+ * __weak - Declares a symbol as "weak"
+ *
+ * A weak symbol provides a default implementation that can be
+ * replaced by another (strong) definition during linking. Useful for
+ * optional overrides and platform hooks.
+ */
+#define __weak __attribute__((weak))
diff --git a/libnvme/src/nvme/fabrics.c b/libnvme/src/nvme/fabrics.c
index c659b23ff6..3c668d1829 100644
--- a/libnvme/src/nvme/fabrics.c
+++ b/libnvme/src/nvme/fabrics.c
@@ -36,6 +36,7 @@
 
 #include "cleanup.h"
 #include "private.h"
+#include "compiler_attributes.h"
 
 const char *nvmf_dev = "/dev/nvme-fabrics";
 
@@ -68,7 +69,7 @@ const char * const trtypes[] = {
 	[NVMF_TRTYPE_LOOP]	= "loop",
 };
 
-const char *nvmf_trtype_str(__u8 trtype)
+__public const char *nvmf_trtype_str(__u8 trtype)
 {
 	return arg_str(trtypes, ARRAY_SIZE(trtypes), trtype);
 }
@@ -81,7 +82,7 @@ static const char * const adrfams[] = {
 	[NVMF_ADDR_FAMILY_FC]	= "fibre-channel",
 };
 
-const char *nvmf_adrfam_str(__u8 adrfam)
+__public const char *nvmf_adrfam_str(__u8 adrfam)
 {
 	return arg_str(adrfams, ARRAY_SIZE(adrfams), adrfam);
 }
@@ -92,7 +93,7 @@ static const char * const subtypes[] = {
 	[NVME_NQN_CURR]		= "current discovery subsystem",
 };
 
-const char *nvmf_subtype_str(__u8 subtype)
+__public const char *nvmf_subtype_str(__u8 subtype)
 {
 	return arg_str(subtypes, ARRAY_SIZE(subtypes), subtype);
 }
@@ -112,7 +113,7 @@ static const char * const treqs[] = {
 				"sq flow control disable supported",
 };
 
-const char *nvmf_treq_str(__u8 treq)
+__public const char *nvmf_treq_str(__u8 treq)
 {
 	return arg_str(treqs, ARRAY_SIZE(treqs), treq);
 }
@@ -138,7 +139,7 @@ static const char * const eflags_strings[] = {
 					  "no cdc connectivity",
 };
 
-const char *nvmf_eflags_str(__u16 eflags)
+__public const char *nvmf_eflags_str(__u16 eflags)
 {
 	return arg_str(eflags_strings, ARRAY_SIZE(eflags_strings), eflags);
 }
@@ -149,7 +150,7 @@ static const char * const sectypes[] = {
 	[NVMF_TCP_SECTYPE_TLS13]	= "tls13",
 };
 
-const char *nvmf_sectype_str(__u8 sectype)
+__public const char *nvmf_sectype_str(__u8 sectype)
 {
 	return arg_str(sectypes, ARRAY_SIZE(sectypes), sectype);
 }
@@ -162,7 +163,7 @@ static const char * const prtypes[] = {
 	[NVMF_RDMA_PRTYPE_IWARP]		= "iwarp",
 };
 
-const char *nvmf_prtype_str(__u8 prtype)
+__public const char *nvmf_prtype_str(__u8 prtype)
 {
 	return arg_str(prtypes, ARRAY_SIZE(prtypes), prtype);
 }
@@ -172,7 +173,7 @@ static const char * const qptypes[] = {
 	[NVMF_RDMA_QPTYPE_DATAGRAM]	= "datagram",
 };
 
-const char *nvmf_qptype_str(__u8 qptype)
+__public const char *nvmf_qptype_str(__u8 qptype)
 {
 	return arg_str(qptypes, ARRAY_SIZE(qptypes), qptype);
 }
@@ -181,12 +182,12 @@ static const char * const cms[] = {
 	[NVMF_RDMA_CMS_RDMA_CM]	= "rdma-cm",
 };
 
-const char *nvmf_cms_str(__u8 cm)
+__public const char *nvmf_cms_str(__u8 cm)
 {
 	return arg_str(cms, ARRAY_SIZE(cms), cm);
 }
 
-int nvmf_context_create(struct nvme_global_ctx *ctx,
+__public int nvmf_context_create(struct nvme_global_ctx *ctx,
 		bool (*decide_retry)(struct nvmf_context *fctx, int err,
 			void *user_data),
 		void (*connected)(struct nvmf_context *fctx,
@@ -213,7 +214,7 @@ int nvmf_context_create(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvmf_context_set_discovery_cbs(struct nvmf_context *fctx,
+__public int nvmf_context_set_discovery_cbs(struct nvmf_context *fctx,
 		void (*discovery_log)(struct nvmf_context *fctx,
 			bool connect,
 			struct nvmf_discovery_log *log,
@@ -233,7 +234,7 @@ int nvmf_context_set_discovery_cbs(struct nvmf_context *fctx,
 	return 0;
 }
 
-int nvmf_context_set_discovery_defaults(struct nvmf_context *fctx,
+__public int nvmf_context_set_discovery_defaults(struct nvmf_context *fctx,
 		int max_discovery_retries, int keep_alive_timeout)
 {
 	fctx->default_max_discovery_retries = max_discovery_retries;
@@ -242,7 +243,7 @@ int nvmf_context_set_discovery_defaults(struct nvmf_context *fctx,
 	return 0;
 }
 
-int nvmf_context_set_fabrics_config(struct nvmf_context *fctx,
+__public int nvmf_context_set_fabrics_config(struct nvmf_context *fctx,
 		struct nvme_fabrics_config *cfg)
 {
 	fctx->cfg = cfg;
@@ -250,7 +251,7 @@ int nvmf_context_set_fabrics_config(struct nvmf_context *fctx,
 	return 0;
 }
 
-int nvmf_context_set_connection(struct nvmf_context *fctx,
+__public int nvmf_context_set_connection(struct nvmf_context *fctx,
 		const char *subsysnqn, const char *transport,
 		const char *traddr, const char *trsvcid,
 		const char *host_traddr, const char *host_iface)
@@ -265,7 +266,7 @@ int nvmf_context_set_connection(struct nvmf_context *fctx,
 	return 0;
 }
 
-int nvmf_context_set_hostnqn(struct nvmf_context *fctx,
+__public int nvmf_context_set_hostnqn(struct nvmf_context *fctx,
 		const char *hostnqn, const char *hostid)
 {
 	fctx->hostnqn = hostnqn;
@@ -274,7 +275,7 @@ int nvmf_context_set_hostnqn(struct nvmf_context *fctx,
 	return 0;
 }
 
-int nvmf_context_set_crypto(struct nvmf_context *fctx,
+__public int nvmf_context_set_crypto(struct nvmf_context *fctx,
 		const char *hostkey, const char *ctrlkey,
 		const char *keyring, const char *tls_key,
 		const char *tls_key_identity)
@@ -288,14 +289,14 @@ int nvmf_context_set_crypto(struct nvmf_context *fctx,
 	return 0;
 }
 
-int nvmf_context_set_persistent(struct nvmf_context *fctx, bool persistent)
+__public int nvmf_context_set_persistent(struct nvmf_context *fctx, bool persistent)
 {
 	fctx->persistent = persistent;
 
 	return 0;
 }
 
-int nvmf_context_set_device(struct nvmf_context *fctx, const char *device)
+__public int nvmf_context_set_device(struct nvmf_context *fctx, const char *device)
 {
 	fctx->device = device;
 
@@ -364,7 +365,7 @@ static struct nvme_fabrics_config *merge_config(nvme_ctrl_t c,
 
 #define UPDATE_CFG_OPTION(c, n, o, d)			\
 	if ((n)->o != d) (c)->o = (n)->o
-void nvmf_update_config(nvme_ctrl_t c, const struct nvme_fabrics_config *cfg)
+__public void nvmf_update_config(nvme_ctrl_t c, const struct nvme_fabrics_config *cfg)
 {
 	struct nvme_fabrics_config *ctrl_cfg = nvme_ctrl_get_config(c);
 
@@ -986,7 +987,7 @@ static const char *lookup_context(struct nvme_global_ctx *ctx, nvme_ctrl_t c)
 	return NULL;
 }
 
-int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
+__public int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
 		  const struct nvme_fabrics_config *cfg)
 {
 	nvme_subsystem_t s;
@@ -1080,7 +1081,7 @@ int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c,
 	return nvme_init_ctrl(h, c, ret);
 }
 
-int nvmf_connect_ctrl(nvme_ctrl_t c)
+__public int nvmf_connect_ctrl(nvme_ctrl_t c)
 {
 	_cleanup_free_ char *argstr = NULL;
 	int ret;
@@ -1349,7 +1350,7 @@ static void sanitize_discovery_log_entry(struct nvmf_disc_log_entry *e)
 	}
 }
 
-int nvmf_get_discovery_log(nvme_ctrl_t c, struct nvmf_discovery_log **logp,
+__public int nvmf_get_discovery_log(nvme_ctrl_t c, struct nvmf_discovery_log **logp,
 			   int max_retries)
 {
 	struct nvme_get_discovery_args args = {
@@ -1363,7 +1364,7 @@ int nvmf_get_discovery_log(nvme_ctrl_t c, struct nvmf_discovery_log **logp,
 	return nvmf_get_discovery_wargs(&args, logp);
 }
 
-int nvmf_get_discovery_wargs(struct nvme_get_discovery_args *args,
+__public int nvmf_get_discovery_wargs(struct nvme_get_discovery_args *args,
 			     struct nvmf_discovery_log **logp)
 {
 	struct nvmf_discovery_log *log;
@@ -1645,7 +1646,7 @@ static int nvme_fetch_cntrltype_dctype_from_id(nvme_ctrl_t c)
 	return 0;
 }
 
-bool nvmf_is_registration_supported(nvme_ctrl_t c)
+__public bool nvmf_is_registration_supported(nvme_ctrl_t c)
 {
 	if (!c->cntrltype || !c->dctype)
 		if (nvme_fetch_cntrltype_dctype_from_id(c))
@@ -1654,7 +1655,7 @@ bool nvmf_is_registration_supported(nvme_ctrl_t c)
 	return !strcmp(c->dctype, "ddc") || !strcmp(c->dctype, "cdc");
 }
 
-int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result)
+__public int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result)
 {
 	if (!nvmf_is_registration_supported(c))
 		return -ENOTSUP;
@@ -1695,7 +1696,7 @@ static char *unescape_uri(const char *str, int len)
 	return dst;
 }
 
-int nvme_parse_uri(const char *str, struct nvme_fabrics_uri **urip)
+__public int nvme_parse_uri(const char *str, struct nvme_fabrics_uri **urip)
 {
 	struct nvme_fabrics_uri *uri;
 	_cleanup_free_ char *scheme = NULL;
@@ -1792,7 +1793,7 @@ int nvme_parse_uri(const char *str, struct nvme_fabrics_uri **urip)
 	return 0;
 }
 
-void nvmf_free_uri(struct nvme_fabrics_uri *uri)
+__public void nvmf_free_uri(struct nvme_fabrics_uri *uri)
 {
 	char **s;
 
@@ -2028,7 +2029,7 @@ static int _nvmf_discovery(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-const char *nvmf_get_default_trsvcid(const char *transport,
+__public const char *nvmf_get_default_trsvcid(const char *transport,
 		bool discovery_ctrl)
 {
 	if (!transport)
@@ -2255,7 +2256,7 @@ int _discovery_config_json(struct nvme_global_ctx *ctx,
 	return ret;
 }
 
-int nvmf_discovery_config_json(struct nvme_global_ctx *ctx,
+__public int nvmf_discovery_config_json(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, bool connect, bool force)
 {
 	const char *hnqn, *hid;
@@ -2303,7 +2304,7 @@ int nvmf_discovery_config_json(struct nvme_global_ctx *ctx,
 	return ret;
 }
 
-int nvmf_connect_config_json(struct nvme_global_ctx *ctx,
+__public int nvmf_connect_config_json(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx)
 {
 	const char *hnqn, *hid;
@@ -2362,7 +2363,7 @@ int nvmf_connect_config_json(struct nvme_global_ctx *ctx,
 	return ret;
 }
 
-int nvmf_discovery_config_file(struct nvme_global_ctx *ctx,
+__public int nvmf_discovery_config_file(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, bool connect, bool force)
 {
 	struct nvme_host *h;
@@ -2422,7 +2423,7 @@ int nvmf_discovery_config_file(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvmf_config_modify(struct nvme_global_ctx *ctx,
+__public int nvmf_config_modify(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx)
 {
 	_cleanup_free_ char *hnqn = NULL;
@@ -2479,7 +2480,7 @@ static int nbft_filter(const struct dirent *dent)
 	return !fnmatch(NBFT_SYSFS_FILENAME, dent->d_name, FNM_PATHNAME);
 }
 
-int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
+__public int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
 		struct nbft_file_entry **head)
 {
 	struct nbft_file_entry *entry = NULL;
@@ -2518,7 +2519,7 @@ int nvmf_nbft_read_files(struct nvme_global_ctx *ctx, char *path,
 	return 0;
 }
 
-void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
+__public void nvmf_nbft_free(struct nvme_global_ctx *ctx, struct nbft_file_entry *head)
 {
 	while (head) {
 		struct nbft_file_entry *next = head->next;
@@ -2725,7 +2726,7 @@ static int nbft_discovery(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
+__public int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 		struct nvmf_context *fctx, bool connect, char *nbft_path)
 {
 	const char *hostnqn = NULL, *hostid = NULL, *host_traddr = NULL;
@@ -2943,7 +2944,7 @@ int nvmf_discovery_nbft(struct nvme_global_ctx *ctx,
 	return ret;
 }
 
-int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
+__public int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
 		bool connect, bool force)
 {
 	struct nvme_ctrl *c = NULL;
@@ -3051,7 +3052,7 @@ int nvmf_discovery(struct nvme_global_ctx *ctx, struct nvmf_context *fctx,
 	return ret;
 }
 
-int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
+__public int nvmf_connect(struct nvme_global_ctx *ctx, struct nvmf_context *fctx)
 {
 	struct nvme_host *h;
 	struct nvme_ctrl *c;
diff --git a/libnvme/src/nvme/filters.c b/libnvme/src/nvme/filters.c
index a3fb4cbfc6..e960420821 100644
--- a/libnvme/src/nvme/filters.c
+++ b/libnvme/src/nvme/filters.c
@@ -13,8 +13,9 @@
 #include <libnvme.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
-int nvme_filter_namespace(const struct dirent *d)
+__public int nvme_filter_namespace(const struct dirent *d)
 {
 	int i, n;
 
@@ -28,7 +29,7 @@ int nvme_filter_namespace(const struct dirent *d)
 	return 0;
 }
 
-int nvme_filter_paths(const struct dirent *d)
+__public int nvme_filter_paths(const struct dirent *d)
 {
 	int i, c, n;
 
@@ -42,7 +43,7 @@ int nvme_filter_paths(const struct dirent *d)
 	return 0;
 }
 
-int nvme_filter_ctrls(const struct dirent *d)
+__public int nvme_filter_ctrls(const struct dirent *d)
 {
 	int i, c, n;
 
@@ -61,7 +62,7 @@ int nvme_filter_ctrls(const struct dirent *d)
 	return 0;
 }
 
-int nvme_filter_subsys(const struct dirent *d)
+__public int nvme_filter_subsys(const struct dirent *d)
 {
 	int i;
 
@@ -75,7 +76,7 @@ int nvme_filter_subsys(const struct dirent *d)
 	return 0;
 }
 
-int nvme_scan_subsystems(struct dirent ***subsys)
+__public int nvme_scan_subsystems(struct dirent ***subsys)
 {
 	const char *dir = nvme_subsys_sysfs_dir();
 	int ret;
@@ -87,7 +88,7 @@ int nvme_scan_subsystems(struct dirent ***subsys)
 	return ret;
 }
 
-int nvme_scan_subsystem_namespaces(nvme_subsystem_t s, struct dirent ***ns)
+__public int nvme_scan_subsystem_namespaces(nvme_subsystem_t s, struct dirent ***ns)
 {
 	int ret;
 
@@ -99,7 +100,7 @@ int nvme_scan_subsystem_namespaces(nvme_subsystem_t s, struct dirent ***ns)
 	return ret;
 }
 
-int nvme_scan_ctrls(struct dirent ***ctrls)
+__public int nvme_scan_ctrls(struct dirent ***ctrls)
 {
 	const char *dir = nvme_ctrl_sysfs_dir();
 	int ret;
@@ -111,7 +112,7 @@ int nvme_scan_ctrls(struct dirent ***ctrls)
 	return ret;
 }
 
-int nvme_scan_ctrl_namespace_paths(nvme_ctrl_t c, struct dirent ***paths)
+__public int nvme_scan_ctrl_namespace_paths(nvme_ctrl_t c, struct dirent ***paths)
 {
 	int ret;
 
@@ -123,7 +124,7 @@ int nvme_scan_ctrl_namespace_paths(nvme_ctrl_t c, struct dirent ***paths)
 	return ret;
 }
 
-int nvme_scan_ctrl_namespaces(nvme_ctrl_t c, struct dirent ***ns)
+__public int nvme_scan_ctrl_namespaces(nvme_ctrl_t c, struct dirent ***ns)
 {
 	int ret;
 
diff --git a/libnvme/src/nvme/ioctl.c b/libnvme/src/nvme/ioctl.c
index a742cd6304..85f401b940 100644
--- a/libnvme/src/nvme/ioctl.c
+++ b/libnvme/src/nvme/ioctl.c
@@ -23,6 +23,7 @@
 #include <libnvme.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 static int nvme_verify_chr(struct nvme_transport_handle *hdl)
 {
@@ -37,7 +38,7 @@ static int nvme_verify_chr(struct nvme_transport_handle *hdl)
 	return 0;
 }
 
-int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
+__public int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -51,7 +52,7 @@ int nvme_reset_subsystem(struct nvme_transport_handle *hdl)
 	return ret;
 }
 
-int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
+__public int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -65,7 +66,7 @@ int nvme_reset_ctrl(struct nvme_transport_handle *hdl)
 	return ret;
 }
 
-int nvme_rescan_ns(struct nvme_transport_handle *hdl)
+__public int nvme_rescan_ns(struct nvme_transport_handle *hdl)
 {
 	int ret;
 
@@ -79,7 +80,7 @@ int nvme_rescan_ns(struct nvme_transport_handle *hdl)
 	return ret;
 }
 
-int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
+__public int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 {
 	__u32 tmp;
 
@@ -170,7 +171,7 @@ static int nvme_submit_passthru64(struct nvme_transport_handle *hdl,
 	return err;
 }
 
-int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
+__public int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd)
 {
 	if (hdl->ioctl_io64)
@@ -178,7 +179,7 @@ int nvme_submit_io_passthru(struct nvme_transport_handle *hdl,
 	return nvme_submit_passthru32(hdl, NVME_IOCTL_IO_CMD, cmd);
 }
 
-int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
+__public int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
 		struct nvme_passthru_cmd *cmd)
 {
 	switch (hdl->type) {
diff --git a/libnvme/src/nvme/lib.c b/libnvme/src/nvme/lib.c
index c9fdd2db64..2dd8a26452 100644
--- a/libnvme/src/nvme/lib.c
+++ b/libnvme/src/nvme/lib.c
@@ -17,6 +17,7 @@
 
 #include "cleanup.h"
 #include "private.h"
+#include "compiler_attributes.h"
 
 static bool nvme_mi_probe_enabled_default(void)
 {
@@ -32,7 +33,7 @@ static bool nvme_mi_probe_enabled_default(void)
 
 }
 
-struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
+__public struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
 {
 	struct nvme_global_ctx *ctx;
 	int fd;
@@ -62,7 +63,7 @@ struct nvme_global_ctx *nvme_create_global_ctx(FILE *fp, int log_level)
 	return ctx;
 }
 
-void nvme_free_global_ctx(struct nvme_global_ctx *ctx)
+__public void nvme_free_global_ctx(struct nvme_global_ctx *ctx)
 {
 	struct nvme_host *h, *_h;
 	nvme_mi_ep_t ep, tmp;
@@ -84,17 +85,17 @@ void nvme_free_global_ctx(struct nvme_global_ctx *ctx)
 	free(ctx);
 }
 
-void nvme_set_dry_run(struct nvme_global_ctx *ctx, bool enable)
+__public void nvme_set_dry_run(struct nvme_global_ctx *ctx, bool enable)
 {
 	ctx->dry_run = enable;
 }
 
-void nvme_set_ioctl_probing(struct nvme_global_ctx *ctx, bool enable)
+__public void nvme_set_ioctl_probing(struct nvme_global_ctx *ctx, bool enable)
 {
 	ctx->ioctl_probing = enable;
 }
 
-void nvme_transport_handle_set_submit_entry(struct nvme_transport_handle *hdl,
+__public void nvme_transport_handle_set_submit_entry(struct nvme_transport_handle *hdl,
 		void *(*submit_entry)(struct nvme_transport_handle *hdl,
 				struct nvme_passthru_cmd *cmd))
 {
@@ -103,7 +104,7 @@ void nvme_transport_handle_set_submit_entry(struct nvme_transport_handle *hdl,
 		hdl->submit_exit = __nvme_submit_exit;
 }
 
-void nvme_transport_handle_set_submit_exit(struct nvme_transport_handle *hdl,
+__public void nvme_transport_handle_set_submit_exit(struct nvme_transport_handle *hdl,
 		void (*submit_exit)(struct nvme_transport_handle *hdl,
 				struct nvme_passthru_cmd *cmd,
 				int err, void *user_data))
@@ -113,7 +114,7 @@ void nvme_transport_handle_set_submit_exit(struct nvme_transport_handle *hdl,
 		hdl->submit_exit = __nvme_submit_exit;
 }
 
-void nvme_transport_handle_set_decide_retry(struct nvme_transport_handle *hdl,
+__public void nvme_transport_handle_set_decide_retry(struct nvme_transport_handle *hdl,
 		bool (*decide_retry)(struct nvme_transport_handle *hdl,
 				struct nvme_passthru_cmd *cmd, int err))
 {
@@ -201,7 +202,7 @@ struct nvme_transport_handle *__nvme_create_transport_handle(
 	return hdl;
 }
 
-int nvme_open(struct nvme_global_ctx *ctx, const char *name,
+__public int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 	      struct nvme_transport_handle **hdlp)
 {
 	struct nvme_transport_handle *hdl;
@@ -243,7 +244,7 @@ int nvme_open(struct nvme_global_ctx *ctx, const char *name,
 	return 0;
 }
 
-void nvme_close(struct nvme_transport_handle *hdl)
+__public void nvme_close(struct nvme_transport_handle *hdl)
 {
 	if (!hdl)
 		return;
@@ -263,32 +264,32 @@ void nvme_close(struct nvme_transport_handle *hdl)
 	}
 }
 
-int nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
+__public int nvme_transport_handle_get_fd(struct nvme_transport_handle *hdl)
 {
 	return hdl->fd;
 }
 
-const char *nvme_transport_handle_get_name(struct nvme_transport_handle *hdl)
+__public const char *nvme_transport_handle_get_name(struct nvme_transport_handle *hdl)
 {
 	return basename(hdl->name);
 }
 
-bool nvme_transport_handle_is_blkdev(struct nvme_transport_handle *hdl)
+__public bool nvme_transport_handle_is_blkdev(struct nvme_transport_handle *hdl)
 {
 	return S_ISBLK(hdl->stat.st_mode);
 }
 
-bool nvme_transport_handle_is_chardev(struct nvme_transport_handle *hdl)
+__public bool nvme_transport_handle_is_chardev(struct nvme_transport_handle *hdl)
 {
 	return S_ISCHR(hdl->stat.st_mode);
 }
 
-bool nvme_transport_handle_is_direct(struct nvme_transport_handle *hdl)
+__public bool nvme_transport_handle_is_direct(struct nvme_transport_handle *hdl)
 {
 	return hdl->type == NVME_TRANSPORT_HANDLE_TYPE_DIRECT;
 }
 
-bool nvme_transport_handle_is_mi(struct nvme_transport_handle *hdl)
+__public bool nvme_transport_handle_is_mi(struct nvme_transport_handle *hdl)
 {
 	return hdl->type == NVME_TRANSPORT_HANDLE_TYPE_MI;
 }
diff --git a/libnvme/src/nvme/linux.c b/libnvme/src/nvme/linux.c
index 6f58507af9..f8913e7ea8 100644
--- a/libnvme/src/nvme/linux.c
+++ b/libnvme/src/nvme/linux.c
@@ -47,6 +47,7 @@
 #include "base64.h"
 #include "cleanup.h"
 #include "private.h"
+#include "compiler_attributes.h"
 
 #define NVMF_HOSTID_SIZE	37
 
@@ -109,7 +110,7 @@ static char *__nvme_get_attr(const char *path)
 	return strlen(value) ? strdup(value) : NULL;
 }
 
-char *nvme_get_attr(const char *dir, const char *attr)
+__public char *nvme_get_attr(const char *dir, const char *attr)
 {
 	_cleanup_free_ char *path = NULL;
 	int ret;
@@ -121,22 +122,22 @@ char *nvme_get_attr(const char *dir, const char *attr)
 	return __nvme_get_attr(path);
 }
 
-char *nvme_get_subsys_attr(nvme_subsystem_t s, const char *attr)
+__public char *nvme_get_subsys_attr(nvme_subsystem_t s, const char *attr)
 {
 	return nvme_get_attr(nvme_subsystem_get_sysfs_dir(s), attr);
 }
 
-char *nvme_get_ctrl_attr(nvme_ctrl_t c, const char *attr)
+__public char *nvme_get_ctrl_attr(nvme_ctrl_t c, const char *attr)
 {
 	return nvme_get_attr(nvme_ctrl_get_sysfs_dir(c), attr);
 }
 
-char *nvme_get_ns_attr(nvme_ns_t n, const char *attr)
+__public char *nvme_get_ns_attr(nvme_ns_t n, const char *attr)
 {
 	return nvme_get_attr(nvme_ns_get_sysfs_dir(n), attr);
 }
 
-char *nvme_get_path_attr(nvme_path_t p, const char *attr)
+__public char *nvme_get_path_attr(nvme_path_t p, const char *attr)
 {
 	return nvme_get_attr(nvme_path_get_sysfs_dir(p), attr);
 }
@@ -147,7 +148,7 @@ static unsigned char default_hmac(size_t key_len)
 	return NVME_HMAC_ALG_NONE;
 }
 
-int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
+__public int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
 		char *hostnqn, enum nvme_hmac_alg hmac,
 		unsigned int key_len, unsigned char *secret,
 		unsigned char *key)
@@ -592,7 +593,7 @@ static DEFINE_CLEANUP_FUNC(cleanup_evp_mac_ctx, EVP_MAC_CTX *, EVP_MAC_CTX_free)
 static DEFINE_CLEANUP_FUNC(cleanup_evp_mac, EVP_MAC *, EVP_MAC_free)
 #define _cleanup_evp_mac_ __cleanup__(cleanup_evp_mac)
 
-int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
+__public int nvme_gen_dhchap_key(struct nvme_global_ctx *ctx,
 		char *hostnqn, enum nvme_hmac_alg hmac,
 		unsigned int key_len, unsigned char *secret,
 		unsigned char *key)
@@ -840,7 +841,7 @@ static ssize_t nvme_identity_len(int hmac, int version, const char *hostnqn,
 	return len;
 }
 
-int nvme_generate_tls_key_identity(struct nvme_global_ctx *ctx,
+__public int nvme_generate_tls_key_identity(struct nvme_global_ctx *ctx,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
 		unsigned char *configured_key, int key_len,
@@ -878,7 +879,7 @@ int nvme_generate_tls_key_identity(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_generate_tls_key_identity_compat(struct nvme_global_ctx *ctx,
+__public int nvme_generate_tls_key_identity_compat(struct nvme_global_ctx *ctx,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac, unsigned char *configured_key,
 		int key_len, char **ident)
@@ -916,7 +917,7 @@ int nvme_generate_tls_key_identity_compat(struct nvme_global_ctx *ctx,
 }
 
 #ifdef CONFIG_KEYUTILS
-int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
+__public int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
 		long *key)
 {
 	key_serial_t keyring_id;
@@ -931,7 +932,7 @@ int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
 	return 0;
 }
 
-char *nvme_describe_key_serial(struct nvme_global_ctx *ctx, long key_id)
+__public char *nvme_describe_key_serial(struct nvme_global_ctx *ctx, long key_id)
 {
 	_cleanup_free_ char *str = NULL;
 	char *last;
@@ -950,7 +951,7 @@ char *nvme_describe_key_serial(struct nvme_global_ctx *ctx, long key_id)
 	return strdup(last);
 }
 
-int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
+__public int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
 		const char *identity, long *keyp)
 {
 	key_serial_t key;
@@ -961,7 +962,7 @@ int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
 	return key;
 }
 
-int nvme_set_keyring(struct nvme_global_ctx *ctx, long key_id)
+__public int nvme_set_keyring(struct nvme_global_ctx *ctx, long key_id)
 {
 	long err;
 
@@ -976,7 +977,7 @@ int nvme_set_keyring(struct nvme_global_ctx *ctx, long key_id)
 	return 0;
 }
 
-int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
+__public int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
 		long key_id, int *len, unsigned char **key)
 {
 	void *buffer;
@@ -995,7 +996,7 @@ int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
 	return 0;
 }
 
-int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
+__public int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
 		const char *key_type, const char *identity,
 		unsigned char *key_data, int key_len, long *keyp)
 {
@@ -1055,7 +1056,7 @@ int __scan_keys_cb(key_serial_t parent, key_serial_t key, char *desc,
 	return 1;
 }
 
-int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
+__public int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
 		nvme_scan_tls_keys_cb_t cb, void *data)
 {
 	struct __scan_keys_data d;
@@ -1123,7 +1124,7 @@ static int __nvme_insert_tls_key(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
+__public int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
@@ -1146,7 +1147,7 @@ int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
 		configured_key, key_len, false, key);
 }
 
-int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
+__public int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
@@ -1169,7 +1170,7 @@ int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
 		configured_key, key_len, true, key);
 }
 
-int nvme_revoke_tls_key(struct nvme_global_ctx *ctx,
+__public int nvme_revoke_tls_key(struct nvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *identity)
 {
@@ -1295,7 +1296,7 @@ int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
 	return 0;
 }
 #else
-int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
+__public int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
 		long *key)
 {
 	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
@@ -1303,14 +1304,14 @@ int nvme_lookup_keyring(struct nvme_global_ctx *ctx, const char *keyring,
 	return -ENOTSUP;
 }
 
-char *nvme_describe_key_serial(struct nvme_global_ctx *ctx, long key_id)
+__public char *nvme_describe_key_serial(struct nvme_global_ctx *ctx, long key_id)
 {
 	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return NULL;
 }
 
-int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
+__public int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
 		const char *identity, long *key)
 {
 	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
@@ -1318,14 +1319,14 @@ int nvme_lookup_key(struct nvme_global_ctx *ctx, const char *type,
 	return -ENOTSUP;
 }
 
-int nvme_set_keyring(struct nvme_global_ctx *ctx, long key_id)
+__public int nvme_set_keyring(struct nvme_global_ctx *ctx, long key_id)
 {
 	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
 		 "recompile with keyutils support.\n");
 	return -ENOTSUP;
 }
 
-int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
+__public int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
 		long key_id, int *len, unsigned char **key)
 {
 	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
@@ -1333,7 +1334,7 @@ int nvme_read_key(struct nvme_global_ctx *ctx, long keyring_id,
 	return -ENOTSUP;
 }
 
-int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
+__public int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
 		const char *key_type, const char *identity,
 		unsigned char *key_data, int key_len, long *key)
 {
@@ -1342,7 +1343,7 @@ int nvme_update_key(struct nvme_global_ctx *ctx, long keyring_id,
 	return -ENOTSUP;
 }
 
-int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
+__public int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
 		nvme_scan_tls_keys_cb_t cb, void *data)
 {
 	nvme_msg(ctx, LOG_ERR, "key operations not supported; "
@@ -1350,7 +1351,7 @@ int nvme_scan_tls_keys(struct nvme_global_ctx *ctx, const char *keyring,
 	return -ENOTSUP;
 }
 
-int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
+__public int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
@@ -1362,7 +1363,7 @@ int nvme_insert_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return -ENOTSUP;
 }
 
-int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
+__public int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *hostnqn, const char *subsysnqn,
 		int version, int hmac,
@@ -1374,7 +1375,7 @@ int nvme_insert_tls_key_compat(struct nvme_global_ctx *ctx,
 	return -ENOTSUP;
 }
 
-int nvme_revoke_tls_key(struct nvme_global_ctx *ctx,
+__public int nvme_revoke_tls_key(struct nvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *identity)
 {
@@ -1393,7 +1394,7 @@ int __nvme_import_keys_from_config(nvme_host_t h, nvme_ctrl_t c,
 }
 #endif
 
-int nvme_insert_tls_key(struct nvme_global_ctx *ctx,
+__public int nvme_insert_tls_key(struct nvme_global_ctx *ctx,
 		const char *keyring, const char *key_type,
 		const char *hostnqn, const char *subsysnqn, int hmac,
 		unsigned char *configured_key, int key_len, long *key)
@@ -1415,7 +1416,7 @@ int nvme_insert_tls_key(struct nvme_global_ctx *ctx,
  * s:  32 or 48 bytes binary followed by a CRC-32 of the configured PSK
  *     (4 bytes) encoded as base64
  */
-int nvme_export_tls_key_versioned(struct nvme_global_ctx *ctx,
+__public int nvme_export_tls_key_versioned(struct nvme_global_ctx *ctx,
 		unsigned char version, unsigned char hmac,
 		const unsigned char *key_data,
 		size_t key_len, char **encoded_keyp)
@@ -1465,7 +1466,7 @@ int nvme_export_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_export_tls_key(struct nvme_global_ctx *ctx,
+__public int nvme_export_tls_key(struct nvme_global_ctx *ctx,
 		const unsigned char *key_data, int key_len, char **key)
 {
 	unsigned char hmac;
@@ -1479,7 +1480,7 @@ int nvme_export_tls_key(struct nvme_global_ctx *ctx,
 		key_len, key);
 }
 
-int nvme_import_tls_key_versioned(struct nvme_global_ctx *ctx,
+__public int nvme_import_tls_key_versioned(struct nvme_global_ctx *ctx,
 		const char *encoded_key, unsigned char *version,
 		unsigned char *hmac, size_t *key_len,
 		unsigned char **keyp)
@@ -1548,7 +1549,7 @@ int nvme_import_tls_key_versioned(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
+__public int nvme_import_tls_key(struct nvme_global_ctx *ctx, const char *encoded_key,
 		int *key_len, unsigned int *hmac, unsigned char **keyp)
 {
 	unsigned char version, _hmac;
@@ -1723,7 +1724,7 @@ static int uuid_from_dmi(char *system_uuid)
 	return ret;
 }
 
-char *nvme_generate_hostid(void)
+__public char *nvme_generate_hostid(void)
 {
 	int ret;
 	char uuid_str[NVME_UUID_LEN_STRING];
@@ -1741,7 +1742,7 @@ char *nvme_generate_hostid(void)
 	return strdup(uuid_str);
 }
 
-char *nvme_generate_hostnqn_from_hostid(char *hostid)
+__public char *nvme_generate_hostnqn_from_hostid(char *hostid)
 {
 	char *hid = NULL;
 	char *hostnqn;
@@ -1756,7 +1757,7 @@ char *nvme_generate_hostnqn_from_hostid(char *hostid)
 	return (ret < 0) ? NULL : hostnqn;
 }
 
-char *nvme_generate_hostnqn(void)
+__public char *nvme_generate_hostnqn(void)
 {
 	return nvme_generate_hostnqn_from_hostid(NULL);
 }
@@ -1779,7 +1780,7 @@ static char *nvmf_read_file(const char *f, int len)
 	return strndup(buf, strcspn(buf, "\n"));
 }
 
-char *nvme_read_hostnqn(void)
+__public char *nvme_read_hostnqn(void)
 {
 	char *hostnqn = getenv("LIBNVME_HOSTNQN");
 
@@ -1792,7 +1793,7 @@ char *nvme_read_hostnqn(void)
 	return nvmf_read_file(NVMF_HOSTNQN_FILE, NVMF_NQN_SIZE);
 }
 
-char *nvme_read_hostid(void)
+__public char *nvme_read_hostid(void)
 {
 	char *hostid = getenv("LIBNVME_HOSTID");
 
diff --git a/libnvme/src/nvme/log.c b/libnvme/src/nvme/log.c
index 56187574ac..705217a069 100644
--- a/libnvme/src/nvme/log.c
+++ b/libnvme/src/nvme/log.c
@@ -20,6 +20,7 @@
 #include "cleanup.h"
 #define LOG_FUNCNAME 1
 #include "private.h"
+#include "compiler_attributes.h"
 
 #ifndef LOG_CLOCK
 #define LOG_CLOCK CLOCK_MONOTONIC
@@ -83,7 +84,7 @@ __nvme_msg(struct nvme_global_ctx *ctx, int level,
 		message ? message : "<error>");
 }
 
-void nvme_set_logging_level(struct nvme_global_ctx *ctx, int log_level,
+__public void nvme_set_logging_level(struct nvme_global_ctx *ctx, int log_level,
 		bool log_pid, bool log_tstamp)
 {
 	ctx->log.level = log_level;
@@ -91,7 +92,7 @@ void nvme_set_logging_level(struct nvme_global_ctx *ctx, int log_level,
 	ctx->log.timestamp = log_tstamp;
 }
 
-int nvme_get_logging_level(struct nvme_global_ctx *ctx,
+__public int nvme_get_logging_level(struct nvme_global_ctx *ctx,
 		bool *log_pid, bool *log_tstamp)
 {
 	if (log_pid)
diff --git a/libnvme/src/nvme/mi-mctp.c b/libnvme/src/nvme/mi-mctp.c
index b87b19c859..d8daff4620 100644
--- a/libnvme/src/nvme/mi-mctp.c
+++ b/libnvme/src/nvme/mi-mctp.c
@@ -39,6 +39,7 @@
 #include <libnvme-mi.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 
 #if !defined(AF_MCTP)
@@ -674,7 +675,7 @@ int nvme_mi_aem_open(nvme_mi_ep_t ep)
 	return 0;
 }
 
-nvme_mi_ep_t nvme_mi_open_mctp(struct nvme_global_ctx *ctx,
+__public nvme_mi_ep_t nvme_mi_open_mctp(struct nvme_global_ctx *ctx,
 			       unsigned int netid, __u8 eid)
 {
 	struct nvme_mi_transport_mctp *mctp;
@@ -944,7 +945,7 @@ static int handle_mctp_obj(struct nvme_global_ctx *ctx, DBusMessageIter *obj)
 	return 0;
 }
 
-struct nvme_global_ctx *nvme_mi_scan_mctp(void)
+__public struct nvme_global_ctx *nvme_mi_scan_mctp(void)
 {
 	DBusMessage *msg, *resp = NULL;
 	DBusConnection *bus = NULL;
@@ -1038,7 +1039,7 @@ struct nvme_global_ctx *nvme_mi_scan_mctp(void)
 
 #else /* CONFIG_DBUS */
 
-struct nvme_global_ctx *nvme_mi_scan_mctp(void)
+__public struct nvme_global_ctx *nvme_mi_scan_mctp(void)
 {
 	return NULL;
 }
diff --git a/libnvme/src/nvme/mi.c b/libnvme/src/nvme/mi.c
index f023428e67..9897c655aa 100644
--- a/libnvme/src/nvme/mi.c
+++ b/libnvme/src/nvme/mi.c
@@ -20,6 +20,7 @@
 #include <libnvme-mi.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 #define NUM_ENABLES    (256u)
 
@@ -296,7 +297,7 @@ struct nvme_mi_ep *nvme_mi_init_ep(struct nvme_global_ctx *ctx)
 	return ep;
 }
 
-int nvme_mi_ep_set_timeout(nvme_mi_ep_t ep, unsigned int timeout_ms)
+__public int nvme_mi_ep_set_timeout(nvme_mi_ep_t ep, unsigned int timeout_ms)
 {
 	if (ep->transport->check_timeout) {
 		int rc;
@@ -314,7 +315,7 @@ void nvme_mi_ep_set_mprt_max(nvme_mi_ep_t ep, unsigned int mprt_max_ms)
 	ep->mprt_max = mprt_max_ms;
 }
 
-unsigned int nvme_mi_ep_get_timeout(nvme_mi_ep_t ep)
+__public unsigned int nvme_mi_ep_get_timeout(nvme_mi_ep_t ep)
 {
 	return ep->timeout;
 }
@@ -324,7 +325,7 @@ static bool nvme_mi_ep_has_quirk(nvme_mi_ep_t ep, unsigned long quirk)
 	return ep->quirks & quirk;
 }
 
-struct nvme_transport_handle *nvme_mi_init_transport_handle(nvme_mi_ep_t ep, __u16 ctrl_id)
+__public struct nvme_transport_handle *nvme_mi_init_transport_handle(nvme_mi_ep_t ep, __u16 ctrl_id)
 {
 	struct nvme_transport_handle *hdl;
 
@@ -342,12 +343,12 @@ struct nvme_transport_handle *nvme_mi_init_transport_handle(nvme_mi_ep_t ep, __u
 	return hdl;
 }
 
-__u16 nvme_mi_ctrl_id(struct nvme_transport_handle *hdl)
+__public __u16 nvme_mi_ctrl_id(struct nvme_transport_handle *hdl)
 {
 	return hdl->id;
 }
 
-int nvme_mi_scan_ep(nvme_mi_ep_t ep, bool force_rescan)
+__public int nvme_mi_scan_ep(nvme_mi_ep_t ep, bool force_rescan)
 {
 	struct nvme_ctrl_list list;
 	unsigned int i, n_ctrl;
@@ -420,15 +421,15 @@ static int nvme_mi_verify_resp_mic(struct nvme_mi_resp *resp)
 	return resp->mic != ~crc;
 }
 
-__attribute__((weak)) void *nvme_mi_submit_entry(__u8 type, const struct nvme_mi_msg_hdr *hdr,
-						 size_t hdr_len, const void *data, size_t data_len)
+__public __weak void *nvme_mi_submit_entry(__u8 type, const struct nvme_mi_msg_hdr *hdr,
+					   size_t hdr_len, const void *data, size_t data_len)
 {
 	return NULL;
 }
 
-__attribute__((weak)) void nvme_mi_submit_exit(__u8 type, const struct nvme_mi_msg_hdr *hdr,
-					       size_t hdr_len, const void *data, size_t data_len,
-					       void *user_data) { }
+__public __weak void nvme_mi_submit_exit(__u8 type, const struct nvme_mi_msg_hdr *hdr,
+					 size_t hdr_len, const void *data, size_t data_len,
+					 void *user_data) { }
 
 
 int nvme_mi_async_read(nvme_mi_ep_t ep, struct nvme_mi_resp *resp)
@@ -568,7 +569,7 @@ int nvme_mi_submit(nvme_mi_ep_t ep, struct nvme_mi_req *req,
 	return 0;
 }
 
-int nvme_mi_set_csi(nvme_mi_ep_t ep, uint8_t csi)
+__public int nvme_mi_set_csi(nvme_mi_ep_t ep, uint8_t csi)
 {
 	uint8_t csi_bit = (csi) ? 1 : 0;
 
@@ -721,7 +722,7 @@ static int nvme_mi_get_async_message(nvme_mi_ep_t ep,
 }
 
 
-int nvme_mi_admin_xfer(struct nvme_transport_handle *hdl,
+__public int nvme_mi_admin_xfer(struct nvme_transport_handle *hdl,
 		       struct nvme_mi_admin_req_hdr *admin_req,
 		       size_t req_data_size,
 		       struct nvme_mi_admin_resp_hdr *admin_resp,
@@ -887,7 +888,7 @@ int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
 	return 0;
 }
 
-int nvme_mi_control(nvme_mi_ep_t ep, __u8 opcode,
+__public int nvme_mi_control(nvme_mi_ep_t ep, __u8 opcode,
 		    __u16 cpsp, __u16 *result_cpsr)
 {
 	struct nvme_mi_control_resp control_resp;
@@ -959,7 +960,7 @@ static int nvme_mi_read_data(nvme_mi_ep_t ep, __u32 cdw0,
 	return 0;
 }
 
-int nvme_mi_mi_xfer(nvme_mi_ep_t ep,
+__public int nvme_mi_mi_xfer(nvme_mi_ep_t ep,
 		       struct nvme_mi_mi_req_hdr *mi_req,
 		       size_t req_data_size,
 		       struct nvme_mi_mi_resp_hdr *mi_resp,
@@ -1009,7 +1010,7 @@ int nvme_mi_mi_xfer(nvme_mi_ep_t ep,
 	return 0;
 }
 
-int nvme_mi_mi_read_mi_data_subsys(nvme_mi_ep_t ep,
+__public int nvme_mi_mi_read_mi_data_subsys(nvme_mi_ep_t ep,
 				   struct nvme_mi_read_nvm_ss_info *s)
 {
 	size_t len;
@@ -1034,7 +1035,7 @@ int nvme_mi_mi_read_mi_data_subsys(nvme_mi_ep_t ep,
 	return 0;
 }
 
-int nvme_mi_mi_read_mi_data_port(nvme_mi_ep_t ep, __u8 portid,
+__public int nvme_mi_mi_read_mi_data_port(nvme_mi_ep_t ep, __u8 portid,
 				 struct nvme_mi_read_port_info *p)
 {
 	size_t len;
@@ -1054,7 +1055,7 @@ int nvme_mi_mi_read_mi_data_port(nvme_mi_ep_t ep, __u8 portid,
 	return 0;
 }
 
-int nvme_mi_mi_read_mi_data_ctrl_list(nvme_mi_ep_t ep, __u8 start_ctrlid,
+__public int nvme_mi_mi_read_mi_data_ctrl_list(nvme_mi_ep_t ep, __u8 start_ctrlid,
 				       struct nvme_ctrl_list *list)
 {
 	size_t len;
@@ -1071,7 +1072,7 @@ int nvme_mi_mi_read_mi_data_ctrl_list(nvme_mi_ep_t ep, __u8 start_ctrlid,
 	return 0;
 }
 
-int nvme_mi_mi_read_mi_data_ctrl(nvme_mi_ep_t ep, __u16 ctrl_id,
+__public int nvme_mi_mi_read_mi_data_ctrl(nvme_mi_ep_t ep, __u16 ctrl_id,
 				       struct nvme_mi_read_ctrl_info *ctrl)
 {
 	size_t len;
@@ -1091,7 +1092,7 @@ int nvme_mi_mi_read_mi_data_ctrl(nvme_mi_ep_t ep, __u16 ctrl_id,
 	return 0;
 }
 
-int nvme_mi_mi_subsystem_health_status_poll(nvme_mi_ep_t ep, bool clear,
+__public int nvme_mi_mi_subsystem_health_status_poll(nvme_mi_ep_t ep, bool clear,
 					    struct nvme_mi_nvm_ss_health_status *sshs)
 {
 	struct nvme_mi_mi_resp_hdr resp_hdr;
@@ -1167,7 +1168,7 @@ int nvme_mi_mi_config_set_get_ex(nvme_mi_ep_t ep, __u8 opcode, __u32 dw0,
 	return 0;
 }
 
-int nvme_mi_mi_config_get(nvme_mi_ep_t ep, __u32 dw0, __u32 dw1,
+__public int nvme_mi_mi_config_get(nvme_mi_ep_t ep, __u32 dw0, __u32 dw1,
 			  __u32 *nmresp)
 {
 	size_t data_in_len = 0;
@@ -1183,7 +1184,7 @@ int nvme_mi_mi_config_get(nvme_mi_ep_t ep, __u32 dw0, __u32 dw1,
 					nmresp);
 }
 
-int nvme_mi_mi_config_set(nvme_mi_ep_t ep, __u32 dw0, __u32 dw1)
+__public int nvme_mi_mi_config_set(nvme_mi_ep_t ep, __u32 dw0, __u32 dw1)
 {
 	size_t data_in_len = 0;
 
@@ -1267,7 +1268,7 @@ int nvme_mi_mi_config_set_async_event(nvme_mi_ep_t ep,
 }
 
 
-void nvme_mi_close(nvme_mi_ep_t ep)
+__public void nvme_mi_close(nvme_mi_ep_t ep)
 {
 	struct nvme_transport_handle *hdl, *tmp;
 
@@ -1283,7 +1284,7 @@ void nvme_mi_close(nvme_mi_ep_t ep)
 	free(ep);
 }
 
-char *nvme_mi_endpoint_desc(nvme_mi_ep_t ep)
+__public char *nvme_mi_endpoint_desc(nvme_mi_ep_t ep)
 {
 	char tsbuf[101], *s = NULL;
 	size_t tslen;
@@ -1313,12 +1314,12 @@ char *nvme_mi_endpoint_desc(nvme_mi_ep_t ep)
 	return s;
 }
 
-nvme_mi_ep_t nvme_mi_first_endpoint(struct nvme_global_ctx *ctx)
+__public nvme_mi_ep_t nvme_mi_first_endpoint(struct nvme_global_ctx *ctx)
 {
 	return list_top(&ctx->endpoints, struct nvme_mi_ep, root_entry);
 }
 
-nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi_ep_t ep)
+__public nvme_mi_ep_t nvme_mi_next_endpoint(struct nvme_global_ctx *ctx, nvme_mi_ep_t ep)
 {
 	return ep ? list_next(&ctx->endpoints, ep, root_entry) : NULL;
 }
@@ -1357,7 +1358,7 @@ static const char *const mi_status[] = {
 
 /* kept in mi.c while we have a split libnvme/libnvme-mi; consider moving
  * to utils.c (with nvme_status_to_string) if we ever merge. */
-const char *nvme_mi_status_to_string(int status)
+__public const char *nvme_mi_status_to_string(int status)
 {
 	const char *s = "Unknown status";
 
@@ -1525,7 +1526,7 @@ static int validate_occ_list_update_ctx(
 	return err;
 }
 
-int nvme_mi_aem_get_fd(nvme_mi_ep_t ep)
+__public int nvme_mi_aem_get_fd(nvme_mi_ep_t ep)
 {
 	if (!ep || !ep->aem_ctx || !ep->transport || !ep->transport->aem_fd)
 		return -1;
@@ -1634,7 +1635,7 @@ static int aem_disable_enabled(nvme_mi_ep_t ep)
 	return rc;
 }
 
-int nvme_mi_aem_enable(nvme_mi_ep_t ep,
+__public int nvme_mi_aem_enable(nvme_mi_ep_t ep,
 	struct nvme_mi_aem_config *config,
 	void *userdata)
 {
@@ -1708,7 +1709,7 @@ int nvme_mi_aem_enable(nvme_mi_ep_t ep,
 	return rc;
 }
 
-int nvme_mi_aem_get_enabled(nvme_mi_ep_t ep,
+__public int nvme_mi_aem_get_enabled(nvme_mi_ep_t ep,
 	struct nvme_mi_aem_enabled_map *enabled_map)
 {
 	if (!ep || !enabled_map)
@@ -1749,7 +1750,7 @@ int nvme_mi_aem_get_enabled(nvme_mi_ep_t ep,
 	return rc;
 }
 
-int nvme_mi_aem_disable(nvme_mi_ep_t ep)
+__public int nvme_mi_aem_disable(nvme_mi_ep_t ep)
 {
 	if (!ep)
 		return -1;
@@ -1767,7 +1768,7 @@ int nvme_mi_aem_disable(nvme_mi_ep_t ep)
  *spec_info and vend_spec_info must be copied to persist as they will not be valid after
  *the aem_handler has returned.
  */
-struct nvme_mi_event *nvme_mi_aem_get_next_event(nvme_mi_ep_t ep)
+__public struct nvme_mi_event *nvme_mi_aem_get_next_event(nvme_mi_ep_t ep)
 {
 	if (!ep || !ep->aem_ctx ||
 		!ep->aem_ctx->list_current ||
@@ -1804,7 +1805,7 @@ struct nvme_mi_event *nvme_mi_aem_get_next_event(nvme_mi_ep_t ep)
 /* POLLIN has indicated events.  This function reads and processes them.
  * A callback will likely be invoked.
  */
-int nvme_mi_aem_process(nvme_mi_ep_t ep, void *userdata)
+__public int nvme_mi_aem_process(nvme_mi_ep_t ep, void *userdata)
 {
 	int rc = 0;
 	uint8_t response_buffer[4096];
diff --git a/libnvme/src/nvme/nbft.c b/libnvme/src/nvme/nbft.c
index 2baa4d4e52..c2b96804c5 100644
--- a/libnvme/src/nvme/nbft.c
+++ b/libnvme/src/nvme/nbft.c
@@ -17,6 +17,7 @@
 #include <libnvme.h>
 
 #include "private.h"
+#include "compiler_attributes.h"
 
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 
@@ -711,7 +712,7 @@ static int parse_raw_nbft(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
 	return 0;
 }
 
-void nvme_free_nbft(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
+__public void nvme_free_nbft(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
 {
 	struct nbft_info_hfi **hfi;
 	struct nbft_info_security **sec;
@@ -737,7 +738,7 @@ void nvme_free_nbft(struct nvme_global_ctx *ctx, struct nbft_info *nbft)
 	free(nbft);
 }
 
-int nvme_read_nbft(struct nvme_global_ctx *ctx, struct nbft_info **nbft,
+__public int nvme_read_nbft(struct nvme_global_ctx *ctx, struct nbft_info **nbft,
 		const char *filename)
 {
 	__u8 *raw_nbft = NULL;
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index d2f6728dff..0d836b436a 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -30,6 +30,7 @@
 #include "cleanup.h"
 #include "private.h"
 #include "util.h"
+#include "compiler_attributes.h"
 
 /**
  * struct candidate_args - Used to look for a controller matching these parameters
@@ -118,7 +119,7 @@ static char *nvme_hostid_from_hostnqn(const char *hostnqn)
 	return strdup(uuid + strlen("uuid:"));
 }
 
-int nvme_host_get_ids(struct nvme_global_ctx *ctx,
+__public int nvme_host_get_ids(struct nvme_global_ctx *ctx,
 		      const char *hostnqn_arg, const char *hostid_arg,
 		      char **hostnqn, char **hostid)
 {
@@ -188,7 +189,7 @@ int nvme_host_get_ids(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_get_host(struct nvme_global_ctx *ctx, const char *hostnqn,
+__public int nvme_get_host(struct nvme_global_ctx *ctx, const char *hostnqn,
 		const char *hostid, nvme_host_t *host)
 {
 	_cleanup_free_ char *hnqn = NULL;
@@ -272,7 +273,7 @@ static void nvme_filter_tree(struct nvme_global_ctx *ctx, nvme_scan_filter_t f,
 	}
 }
 
-int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *f_args)
+__public int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *f_args)
 {
 	_cleanup_dirents_ struct dirents subsys = {}, ctrls = {};
 	int i, ret;
@@ -323,7 +324,7 @@ int nvme_scan_topology(struct nvme_global_ctx *ctx, nvme_scan_filter_t f, void *
 	return 0;
 }
 
-int nvme_read_config(struct nvme_global_ctx *ctx, const char *config_file)
+__public int nvme_read_config(struct nvme_global_ctx *ctx, const char *config_file)
 {
 	int err;
 
@@ -345,22 +346,22 @@ int nvme_read_config(struct nvme_global_ctx *ctx, const char *config_file)
 	return err;
 }
 
-int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
+__public int nvme_dump_config(struct nvme_global_ctx *ctx, int fd)
 {
 	return json_update_config(ctx, fd);
 }
 
-int nvme_dump_tree(struct nvme_global_ctx *ctx)
+__public int nvme_dump_tree(struct nvme_global_ctx *ctx)
 {
 	return json_dump_tree(ctx);
 }
 
-const char *nvme_get_application(struct nvme_global_ctx *ctx)
+__public const char *nvme_get_application(struct nvme_global_ctx *ctx)
 {
 	return ctx->application;
 }
 
-void nvme_set_application(struct nvme_global_ctx *ctx, const char *a)
+__public void nvme_set_application(struct nvme_global_ctx *ctx, const char *a)
 {
 	free(ctx->application);
 	ctx->application = NULL;
@@ -369,50 +370,50 @@ void nvme_set_application(struct nvme_global_ctx *ctx, const char *a)
 		ctx->application = strdup(a);
 }
 
-void nvme_skip_namespaces(struct nvme_global_ctx *ctx)
+__public void nvme_skip_namespaces(struct nvme_global_ctx *ctx)
 {
 	ctx->create_only = true;
 }
 
-nvme_host_t nvme_first_host(struct nvme_global_ctx *ctx)
+__public nvme_host_t nvme_first_host(struct nvme_global_ctx *ctx)
 {
 	return list_top(&ctx->hosts, struct nvme_host, entry);
 }
 
-nvme_host_t nvme_next_host(struct nvme_global_ctx *ctx, nvme_host_t h)
+__public nvme_host_t nvme_next_host(struct nvme_global_ctx *ctx, nvme_host_t h)
 {
 	return h ? list_next(&ctx->hosts, h, entry) : NULL;
 }
 
-struct nvme_global_ctx *nvme_host_get_global_ctx(nvme_host_t h)
+__public struct nvme_global_ctx *nvme_host_get_global_ctx(nvme_host_t h)
 {
 	return h->ctx;
 }
 
-void nvme_host_set_pdc_enabled(nvme_host_t h, bool enabled)
+__public void nvme_host_set_pdc_enabled(nvme_host_t h, bool enabled)
 {
 	h->pdc_enabled_valid = true;
 	h->pdc_enabled = enabled;
 }
 
-bool nvme_host_is_pdc_enabled(nvme_host_t h, bool fallback)
+__public bool nvme_host_is_pdc_enabled(nvme_host_t h, bool fallback)
 {
 	if (h->pdc_enabled_valid)
 		return h->pdc_enabled;
 	return fallback;
 }
 
-nvme_subsystem_t nvme_first_subsystem(nvme_host_t h)
+__public nvme_subsystem_t nvme_first_subsystem(nvme_host_t h)
 {
 	return list_top(&h->subsystems, struct nvme_subsystem, entry);
 }
 
-nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s)
+__public nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s)
 {
 	return s ? list_next(&h->subsystems, s, entry) : NULL;
 }
 
-void nvme_refresh_topology(struct nvme_global_ctx *ctx)
+__public void nvme_refresh_topology(struct nvme_global_ctx *ctx)
 {
 	struct nvme_host *h, *_h;
 
@@ -429,37 +430,37 @@ void nvme_root_release_fds(struct nvme_global_ctx *ctx)
 		nvme_host_release_fds(h);
 }
 
-nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s)
+__public nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s)
 {
 	return list_top(&s->ctrls, struct nvme_ctrl, entry);
 }
 
-nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c)
+__public nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c)
 {
 	return c ? list_next(&s->ctrls, c, entry) : NULL;
 }
 
-nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s)
+__public nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s)
 {
 	return s->h;
 }
 
-nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s)
+__public nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s)
 {
 	return list_top(&s->namespaces, struct nvme_ns, entry);
 }
 
-nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
+__public nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n)
 {
 	return n ? list_next(&s->namespaces, n, entry) : NULL;
 }
 
-nvme_path_t nvme_namespace_first_path(nvme_ns_t ns)
+__public nvme_path_t nvme_namespace_first_path(nvme_ns_t ns)
 {
 	return list_top(&ns->head->paths, struct nvme_path, nentry);
 }
 
-nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
+__public nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p)
 {
 	return p ? list_next(&ns->head->paths, p, nentry) : NULL;
 }
@@ -484,7 +485,7 @@ static void __nvme_free_ns(struct nvme_ns *n)
 }
 
 /* Stub for SWIG */
-void nvme_free_ns(struct nvme_ns *n)
+__public void nvme_free_ns(struct nvme_ns *n)
 {
 	__nvme_free_ns(n);
 }
@@ -513,7 +514,7 @@ static void __nvme_free_subsystem(struct nvme_subsystem *s)
 	free(s);
 }
 
-void nvme_subsystem_release_fds(struct nvme_subsystem *s)
+__public void nvme_subsystem_release_fds(struct nvme_subsystem *s)
 {
 	struct nvme_ctrl *c, *_c;
 	struct nvme_ns *n, *_n;
@@ -528,7 +529,7 @@ void nvme_subsystem_release_fds(struct nvme_subsystem *s)
 /*
  * Stub for SWIG
  */
-void nvme_free_subsystem(nvme_subsystem_t s)
+__public void nvme_free_subsystem(nvme_subsystem_t s)
 {
 }
 
@@ -577,7 +578,7 @@ struct nvme_subsystem *nvme_lookup_subsystem(struct nvme_host *h,
 	return nvme_alloc_subsystem(h, name, subsysnqn);
 }
 
-int nvme_get_subsystem(struct nvme_global_ctx *ctx,
+__public int nvme_get_subsystem(struct nvme_global_ctx *ctx,
 		struct nvme_host *h, const char *name,
 		const char *subsysnqn, struct nvme_subsystem **subsys)
 {
@@ -606,7 +607,7 @@ void __nvme_free_host(struct nvme_host *h)
 	free(h);
 }
 
-void nvme_host_release_fds(struct nvme_host *h)
+__public void nvme_host_release_fds(struct nvme_host *h)
 {
 	struct nvme_subsystem *s, *_s;
 
@@ -615,7 +616,7 @@ void nvme_host_release_fds(struct nvme_host *h)
 }
 
 /* Stub for SWIG */
-void nvme_free_host(struct nvme_host *h)
+__public void nvme_free_host(struct nvme_host *h)
 {
 	__nvme_free_host(h);
 }
@@ -781,17 +782,17 @@ static int nvme_scan_subsystem(struct nvme_global_ctx *ctx, const char *name)
 	return 0;
 }
 
-nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p)
+__public nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p)
 {
 	return p->c;
 }
 
-nvme_ns_t nvme_path_get_ns(nvme_path_t p)
+__public nvme_ns_t nvme_path_get_ns(nvme_path_t p)
 {
 	return p->n;
 }
 
-int nvme_path_get_queue_depth(nvme_path_t p)
+__public int nvme_path_get_queue_depth(nvme_path_t p)
 {
 	_cleanup_free_ char *queue_depth = NULL;
 
@@ -861,7 +862,7 @@ static int nvme_ctrl_scan_path(struct nvme_global_ctx *ctx, struct nvme_ctrl *c,
 	return 0;
 }
 
-struct nvme_transport_handle *nvme_ctrl_get_transport_handle(nvme_ctrl_t c)
+__public struct nvme_transport_handle *nvme_ctrl_get_transport_handle(nvme_ctrl_t c)
 {
 	if (!c->hdl) {
 		int err;
@@ -875,7 +876,7 @@ struct nvme_transport_handle *nvme_ctrl_get_transport_handle(nvme_ctrl_t c)
 	return c->hdl;
 }
 
-void nvme_ctrl_release_transport_handle(nvme_ctrl_t c)
+__public void nvme_ctrl_release_transport_handle(nvme_ctrl_t c)
 {
 	if (!c->hdl)
 		return;
@@ -884,13 +885,13 @@ void nvme_ctrl_release_transport_handle(nvme_ctrl_t c)
 	c->hdl = NULL;
 }
 
-nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c)
+__public nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c)
 {
 	return c->s;
 }
 
 
-char *nvme_ctrl_get_src_addr(nvme_ctrl_t c, char *src_addr, size_t src_addr_len)
+__public char *nvme_ctrl_get_src_addr(nvme_ctrl_t c, char *src_addr, size_t src_addr_len)
 {
 	size_t l;
 	char *p;
@@ -916,7 +917,7 @@ char *nvme_ctrl_get_src_addr(nvme_ctrl_t c, char *src_addr, size_t src_addr_len)
 	return src_addr;
 }
 
-const char *nvme_ctrl_get_state(nvme_ctrl_t c)
+__public const char *nvme_ctrl_get_state(nvme_ctrl_t c)
 {
 	char *state = c->state;
 
@@ -925,12 +926,12 @@ const char *nvme_ctrl_get_state(nvme_ctrl_t c)
 	return c->state;
 }
 
-struct nvme_fabrics_config *nvme_ctrl_get_config(nvme_ctrl_t c)
+__public struct nvme_fabrics_config *nvme_ctrl_get_config(nvme_ctrl_t c)
 {
 	return &c->cfg;
 }
 
-int nvme_ctrl_identify(nvme_ctrl_t c, struct nvme_id_ctrl *id)
+__public int nvme_ctrl_identify(nvme_ctrl_t c, struct nvme_id_ctrl *id)
 {
 	struct nvme_transport_handle *hdl = nvme_ctrl_get_transport_handle(c);
 	struct nvme_passthru_cmd cmd;
@@ -939,22 +940,22 @@ int nvme_ctrl_identify(nvme_ctrl_t c, struct nvme_id_ctrl *id)
 	return nvme_submit_admin_passthru(hdl, &cmd);
 }
 
-nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c)
+__public nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c)
 {
 	return list_top(&c->namespaces, struct nvme_ns, entry);
 }
 
-nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n)
+__public nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n)
 {
 	return n ? list_next(&c->namespaces, n, entry) : NULL;
 }
 
-nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c)
+__public nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c)
 {
 	return list_top(&c->paths, struct nvme_path, entry);
 }
 
-nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p)
+__public nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p)
 {
 	return p ? list_next(&c->paths, p, entry) : NULL;
 }
@@ -985,7 +986,7 @@ void nvme_deconfigure_ctrl(nvme_ctrl_t c)
 	FREE_CTRL_ATTR(c->phy_slot);
 }
 
-int nvme_disconnect_ctrl(nvme_ctrl_t c)
+__public int nvme_disconnect_ctrl(nvme_ctrl_t c)
 {
 	struct nvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL;
 	int ret;
@@ -1002,7 +1003,7 @@ int nvme_disconnect_ctrl(nvme_ctrl_t c)
 	return 0;
 }
 
-void nvme_unlink_ctrl(nvme_ctrl_t c)
+__public void nvme_unlink_ctrl(nvme_ctrl_t c)
 {
 	list_del_init(&c->entry);
 	c->s = NULL;
@@ -1032,7 +1033,7 @@ static void __nvme_free_ctrl(nvme_ctrl_t c)
 	free(c);
 }
 
-void nvme_free_ctrl(nvme_ctrl_t c)
+__public void nvme_free_ctrl(nvme_ctrl_t c)
 {
 	__nvme_free_ctrl(c);
 }
@@ -1054,14 +1055,14 @@ static bool traddr_is_hostname(const char *transport, const char *traddr)
 	return true;
 }
 
-void nvmf_default_config(struct nvme_fabrics_config *cfg)
+__public void nvmf_default_config(struct nvme_fabrics_config *cfg)
 {
 	memset(cfg, 0, sizeof(*cfg));
 	cfg->tos = -1;
 	cfg->ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO;
 }
 
-int nvme_create_ctrl(struct nvme_global_ctx *ctx,
+__public int nvme_create_ctrl(struct nvme_global_ctx *ctx,
 		     const char *subsysnqn, const char *transport,
 		     const char *traddr, const char *host_traddr,
 	   	     const char *host_iface, const char *trsvcid,
@@ -1461,7 +1462,7 @@ nvme_ctrl_t __nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport,
 	return matching_c;
 }
 
-bool nvme_ctrl_match_config(struct nvme_ctrl *c, const char *transport,
+__public bool nvme_ctrl_match_config(struct nvme_ctrl *c, const char *transport,
 			    const char *traddr, const char *trsvcid,
 			    const char *subsysnqn, const char *host_traddr,
 			    const char *host_iface)
@@ -1756,7 +1757,7 @@ static int nvme_reconfigure_ctrl(struct nvme_global_ctx *ctx, nvme_ctrl_t c, con
 	return 0;
 }
 
-int nvme_init_ctrl(nvme_host_t h, nvme_ctrl_t c, int instance)
+__public int nvme_init_ctrl(nvme_host_t h, nvme_ctrl_t c, int instance)
 {
 	_cleanup_free_ char *subsys_name = NULL, *name = NULL, *path = NULL;
 	nvme_subsystem_t s;
@@ -1897,7 +1898,7 @@ int nvme_ctrl_alloc(struct nvme_global_ctx *ctx, nvme_subsystem_t s,
 	return 0;
 }
 
-int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name,
+__public int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name,
 		   nvme_ctrl_t *cp)
 {
 	_cleanup_free_ char *subsysnqn = NULL, *subsysname = NULL;
@@ -1964,7 +1965,7 @@ int nvme_scan_ctrl(struct nvme_global_ctx *ctx, const char *name,
 	return 0;
 }
 
-void nvme_rescan_ctrl(struct nvme_ctrl *c)
+__public void nvme_rescan_ctrl(struct nvme_ctrl *c)
 {
 	struct nvme_global_ctx *ctx = c->s && c->s->h ? c->s->h->ctx : NULL;
 	if (!c->s)
@@ -2018,12 +2019,12 @@ void nvme_ns_release_transport_handle(nvme_ns_t n)
 	n->hdl = NULL;
 }
 
-nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n)
+__public nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n)
 {
 	return n->s;
 }
 
-nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n)
+__public nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n)
 {
 	return n->c;
 }
@@ -2033,47 +2034,47 @@ const char *nvme_ns_head_get_sysfs_dir(nvme_ns_head_t head)
 	return head->sysfs_dir;
 }
 
-const char *nvme_ns_get_generic_name(nvme_ns_t n)
+__public const char *nvme_ns_get_generic_name(nvme_ns_t n)
 {
 	return n->generic_name;
 }
 
-const char *nvme_ns_get_model(nvme_ns_t n)
+__public const char *nvme_ns_get_model(nvme_ns_t n)
 {
 	return n->c ? n->c->model : n->s->model;
 }
 
-const char *nvme_ns_get_serial(nvme_ns_t n)
+__public const char *nvme_ns_get_serial(nvme_ns_t n)
 {
 	return n->c ? n->c->serial : n->s->serial;
 }
 
-const char *nvme_ns_get_firmware(nvme_ns_t n)
+__public const char *nvme_ns_get_firmware(nvme_ns_t n)
 {
 	return n->c ? n->c->firmware : n->s->firmware;
 }
 
-enum nvme_csi nvme_ns_get_csi(nvme_ns_t n)
+__public enum nvme_csi nvme_ns_get_csi(nvme_ns_t n)
 {
 	return n->csi;
 }
 
-const uint8_t *nvme_ns_get_eui64(nvme_ns_t n)
+__public const uint8_t *nvme_ns_get_eui64(nvme_ns_t n)
 {
 	return n->eui64;
 }
 
-const uint8_t *nvme_ns_get_nguid(nvme_ns_t n)
+__public const uint8_t *nvme_ns_get_nguid(nvme_ns_t n)
 {
 	return n->nguid;
 }
 
-void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN])
+__public void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN])
 {
 	memcpy(out, n->uuid, NVME_UUID_LEN);
 }
 
-int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
+__public int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2101,7 +2102,7 @@ int nvme_ns_identify_descs(nvme_ns_t n, struct nvme_ns_id_desc *descs)
 	return nvme_submit_admin_passthru(hdl, &cmd);
 }
 
-int nvme_ns_verify(nvme_ns_t n, off_t offset, size_t count)
+__public int nvme_ns_verify(nvme_ns_t n, off_t offset, size_t count)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2122,7 +2123,7 @@ int nvme_ns_verify(nvme_ns_t n, off_t offset, size_t count)
 	return nvme_submit_io_passthru(hdl, &cmd);
 }
 
-int nvme_ns_write_uncorrectable(nvme_ns_t n, off_t offset, size_t count)
+__public int nvme_ns_write_uncorrectable(nvme_ns_t n, off_t offset, size_t count)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2143,7 +2144,7 @@ int nvme_ns_write_uncorrectable(nvme_ns_t n, off_t offset, size_t count)
 	return nvme_submit_io_passthru(hdl, &cmd);
 }
 
-int nvme_ns_write_zeros(nvme_ns_t n, off_t offset, size_t count)
+__public int nvme_ns_write_zeros(nvme_ns_t n, off_t offset, size_t count)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2163,7 +2164,7 @@ int nvme_ns_write_zeros(nvme_ns_t n, off_t offset, size_t count)
 	return nvme_submit_io_passthru(hdl, &cmd);
 }
 
-int nvme_ns_write(nvme_ns_t n, void *buf, off_t offset, size_t count)
+__public int nvme_ns_write(nvme_ns_t n, void *buf, off_t offset, size_t count)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2184,7 +2185,7 @@ int nvme_ns_write(nvme_ns_t n, void *buf, off_t offset, size_t count)
 	return nvme_submit_io_passthru(hdl, &cmd);
 }
 
-int nvme_ns_read(nvme_ns_t n, void *buf, off_t offset, size_t count)
+__public int nvme_ns_read(nvme_ns_t n, void *buf, off_t offset, size_t count)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2205,7 +2206,7 @@ int nvme_ns_read(nvme_ns_t n, void *buf, off_t offset, size_t count)
 	return nvme_submit_io_passthru(hdl, &cmd);
 }
 
-int nvme_ns_compare(nvme_ns_t n, void *buf, off_t offset, size_t count)
+__public int nvme_ns_compare(nvme_ns_t n, void *buf, off_t offset, size_t count)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2226,7 +2227,7 @@ int nvme_ns_compare(nvme_ns_t n, void *buf, off_t offset, size_t count)
 	return nvme_submit_io_passthru(hdl, &cmd);
 }
 
-int nvme_ns_flush(nvme_ns_t n)
+__public int nvme_ns_flush(nvme_ns_t n)
 {
 	struct nvme_transport_handle *hdl;
 	struct nvme_passthru_cmd cmd;
@@ -2539,7 +2540,7 @@ static int __nvme_scan_namespace(struct nvme_global_ctx *ctx,
 	return 0;
 }
 
-int nvme_scan_namespace(struct nvme_global_ctx *ctx, const char *name,
+__public int nvme_scan_namespace(struct nvme_global_ctx *ctx, const char *name,
 		nvme_ns_t *ns)
 {
 	return __nvme_scan_namespace(ctx, nvme_ns_sysfs_dir(), name, ns);
@@ -2664,7 +2665,7 @@ static int nvme_subsystem_scan_namespace(struct nvme_global_ctx *ctx, nvme_subsy
 	return 0;
 }
 
-struct nvme_ns *nvme_subsystem_lookup_namespace(struct nvme_subsystem *s,
+__public struct nvme_ns *nvme_subsystem_lookup_namespace(struct nvme_subsystem *s,
 						__u32 nsid)
 {
 	struct nvme_ns *n;
diff --git a/libnvme/src/nvme/util.c b/libnvme/src/nvme/util.c
index 842a52027f..70916d566d 100644
--- a/libnvme/src/nvme/util.c
+++ b/libnvme/src/nvme/util.c
@@ -30,6 +30,7 @@
 #include "cleanup.h"
 #include "private.h"
 #include "util.h"
+#include "compiler_attributes.h"
 
 /* The bionic libc implementation doesn't define LINE_MAX */
 #ifndef LINE_MAX
@@ -174,7 +175,7 @@ static inline __u8 nvme_fabrics_status_to_errno(__u16 status)
 	return EIO;
 }
 
-__u8 nvme_status_to_errno(int status, bool fabrics)
+__public __u8 nvme_status_to_errno(int status, bool fabrics)
 {
 	__u16 sc;
 
@@ -373,7 +374,7 @@ static const char *arg_str(const char * const *strings,
 	return "unrecognized";
 }
 
-const char *nvme_status_to_string(int status, bool fabrics)
+__public const char *nvme_status_to_string(int status, bool fabrics)
 {
 	const char *s = "Unknown status";
 	__u16 sc, sct;
@@ -437,14 +438,14 @@ static const char * const libnvme_status[] = {
 	[ENVME_CONNECT_NOKEY] = "pre-shared TLS key is missing"
 };
 
-const char *nvme_errno_to_string(int status)
+__public const char *nvme_errno_to_string(int status)
 {
 	const char *s = ARGSTR(libnvme_status, status);
 
 	return s;
 }
 
-const char *nvme_strerror(int errnum)
+__public const char *nvme_strerror(int errnum)
 {
 	if (errnum >= ENVME_CONNECT_RESOLVE)
 		return nvme_errno_to_string(errnum);
@@ -705,13 +706,13 @@ size_t get_entity_version(char *buffer, size_t bufsz)
 	return num_bytes;
 }
 
-struct nvmf_ext_attr *nvmf_exat_ptr_next(struct nvmf_ext_attr *p)
+__public struct nvmf_ext_attr *nvmf_exat_ptr_next(struct nvmf_ext_attr *p)
 {
 	return (struct nvmf_ext_attr *)
 		((uintptr_t)p + (ptrdiff_t)nvmf_exat_size(le16_to_cpu(p->exatlen)));
 }
 
-const char *nvme_get_version(enum nvme_version type)
+__public const char *nvme_get_version(enum nvme_version type)
 {
 	switch(type) {
 	case NVME_VERSION_PROJECT:
@@ -723,7 +724,7 @@ const char *nvme_get_version(enum nvme_version type)
 	}
 }
 
-int nvme_uuid_to_string(unsigned char uuid[NVME_UUID_LEN], char *str)
+__public int nvme_uuid_to_string(unsigned char uuid[NVME_UUID_LEN], char *str)
 {
 	int n;
 	n = snprintf(str, NVME_UUID_LEN_STRING,
@@ -735,7 +736,7 @@ int nvme_uuid_to_string(unsigned char uuid[NVME_UUID_LEN], char *str)
 	return n != NVME_UUID_LEN_STRING - 1 ? -EINVAL : 0;
 }
 
-int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN])
+__public int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN])
 {
 	int n;
 
@@ -749,7 +750,7 @@ int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN])
 
 }
 
-int nvme_random_uuid(unsigned char uuid[NVME_UUID_LEN])
+__public int nvme_random_uuid(unsigned char uuid[NVME_UUID_LEN])
 {
 	_cleanup_fd_ int f = -1;
 	ssize_t n;
@@ -774,7 +775,7 @@ int nvme_random_uuid(unsigned char uuid[NVME_UUID_LEN])
 	return 0;
 }
 
-int nvme_find_uuid(struct nvme_id_uuid_list *uuid_list,
+__public int nvme_find_uuid(struct nvme_id_uuid_list *uuid_list,
 		const unsigned char uuid[NVME_UUID_LEN])
 {
 	const unsigned char uuid_end[NVME_UUID_LEN] = {0};
diff --git a/libnvme/test/meson.build b/libnvme/test/meson.build
index 5f952a3509..035070a992 100644
--- a/libnvme/test/meson.build
+++ b/libnvme/test/meson.build
@@ -5,6 +5,18 @@
 #
 # Authors: Martin Belanger <Martin.Belanger@dell.com>
 
+python3_prog = find_program('python3', required: false)
+if python3_prog.found()
+    test(
+        'libnvme - check-public-symbols',
+        python3_prog,
+        args: [
+            files('../tools/check-public-symbols.py'),
+            meson.project_source_root() / 'libnvme',
+        ],
+    )
+endif
+
 # These tests all require interaction with a real NVMe device, so we don't
 # define as meson unit-tests, and therefore get run as part of the 'test'
 # target. However, they're available for developer use, when hardware is
diff --git a/libnvme/tools/check-public-symbols.py b/libnvme/tools/check-public-symbols.py
new file mode 100644
index 0000000000..f9a0054503
--- /dev/null
+++ b/libnvme/tools/check-public-symbols.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: LGPL-2.1-or-later
+#
+# This file is part of libnvme.
+# Copyright (c) 2025, Dell Technologies Inc. or its subsidiaries.
+#
+# Authors: Martin Belanger <Martin.Belanger@dell.com>
+#
+# Verify that __public annotations and version-script entries are
+# kept in sync:
+#
+#   1. Every function definition annotated with __public in a .c
+#      file must appear in one of the three version scripts (libnvme.ld,
+#      libnvmf.ld, accessors.ld).  A function that is annotated but not
+#      listed is visible to the compiler but silently hidden by the linker
+#      version script's "local: *;" catch-all — the developer's intent to
+#      export it would be silently ignored.
+#
+#   2. Every symbol listed in a version script must have a __public
+#      annotation on its definition.  Without the annotation the symbol is
+#      hidden at compile time (due to -fvisibility=hidden) and the build
+#      will either fail to link or produce a .so that is missing the symbol.
+#
+# Usage (standalone):
+#   python3 tools/check-public-symbols.py [LIBNVME-SOURCE-ROOT]
+#
+# The source root defaults to the parent directory of this script.
+
+import re
+import sys
+import pathlib
+
+ROOT = pathlib.Path(sys.argv[1]) if len(sys.argv) > 1 else \
+       pathlib.Path(__file__).resolve().parent.parent
+
+SRC_DIR = ROOT / 'src' / 'nvme'
+LD_FILES = [
+    ROOT / 'src' / 'libnvme.ld',
+    ROOT / 'src' / 'libnvmf.ld',
+    ROOT / 'src' / 'accessors.ld',
+]
+
+# ---------------------------------------------------------------------------
+# Collect symbols listed in the version scripts
+# ---------------------------------------------------------------------------
+ld_syms = {}   # symbol -> Path of the .ld file that declares it
+
+for ld_path in LD_FILES:
+    if not ld_path.exists():
+        continue
+    for line in ld_path.read_text().splitlines():
+        m = re.match(r'^\s+([a-z]\w+);', line)
+        if m:
+            ld_syms[m.group(1)] = ld_path
+
+# ---------------------------------------------------------------------------
+# Collect function names annotated with __public in .c files
+# ---------------------------------------------------------------------------
+# Match: __public <return-type> [*] function_name(
+# The .*\b is greedy so it skips over the return type and any __attribute__
+# qualifiers, leaving the last identifier before '(' as the function name.
+PUB_RE = re.compile(r'^__public\b.*\b([a-z_]\w+)\s*\(', re.MULTILINE)
+
+pub_syms = {}  # symbol -> Path of the .c file that defines it
+
+for c_path in sorted(SRC_DIR.glob('*.c')):
+    for m in PUB_RE.finditer(c_path.read_text()):
+        sym = m.group(1)
+        pub_syms[sym] = c_path
+
+# ---------------------------------------------------------------------------
+# Report mismatches
+# ---------------------------------------------------------------------------
+errors = 0
+
+# Check 1: __public in .c but missing from all .ld files
+for sym, c_path in sorted(pub_syms.items()):
+    if sym not in ld_syms:
+        print(f'ERROR: {sym}() is annotated __public in '
+              f'{c_path.name} but is not listed in any version script')
+        errors += 1
+
+# Check 2: listed in a .ld file but no __public definition found
+for sym, ld_path in sorted(ld_syms.items()):
+    if sym not in pub_syms:
+        print(f'ERROR: {sym}() is listed in {ld_path.name} but has no '
+              f'__public definition in {SRC_DIR.name}/*.c')
+        errors += 1
+
+if errors:
+    print(f'\n{errors} error(s) found.')
+    sys.exit(1)
+
+print(f'OK: {len(pub_syms)} __public symbols all present in version '
+      f'scripts; {len(ld_syms)} version-script entries all annotated.')
diff --git a/libnvme/tools/generator/generate-accessors.py b/libnvme/tools/generator/generate-accessors.py
index 3fc159bfc2..e8085eedb7 100755
--- a/libnvme/tools/generator/generate-accessors.py
+++ b/libnvme/tools/generator/generate-accessors.py
@@ -392,7 +392,7 @@ def generate_hdr(f, prefix, struct_name, members):
 # Source (*.c) code emitters
 # ---------------------------------------------------------------------------
 
-PUB = ''  # PUB = '__public '  # Uncomment when merging the __public branch
+PUB = '__public '
 
 
 def emit_src_setter_dynstr(f, prefix, sname, mname):
@@ -646,7 +646,7 @@ def main():
         )
         for fname in files_to_include:
             f.write(f'#include "{fname}"\n')
-        # f.write('#include "compiler_attributes.h"\n')  # Uncomment when merging the __public branch
+        f.write('#include "compiler_attributes.h"\n')
         f.write('\n')
         f.write(''.join(src_parts))